@event4u/agent-config 3.1.0 → 3.2.0

package/scripts/release.py

@@ -12,7 +12,11 @@ Pipeline:
                            since the last tag, render CHANGELOG section.
     3. Confirm           — show preview, ask once (skippable with --yes).
     4. Branch + bump     — create `release/X.Y.Z`, update package.json,
-                           .claude-plugin/marketplace.json, CHANGELOG.md.
+                           .claude-plugin/marketplace.json, CHANGELOG.md,
+                           then run `task release-prepare` so pack
+                           manifests and tool projections pick up the
+                           new version (otherwise the PR's own consistency
+                           check fails — see PR #226 post-mortem).
     5. Commit + push     — `release: X.Y.Z`, push branch, open PR.
     6. Wait for CI       — `gh pr checks --watch` (skippable with --no-wait).
     7. Merge             — `gh pr merge --merge --delete-branch`.
@@ -43,6 +47,16 @@ from dataclasses import dataclass
 from datetime import date as _date
 from pathlib import Path
 
+from _lib.changelog_eras import (
+    CURRENT_ERA_BODY_CAP,
+    SplitPlan,
+    current_era_body_size,
+    current_era_insertion_point,
+    perform_split,
+    plan_split,
+    read_changelog_lines,
+)
+
 REPO_ROOT = Path(__file__).resolve().parent.parent
 PACKAGE_JSON = REPO_ROOT / "package.json"
 MARKETPLACE_JSON = REPO_ROOT / ".claude-plugin" / "marketplace.json"
@@ -92,6 +106,10 @@ class Plan:
     last_tag: str | None
     changelog_body: str  # rendered body (without the heading)
     changelog_entry: str  # full entry including heading, for CHANGELOG.md
+    # Populated only when the release crosses an era boundary AND the
+    # current era body has grown past CURRENT_ERA_BODY_CAP. None for
+    # patch releases and for minor/major bumps where the era still fits.
+    split_plan: SplitPlan | None = None
 
 
 # ─── utilities ────────────────────────────────────────────────────────────────
@@ -449,16 +467,32 @@ def _render_test_trend_line(prev_tag: str | None) -> str | None:
 
 
 def prepend_changelog(path: Path, entry: str) -> None:
-    """Insert `entry` directly above the most recent `## [` heading."""
+    """Insert ``entry`` inside the current era block.
+
+    Strategy delegates to ``current_era_insertion_point`` so a fresh
+    era (no version headings yet, just the intro blockquote) places the
+    new entry after the intro instead of appended at end-of-file. When
+    no current era header exists, falls back to the legacy "above the
+    most recent ## [" heuristic for safety.
+    """
     text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    insert_at = current_era_insertion_point(lines)
+    if insert_at is not None:
+        before = "\n".join(lines[:insert_at])
+        after = "\n".join(lines[insert_at:])
+        head = before + ("\n" if before else "")
+        path.write_text(head + entry + "\n" + after + "\n", encoding="utf-8")
+        return
+
+    # Legacy fallback — no era header present at all.
     marker_re = re.compile(r"^## \[?\d+\.\d+\.\d+", re.MULTILINE)
     m = marker_re.search(text)
     if not m:
-        # No prior release heading — append after the introduction.
         path.write_text(text.rstrip() + "\n\n" + entry, encoding="utf-8")
         return
     before = text[: m.start()]
-    after = text[m.start() :]
+    after = text[m.start():]
     path.write_text(before + entry + "\n" + after, encoding="utf-8")
 
 
@@ -573,6 +607,16 @@ def print_preview(plan: Plan) -> None:
     print(f"  · {PACKAGE_JSON.relative_to(REPO_ROOT)}")
     print(f"  · {MARKETPLACE_JSON.relative_to(REPO_ROOT)}")
     print(f"  · {CHANGELOG.relative_to(REPO_ROOT)}")
+    print("  · regenerated derived files via `task release-prepare`")
+    print("    (packages/*/pack.yaml + README.md, .agent-src/, tool projections)")
+    if plan.split_plan is not None:
+        sp = plan.split_plan
+        print()
+        print("Era split (separate commit, before release commit):")
+        print(f"  · archive   → {sp.archive_path.relative_to(REPO_ROOT)}")
+        print(f"  · old era   → pre-{sp.boundary} (archived pointer)")
+        print(f"  · new era   → {sp.new_era_label} — current (empty body)")
+        print(f"  · subject   → {sp.commit_subject}")
     print()
     print("Changelog section:")
     print("─" * 72)
@@ -629,6 +673,39 @@ def execute(
         _step(1, total, f"Create branch {branch}")
         run("git", "checkout", "-b", branch)
 
+    # ─── 1b. era split (optional, separate commit) ─────────────────────────
+    # Lands as `chore(changelog): split era ...` BEFORE the release commit
+    # so the split is reviewable on its own and the release commit only
+    # touches the bump + new entry. Idempotent: archive already on disk
+    # OR a prior split commit on the branch is treated as already done.
+    if plan.split_plan is not None and not pr_merged:
+        sp = plan.split_plan
+        split_already_committed = (
+            sp.commit_subject
+            in git("log", f"{MAIN_BRANCH}..HEAD", "--format=%s", capture=True)
+            .splitlines()
+        )
+        if sp.archive_path.exists() and split_already_committed:
+            _step(
+                1, total,
+                f"Era split for pre-{sp.boundary} already committed — skip",
+            )
+        elif sp.archive_path.exists() and not split_already_committed:
+            die(
+                f"era archive {sp.archive_path.relative_to(REPO_ROOT)} exists "
+                "but no matching split commit found on this branch — inspect "
+                "manually before resuming"
+            )
+        else:
+            _step(
+                1, total,
+                f"Split era {sp.old_era_label} → pre-{sp.boundary} "
+                f"(new era {sp.new_era_label})",
+            )
+            perform_split(sp)
+            run("git", "add", "-A")
+            run("git", "commit", "-m", sp.commit_subject)
+
     # ─── 2. file mutations ──────────────────────────────────────────────────
     if pr_merged:
         _step(2, total, "PR already merged — skip file bumps")
@@ -642,6 +719,15 @@ def execute(
             set_marketplace_version(MARKETPLACE_JSON, plan.target)
             prepend_changelog(CHANGELOG, plan.changelog_entry)
 
+        # Regenerate derived files (pack manifests, .agent-src/, tool
+        # projections) so the PR's own consistency check passes. Without
+        # this the bump only lands in package.json + marketplace.json and
+        # the Sync + Generate Tools Consistency gate fails on the release
+        # PR itself — exactly the failure mode PR #226 hit. `task
+        # release-prepare` is idempotent, so resume runs are safe.
+        _step(2, total, "Regenerate derived files (`task release-prepare`)")
+        run("task", "release-prepare")
+
     # ─── 3. commit ──────────────────────────────────────────────────────────
     if pr_merged:
         _step(3, total, "PR already merged — skip commit")
@@ -652,7 +738,12 @@ def execute(
             _step(3, total, f"Last commit already `release: {plan.target}` and tree clean — skip")
         else:
             _step(3, total, f"Commit `release: {plan.target}`")
-            run("git", "add", str(PACKAGE_JSON), str(MARKETPLACE_JSON), str(CHANGELOG))
+            # `git add -A` stages the three primary bump files AND every
+            # regenerated derived file (packages/*/pack.yaml + README.md,
+            # .agent-src/, .augment/, tool projections). Listing them
+            # explicitly would silently drift the moment a new generated
+            # tree is added.
+            run("git", "add", "-A")
             run("git", "commit", "-m", f"release: {plan.target}")
 
     # ─── 4. push ────────────────────────────────────────────────────────────
@@ -863,6 +954,24 @@ def main(argv: list[str] | None = None) -> int:
     full, body = render_changelog_entry(
         target, prev, commits, today, test_trend_line=test_trend_line
     )
+
+    # Era-split planning: only crosses the gate when the current era body
+    # has grown past the drift cap AND the release crosses a minor/major
+    # boundary. Patch overflow is caught by the drift test (red CI), not
+    # by an auto-split into a nonsensical "pre-X.Y.Z" archive.
+    split: SplitPlan | None = None
+    body_size = current_era_body_size()
+    if body_size > CURRENT_ERA_BODY_CAP:
+        candidate = plan_split(target)
+        if candidate is None:
+            die(
+                f"current era body is {body_size} lines (cap "
+                f"{CURRENT_ERA_BODY_CAP}) but release {target} is a patch "
+                f"within the same era — split needs a minor/major bump. "
+                "Cut a minor release or split CHANGELOG.md manually first."
+            )
+        split = candidate
+
     plan = Plan(
         current=current,
         target=target,
@@ -871,6 +980,7 @@ def main(argv: list[str] | None = None) -> int:
         last_tag=prev,
         changelog_body=body,
         changelog_entry=full,
+        split_plan=split,
     )
     print_preview(plan)
     if args.resume: