.+)$"
+ )
+ for line in self.whats_new.splitlines():
+ match = bullet_re.match(line)
+ if not match:
+ continue
+ label = match.group("label").strip().rstrip(":").strip()
+ text = match.group("text").strip()
+ if not text:
+ continue
+ items.append(
+ {
+ "title": label,
+ "description": text,
+ }
+ )
+ return items
+
class OperatingSystems(models.TextChoices):
UNIX = "Unix", "Unix"
diff --git a/versions/releases.py b/versions/releases.py
index 8b431e249..24c8f4fc8 100644
--- a/versions/releases.py
+++ b/versions/releases.py
@@ -345,6 +345,12 @@ def store_release_notes_for_version(version_pk):
logger.info(
f"store_release_notes_for_version_success {rendered_content.id=} {version.name=}"
)
+
+ if not version.whats_new:
+ from versions.tasks import dispatch_whats_new
+
+ dispatch_whats_new(version.pk)
+
return rendered_content
diff --git a/versions/tasks.py b/versions/tasks.py
index 338f21ee4..b47f08c6d 100644
--- a/versions/tasks.py
+++ b/versions/tasks.py
@@ -1,3 +1,14 @@
+"""Celery tasks for the versions app.
+
+Covers Boost release ingestion (versions, library-versions, downloads, release
+notes) and the AI-generated "What's New" summary pipeline. The AI tasks
+(``generate_whats_new`` / ``save_whats_new`` / ``dispatch_whats_new``) live at
+the bottom of this module.
+"""
+
+import re
+from textwrap import dedent
+
from django.db import transaction
import requests
import structlog
@@ -5,9 +16,13 @@
from celery import group, chain
from config.celery import app
+from config.settings import OPENROUTER_API_KEY, OPENROUTER_URL
from django.conf import settings
from django.core.management import call_command
+from django.utils import timezone
+from django.utils.html import strip_tags
from fastcore.xtras import obj2dict
+from openai import OpenAI, OpenAIError
from core.githubhelper import GithubAPIClient, GithubDataParser
from libraries.constants import SKIP_LIBRARY_VERSIONS
@@ -603,3 +618,157 @@ def skip_tag(name, new=False):
return True
return False
+
+
+# ---------------------------------------------------------------------------
+# AI tasks: "What's New" release-note summarization
+# ---------------------------------------------------------------------------
+
+
+WHATS_NEW_MODEL = "gpt-oss-120b"
+# Guardrail to keep the LLM call comfortably under the model's context window
+# (gpt-oss-120b is ~131K tokens; ~100K chars leaves headroom for the system
+# prompt + output). Inputs above this are truncated.
+WHATS_NEW_MAX_INPUT_CHARS = 100_000
+
+WHATS_NEW_SYSTEM_PROMPT = dedent(
+ """
+ You are a technical writer for the Boost C++ library ecosystem. Your job is
+ to read a Boost release note and generate a "What's New" summary for the
+ Boost website.
+
+ Rules:
+
+ Return the output as a Markdown unordered list: every line must begin
+ with "- " and there must be no other lines
+ Return a maximum of 5 bullets, each with a bold category label,
+ and a single sentence of no more than 20 words
+ Do not use emoji anywhere in the output
+ Do not name or highlight specific libraries — speak to the ecosystem as a whole
+ Only include a bullet if there is relevant content in the release note to
+ support it
+ Omit any category that has no relevant content — do not pad or fabricate
+ Follow this rubric and order where content exists:
+
+ New libraries — how many new libraries were added and what they broadly cover
+ Performance improvements — notable speed, memory, or compile time gains across the release
+ Dependencies — notable changes to library dependencies, removals, or newly introduced requirements
+ Security & reliability — bug fixes, security updates, and stability improvements
+ Developer experience — constexpr support, tooling improvements, or better error handling
+
+ Input: release note
+
+ Output: Return only the Markdown unordered list. No preamble, no
+ explanation, no additional commentary.
+ """
+).strip()
+
+
+def _release_note_text(rendered_content) -> str:
+ """Extract the plain-text release note used as the LLM input.
+
+ AsciiDoc originals are passed through directly (LLMs handle the markup);
+ HTML originals are stripped of tags. Whitespace is collapsed either way.
+ """
+ if (
+ rendered_content.content_type == "text/asciidoc"
+ and rendered_content.content_original
+ ):
+ raw = rendered_content.content_original
+ else:
+ raw = strip_tags(rendered_content.content_html or "")
+ return re.sub(r"[ \t]+\n", "\n", re.sub(r"\n{3,}", "\n\n", raw)).strip()
+
+
+@app.task(bind=True, max_retries=3, autoretry_for=(OpenAIError,))
+def generate_whats_new(self, version_pk: int) -> str | None:
+ """Generate a draft What's New summary for the given Version's release notes."""
+ from core.models import RenderedContent
+
+ try:
+ version = Version.objects.with_partials().get(pk=version_pk)
+ except Version.DoesNotExist:
+ logger.error("generate_whats_new_version_not_found", version_pk=version_pk)
+ return None
+
+ rendered_content = RenderedContent.objects.filter(
+ cache_key=version.release_notes_cache_key
+ ).first()
+ if not rendered_content or not (
+ rendered_content.content_html or rendered_content.content_original
+ ):
+ logger.info(
+ "generate_whats_new_no_release_notes",
+ version_pk=version_pk,
+ cache_key=version.release_notes_cache_key,
+ )
+ return None
+
+ release_note_text = _release_note_text(rendered_content)
+ if len(release_note_text) > WHATS_NEW_MAX_INPUT_CHARS:
+ logger.warning(
+ "generate_whats_new_truncating_input",
+ version_pk=version_pk,
+ original_chars=len(release_note_text),
+ max_chars=WHATS_NEW_MAX_INPUT_CHARS,
+ )
+ release_note_text = release_note_text[:WHATS_NEW_MAX_INPUT_CHARS]
+
+ logger.info(
+ "generate_whats_new_dispatching",
+ version_pk=version_pk,
+ version_name=version.name,
+ input_chars=len(release_note_text),
+ )
+
+ messages = [
+ {"role": "system", "content": WHATS_NEW_SYSTEM_PROMPT},
+ {"role": "user", "content": release_note_text},
+ ]
+ client = OpenAI(base_url=OPENROUTER_URL, api_key=OPENROUTER_API_KEY)
+ try:
+ response = client.chat.completions.create(
+ model=WHATS_NEW_MODEL, messages=messages
+ )
+ content = response.choices[0].message.content
+ except OpenAIError:
+ # Let autoretry_for=(OpenAIError,) on the task handle retries.
+ logger.exception("generate_whats_new_openai_error", version_pk=version_pk)
+ raise
+ except (AttributeError, IndexError) as e:
+ logger.error("generate_whats_new_response_error", error=str(e))
+ return None
+
+ logger.info(
+ "generate_whats_new_received",
+ version_pk=version_pk,
+ output_chars=len(content) if content else 0,
+ )
+ return content
+
+
+@app.task
+def save_whats_new(markdown_text: str | None, version_pk: int):
+ """Persist a generated summary on the Version.
+
+ Resets ``whats_new_approved`` to False so regenerated content goes back
+ through admin moderation before it becomes visible on the public site.
+ """
+ if not markdown_text:
+ logger.info("save_whats_new_empty_skip", version_pk=version_pk)
+ return
+
+ Version.objects.filter(pk=version_pk).update(
+ whats_new=markdown_text,
+ whats_new_generated_at=timezone.now(),
+ whats_new_approved=False,
+ )
+ logger.info("save_whats_new_saved", version_pk=version_pk)
+
+
+def dispatch_whats_new(version_pk: int) -> None:
+ """Queue the generate→save chain for a single Version."""
+ generate_whats_new.apply_async(
+ args=[version_pk],
+ link=save_whats_new.s(version_pk),
+ )
diff --git a/versions/tests/test_ai_tasks.py b/versions/tests/test_ai_tasks.py
new file mode 100644
index 000000000..1c192baba
--- /dev/null
+++ b/versions/tests/test_ai_tasks.py
@@ -0,0 +1,205 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from model_bakery import baker
+from openai import APIError
+
+from core.models import RenderedContent
+from versions.tasks import (
+ WHATS_NEW_MAX_INPUT_CHARS,
+ generate_whats_new,
+ save_whats_new,
+)
+from versions.models import Version
+
+
+SAMPLE_OUTPUT = (
+ "- **New libraries** — Three new libraries broaden coverage of "
+ "scientific computing and modern C++ patterns.\n"
+ "- **Performance improvements** — Compile-time and runtime gains "
+ "are reported across multiple core components.\n"
+ "- **Security & reliability** — Several stability and correctness "
+ "fixes land in this release.\n"
+)
+
+
+def _mock_openai_response(content: str):
+ response = MagicMock()
+ response.choices = [MagicMock()]
+ response.choices[0].message.content = content
+ return response
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_populates_field(version):
+ baker.make(
+ RenderedContent,
+ cache_key=version.release_notes_cache_key,
+ content_type="text/asciidoc",
+ content_original="Big release with new libraries and perf fixes.",
+ content_html="Big release with new libraries and perf fixes.
",
+ )
+
+ with patch("versions.tasks.OpenAI") as mock_openai:
+ client = mock_openai.return_value
+ client.chat.completions.create.return_value = _mock_openai_response(
+ SAMPLE_OUTPUT
+ )
+ result = generate_whats_new.run(version.pk)
+
+ assert result == SAMPLE_OUTPUT
+ save_whats_new.run(result, version.pk)
+
+ version.refresh_from_db()
+ assert version.whats_new == SAMPLE_OUTPUT
+ assert len(version.whats_new_items) == 3
+ assert version.whats_new_generated_at is not None
+ # Drafts must not auto-publish.
+ assert version.whats_new_approved is False
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_no_release_notes_returns_none(version):
+ # No RenderedContent row for this version's cache key.
+ with patch("versions.tasks.OpenAI") as mock_openai:
+ result = generate_whats_new.run(version.pk)
+
+ assert result is None
+ mock_openai.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_version_not_found_returns_none():
+ with patch("versions.tasks.OpenAI") as mock_openai:
+ result = generate_whats_new.run(999999)
+
+ assert result is None
+ mock_openai.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_save_whats_new_skips_empty(version):
+ save_whats_new.run(None, version.pk)
+ save_whats_new.run("", version.pk)
+
+ version.refresh_from_db()
+ assert version.whats_new == ""
+ assert version.whats_new_generated_at is None
+
+
+@pytest.mark.django_db
+def test_save_whats_new_resets_approval(version):
+ Version.objects.filter(pk=version.pk).update(whats_new_approved=True)
+ save_whats_new.run(SAMPLE_OUTPUT, version.pk)
+
+ version.refresh_from_db()
+ assert version.whats_new_approved is False
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_truncates_long_input(version):
+ long_text = "x" * (WHATS_NEW_MAX_INPUT_CHARS + 50_000)
+ baker.make(
+ RenderedContent,
+ cache_key=version.release_notes_cache_key,
+ content_type="text/asciidoc",
+ content_original=long_text,
+ )
+
+ with patch("versions.tasks.OpenAI") as mock_openai:
+ client = mock_openai.return_value
+ client.chat.completions.create.return_value = _mock_openai_response(
+ SAMPLE_OUTPUT
+ )
+ generate_whats_new.run(version.pk)
+
+ sent_messages = client.chat.completions.create.call_args.kwargs["messages"]
+ user_content = next(m["content"] for m in sent_messages if m["role"] == "user")
+ assert len(user_content) == WHATS_NEW_MAX_INPUT_CHARS
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_propagates_openai_error(version):
+ baker.make(
+ RenderedContent,
+ cache_key=version.release_notes_cache_key,
+ content_type="text/asciidoc",
+ content_original="release notes",
+ )
+
+ with patch("versions.tasks.OpenAI") as mock_openai:
+ client = mock_openai.return_value
+ # APIError is a concrete OpenAIError subclass.
+ client.chat.completions.create.side_effect = APIError(
+ message="boom", request=MagicMock(), body=None
+ )
+ with pytest.raises(APIError):
+ generate_whats_new.run(version.pk)
+
+
+@pytest.mark.django_db
+def test_whats_new_items_parses_bullets(version):
+ Version.objects.filter(pk=version.pk).update(whats_new=SAMPLE_OUTPUT)
+ version.refresh_from_db()
+
+ items = version.whats_new_items
+ assert len(items) == 3
+ assert items[0]["title"] == "New libraries"
+ assert items[0]["description"].startswith("Three new libraries")
+ assert items[1]["title"] == "Performance improvements"
+ assert items[2]["title"] == "Security & reliability"
+
+
+@pytest.mark.django_db
+def test_whats_new_items_empty_when_unset(version):
+ assert version.whats_new == ""
+ assert version.whats_new_items == []
+
+
+@pytest.mark.django_db
+def test_whats_new_items_ignores_non_bullet_lines(version):
+ Version.objects.filter(pk=version.pk).update(
+ whats_new=(
+ "Some preamble that should be ignored.\n"
+ "- **New libraries** — One library added.\n"
+ "Trailing line without bullet.\n"
+ )
+ )
+ version.refresh_from_db()
+ items = version.whats_new_items
+ assert len(items) == 1
+ assert items[0]["title"] == "New libraries"
+
+
+@pytest.mark.django_db
+def test_whats_new_items_parses_colon_in_label(version):
+ """A colon inside the bold label is stripped; the bullet marker is
+ still required."""
+ Version.objects.filter(pk=version.pk).update(
+ whats_new=(
+ "- **New libraries:** One new library introduces open-method support.\n"
+ "* **Performance improvements:** Container redesigns deliver speed gains.\n"
+ )
+ )
+ version.refresh_from_db()
+ items = version.whats_new_items
+ assert len(items) == 2
+ assert items[0]["title"] == "New libraries"
+ assert items[0]["description"].startswith("One new library")
+ assert items[1]["title"] == "Performance improvements"
+
+
+@pytest.mark.django_db
+def test_whats_new_items_ignores_dashless_lines(version):
+ """Lines without a leading bullet marker are not list items and are
+ skipped."""
+ Version.objects.filter(pk=version.pk).update(
+ whats_new=(
+ "**New libraries:** This line has no bullet marker.\n"
+ "- **Performance improvements** — This one does.\n"
+ )
+ )
+ version.refresh_from_db()
+ items = version.whats_new_items
+ assert len(items) == 1
+ assert items[0]["title"] == "Performance improvements"
diff --git a/versions/tests/test_commands.py b/versions/tests/test_commands.py
new file mode 100644
index 000000000..3dbf38374
--- /dev/null
+++ b/versions/tests/test_commands.py
@@ -0,0 +1,144 @@
+from unittest.mock import patch
+
+import pytest
+from django.core.management import call_command
+from model_bakery import baker
+
+from core.models import RenderedContent
+
+
+@pytest.fixture
+def version_with_notes(db):
+ v = baker.make(
+ "versions.Version",
+ name="boost-1.84.0",
+ active=True,
+ fully_imported=True,
+ )
+ baker.make(
+ RenderedContent,
+ cache_key=v.release_notes_cache_key,
+ content_html="notes
",
+ )
+ return v
+
+
+@pytest.fixture
+def version_with_notes_and_summary(db):
+ v = baker.make(
+ "versions.Version",
+ name="boost-1.85.0",
+ active=True,
+ fully_imported=True,
+ whats_new="- **New libraries** — already populated.",
+ )
+ baker.make(
+ RenderedContent,
+ cache_key=v.release_notes_cache_key,
+ content_html="notes
",
+ )
+ return v
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_dry_run_does_not_dispatch(version_with_notes):
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command("generate_whats_new", "--all-missing", "--dry-run")
+
+ mock_dispatch.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_all_missing_skips_populated(
+ version_with_notes, version_with_notes_and_summary
+):
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command("generate_whats_new", "--all-missing")
+
+ mock_dispatch.assert_called_once_with(version_with_notes.pk)
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_force_includes_populated(
+ version_with_notes, version_with_notes_and_summary
+):
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command("generate_whats_new", "--all-missing", "--force")
+
+ queued_pks = {call.args[0] for call in mock_dispatch.call_args_list}
+ assert queued_pks == {version_with_notes.pk, version_with_notes_and_summary.pk}
+
+ # --force only controls which versions are queued; the existing summary
+ # is left intact until the chained save task lands its replacement.
+ version_with_notes_and_summary.refresh_from_db()
+ assert version_with_notes_and_summary.whats_new != ""
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_version_skips_populated_without_force(
+ version_with_notes_and_summary,
+):
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command(
+ "generate_whats_new", "--version", version_with_notes_and_summary.slug
+ )
+
+ mock_dispatch.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_version_with_force_overrides_populated(
+ version_with_notes_and_summary,
+):
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command(
+ "generate_whats_new",
+ "--version",
+ version_with_notes_and_summary.slug,
+ "--force",
+ )
+
+ mock_dispatch.assert_called_once_with(version_with_notes_and_summary.pk)
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_skips_versions_without_release_notes(db):
+ baker.make(
+ "versions.Version",
+ name="boost-1.86.0",
+ active=True,
+ fully_imported=True,
+ )
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command("generate_whats_new", "--all-missing")
+
+ mock_dispatch.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_single_version(version_with_notes):
+ with patch(
+ "versions.management.commands.generate_whats_new.dispatch_whats_new"
+ ) as mock_dispatch:
+ call_command("generate_whats_new", "--version", version_with_notes.slug)
+
+ mock_dispatch.assert_called_once_with(version_with_notes.pk)
+
+
+@pytest.mark.django_db
+def test_generate_whats_new_requires_an_action():
+ with pytest.raises(Exception):
+ # djclick raises UsageError; pytest treats it as failure.
+ call_command("generate_whats_new")
diff --git a/versions/tests/test_releases.py b/versions/tests/test_releases.py
index 5835a692b..7ec55c61b 100644
--- a/versions/tests/test_releases.py
+++ b/versions/tests/test_releases.py
@@ -1,15 +1,18 @@
+from unittest.mock import patch
+
import responses
import pytest
from django.conf import settings
-from ..models import VersionFile
+from ..models import Version, VersionFile
from ..releases import (
get_artifactory_download_data,
get_archives_download_data,
get_artifactory_download_uris_for_release,
get_archives_download_uris_for_release,
store_release_downloads_for_version,
+ store_release_notes_for_version,
)
@@ -135,3 +138,33 @@ def test_store_release_downloads_for_version(version):
assert VersionFile.objects.filter(version=version).count() == count + 2
assert VersionFile.objects.filter(version=version, checksum="123").exists()
assert VersionFile.objects.filter(version=version, checksum="456").exists()
+
+
+@pytest.mark.django_db
+def test_store_release_notes_queues_whats_new_when_missing(version):
+ with (
+ patch(
+ "versions.releases.get_release_notes_for_version",
+ return_value=("notes
", "notes
", "text/html"),
+ ),
+ patch("versions.tasks.dispatch_whats_new") as mock_dispatch,
+ ):
+ store_release_notes_for_version(version.pk)
+
+ mock_dispatch.assert_called_once_with(version.pk)
+
+
+@pytest.mark.django_db
+def test_store_release_notes_skips_whats_new_when_populated(version):
+ Version.objects.filter(pk=version.pk).update(whats_new="- already there")
+
+ with (
+ patch(
+ "versions.releases.get_release_notes_for_version",
+ return_value=("notes
", "notes
", "text/html"),
+ ),
+ patch("versions.tasks.dispatch_whats_new") as mock_dispatch,
+ ):
+ store_release_notes_for_version(version.pk)
+
+ mock_dispatch.assert_not_called()