@dbx-tools/projen 0.6.223 → 0.6.225

package/tasks/publish-npm.ts

@@ -1,8 +1,17 @@
 #!/usr/bin/env -S bun
 /** Idempotent npm archive publication for release recovery. */
 import { createHash } from "node:crypto";
-import { readFileSync, readdirSync } from "node:fs";
-import { join, resolve } from "node:path";
+import {
+  lstatSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  readlinkSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative, resolve } from "node:path";
 import { exec } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
@@ -11,6 +20,7 @@ const DEFAULT_REGISTRY = "https://registry.npmjs.org";
 const logger = log.logger("dbx-tools:publish-npm");
 
 export interface NpmReleaseIdentity {
+  readonly contentDigest?: string;
   readonly integrity?: string;
   readonly name: string;
   readonly repository?: unknown;
@@ -47,7 +57,18 @@ export function npmReleaseMatches(
   if (localRepository && publishedRepository && localRepository !== publishedRepository) {
     throw new Error(`Published npm repository does not match ${local.name}@${local.version}`);
   }
-  if (local.integrity && published.integrity !== local.integrity) {
+  if (
+    local.contentDigest &&
+    published.contentDigest &&
+    local.contentDigest !== published.contentDigest
+  ) {
+    throw new Error(`Published npm content does not match ${local.name}@${local.version}`);
+  }
+  if (
+    !(local.contentDigest && published.contentDigest) &&
+    local.integrity &&
+    published.integrity !== local.integrity
+  ) {
     throw new Error(`Published npm integrity does not match ${local.name}@${local.version}`);
   }
   return true;
@@ -66,7 +87,7 @@ export async function publishedNpmRelease(
     throw new Error(`npm registry lookup failed for ${name}@${version}: ${response.status}`);
   }
   const metadata = (await response.json()) as {
-    dist?: { integrity?: string };
+    dist?: { integrity?: string; tarball?: string };
     name?: string;
     repository?: unknown;
     version?: string;
@@ -74,7 +95,23 @@ export async function publishedNpmRelease(
   if (!metadata.name || !metadata.version) {
     throw new Error(`npm registry returned an incomplete identity for ${name}@${version}`);
   }
+  let contentDigest: string | undefined;
+  if (metadata.dist?.tarball) {
+    const archive = await fetch(metadata.dist.tarball);
+    if (!archive.ok) {
+      throw new Error(`npm tarball lookup failed for ${name}@${version}: ${archive.status}`);
+    }
+    const temp = mkdtempSync(join(tmpdir(), "dbx-tools-published-npm-"));
+    const path = join(temp, "package.tgz");
+    try {
+      writeFileSync(path, Buffer.from(await archive.arrayBuffer()));
+      contentDigest = npmArchiveContentDigest(path);
+    } finally {
+      rmSync(temp, { recursive: true, force: true });
+    }
+  }
   return {
+    ...(contentDigest ? { contentDigest } : {}),
     integrity: metadata.dist?.integrity,
     name: metadata.name,
     repository: metadata.repository,
@@ -102,6 +139,7 @@ export function readNpmArchiveIdentity(path: string): NpmReleaseIdentity {
     throw new Error(`npm archive has no package name or version: ${path}`);
   }
   return {
+    contentDigest: npmArchiveContentDigest(path),
     integrity: `sha512-${createHash("sha512").update(readFileSync(path)).digest("base64")}`,
     name: manifest.name,
     repository: manifest.repository,
@@ -109,6 +147,39 @@ export function readNpmArchiveIdentity(path: string): NpmReleaseIdentity {
   };
 }
 
+/** Hash paths, executable bits, symlink targets, and bytes while ignoring tar metadata. */
+export function npmArchiveContentDigest(path: string): string {
+  const temp = mkdtempSync(join(tmpdir(), "dbx-tools-npm-content-"));
+  try {
+    exec.spawnSync("tar", ["-xzf", path, "-C", temp], {
+      cwd: process.cwd(),
+      stdout: "ignore",
+      stderr: "capture",
+      stdin: "ignore",
+      check: true,
+    });
+    const hash = createHash("sha512");
+    const visit = (directory: string): void => {
+      for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) =>
+        a.name.localeCompare(b.name),
+      )) {
+        const entryPath = join(directory, entry.name);
+        const name = relative(temp, entryPath).split("\\").join("/");
+        const stat = lstatSync(entryPath);
+        hash.update(`${entry.isDirectory() ? "D" : entry.isSymbolicLink() ? "L" : "F"}\0`);
+        hash.update(`${name}\0${stat.mode & 0o111}\0`);
+        if (entry.isDirectory()) visit(entryPath);
+        else if (entry.isSymbolicLink()) hash.update(readlinkSync(entryPath));
+        else hash.update(readFileSync(entryPath));
+      }
+    };
+    visit(temp);
+    return `sha512-${hash.digest("base64")}`;
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
 export function packNpmPackage(
   directory: string,
   destination: string,

package/tasks/publish-python.ts

@@ -13,20 +13,18 @@ import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { exec } from "@dbx-tools/core";
 import { Command } from "commander";
+import { parse, stringify } from "smol-toml";
+import { pythonProjectInfo, stampPythonProject } from "./uniffi-python.js";
 
 interface PythonProjectFile {
   readonly directory: string;
   readonly mode: number;
   readonly name: string;
   readonly path: string;
+  readonly private: boolean;
   readonly source: string;
 }
 
-function isPrivatePythonProject(source: string): boolean {
-  const section = source.match(/^\[tool\.dbx-tools\]\s*\n([\s\S]*?)(?=^\[|(?![\s\S]))/m)?.[1] ?? "";
-  return /^\s*private\s*=\s*true\s*$/m.test(section);
-}
-
 export interface StampPythonProjectsOptions {
   readonly rewriteDependencies?: boolean;
 }
@@ -36,10 +34,6 @@ export interface RestorePythonProjects {
   readonly paths: readonly string[];
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 export function stampPythonProjects(
   root: string,
   version: string,
@@ -52,37 +46,27 @@ export function stampPythonProjects(
     .sort();
   const allProjects: PythonProjectFile[] = packageFiles.map((path) => {
     const source = readFileSync(path, "utf8");
-    const name = /^name = "([^"]+)"$/m.exec(source)?.[1];
-    if (!name) throw new Error(`Missing project name in ${path}`);
+    const info = pythonProjectInfo(source, { parse, stringify });
     return {
       directory: basename(resolve(path, "..")),
       mode: statSync(path).mode,
-      name,
+      name: info.name,
       path,
+      private: info.private,
       source,
     };
   });
-  const projects = allProjects.filter((project) => !isPrivatePythonProject(project.source));
+  const projects = allProjects.filter((project) => !project.private);
   if (projects.length === 0) throw new Error(`No Python packages found under ${root}`);
 
   try {
     for (const project of projects) {
-      const versionPattern = /^version = "[^"]+"$/m;
-      if (!versionPattern.test(project.source)) {
-        throw new Error(`Expected one project version in ${project.path}`);
-      }
-      let stamped = project.source.replace(versionPattern, `version = "${version}"`);
-      if (options.rewriteDependencies ?? true) {
-        for (const sibling of allProjects) {
-          stamped = stamped.replace(
-            new RegExp(
-              `${escapeRegExp(sibling.name)} @ git\\+[^" ]+#subdirectory=[^" ]+/${escapeRegExp(sibling.directory)}`,
-              "g",
-            ),
-            `${sibling.name}==${version}`,
-          );
-        }
-      }
+      const stamped = stampPythonProject(project.source, {
+        packages: allProjects,
+        rewriteDependencies: options.rewriteDependencies,
+        toml: { parse, stringify },
+        version,
+      });
       chmodSync(project.path, project.mode | 0o200);
       writeFileSync(project.path, stamped);
       chmodSync(project.path, project.mode);

package/tasks/publish-uniffi-local.ts

@@ -6,6 +6,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { log } from "@dbx-tools/shared-core";
+import { parse, stringify } from "smol-toml";
 import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import type { RustBindingMapping, RustWorkspaceMapping } from "../src/project-rs.ts";
 
@@ -110,19 +111,21 @@ function publishCargo(config: RustWorkspaceMapping, registry: string, version: s
     );
     for (const manifest of manifests) {
       const mode = statSync(manifest).mode;
-      let source = readFileSync(manifest, "utf8");
+      const document = parse(readFileSync(manifest, "utf8")) as Record<string, unknown>;
       for (const crateName of crateNames) {
         if (!crateName) continue;
-        source = source.replace(
-          new RegExp(
-            `(${crateName.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")} = \\{[^}]*)( \\})`,
-            "g",
-          ),
-          `$1, registry = "${registry}"$2`,
-        );
+        for (const sectionName of ["dependencies", "dev-dependencies", "build-dependencies"]) {
+          const section = document[sectionName];
+          if (!section || typeof section !== "object" || Array.isArray(section)) continue;
+          const dependency = (section as Record<string, unknown>)[crateName];
+          if (!dependency || typeof dependency !== "object" || Array.isArray(dependency)) {
+            continue;
+          }
+          (dependency as Record<string, unknown>).registry = registry;
+        }
       }
       chmodSync(manifest, mode | 0o200);
-      writeFileSync(manifest, source);
+      writeFileSync(manifest, `${stringify(document).trimEnd()}\n`);
       chmodSync(manifest, mode);
     }
     for (const crateName of crateNames) {

package/tasks/publish.ts

@@ -62,7 +62,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve } from "node:path";
 import { exec } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
 import ts from "typescript";
@@ -253,7 +253,7 @@ function applyPublishConfig(pkgPath: string): void {
 function enrichedPath(root: string): string {
   const binDir = join(root, "node_modules", ".bin");
   const current = process.env.PATH ?? "";
-  return current.split(":").includes(binDir) ? current : `${binDir}:${current}`;
+  return current.split(delimiter).includes(binDir) ? current : `${binDir}${delimiter}${current}`;
 }
 
 const [version, ...rest] = process.argv.slice(2);

package/tasks/release-pr.ts

@@ -13,6 +13,8 @@ import { fileURLToPath } from "node:url";
 import { exec, project } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
+import { publishLocalRelease } from "./local-publish.ts";
+import { generateReleaseSummary } from "./release-summary.ts";
 import {
   releaseArchitectureOption,
   releaseLevelOption,
@@ -21,7 +23,16 @@ import {
   type ReleaseOs,
   type VersionLevel,
 } from "../src/_release-platform.ts";
-import { publishLocalRelease } from "./local-publish.ts";
+import {
+  githubRepositoryIdentity,
+  githubRepositorySpecifier,
+  githubTokenArguments,
+  githubTokenEnvironmentName,
+} from "../src/release-github.ts";
+import {
+  RELEASE_SUMMARY_PROVIDER_NAMES,
+  type ReleaseSummaryProviderName,
+} from "../src/release-dispatch.ts";
 import { readWorkspaceVersion, resolveNextVersion } from "../src/workspace-version.ts";
 
 const logger = log.logger("projen:release");
@@ -100,13 +111,17 @@ function runIgnoringStdout(root: string, command: string, args: string[]): void
   });
 }
 
-function githubAccount(root: string): { owner: string; repository: string; token: string } {
+function githubAccount(root: string): {
+  hostname: string;
+  owner: string;
+  repository: string;
+  token: string;
+} {
   const repository = project.repositoryUrl(root);
   if (!repository) throw new Error("Release preparation requires a GitHub repository");
-  const [owner, name] = new URL(repository).pathname.split("/").filter(Boolean);
-  if (!owner || !name) throw new Error(`Cannot determine GitHub identity from ${repository}`);
+  const identity = githubRepositoryIdentity(repository);
   const token = exec
-    .spawnSync("gh", ["auth", "token", "--user", owner], {
+    .spawnSync("gh", githubTokenArguments(identity.hostname), {
       cwd: root,
       stdout: "capture",
       stderr: "ignore",
@@ -114,8 +129,26 @@ function githubAccount(root: string): { owner: string; repository: string; token
       check: true,
     })
     .stdout?.trim();
-  if (!token) throw new Error(`No GitHub CLI authentication found for ${owner}`);
-  return { owner, repository: name.replace(/\.git$/, ""), token };
+  if (!token) {
+    throw new Error(`No GitHub CLI authentication found for ${identity.hostname}`);
+  }
+  return { ...identity, token };
+}
+
+function releaseSummaryProviders(
+  value: string | undefined,
+): ReleaseSummaryProviderName[] | undefined {
+  if (value === undefined) return undefined;
+  const providers = value
+    .split(",")
+    .map((provider) => provider.trim())
+    .filter(Boolean);
+  for (const provider of providers) {
+    if (!RELEASE_SUMMARY_PROVIDER_NAMES.includes(provider as ReleaseSummaryProviderName)) {
+      throw new Error(`Unknown release summary provider: ${provider}`);
+    }
+  }
+  return providers as ReleaseSummaryProviderName[];
 }
 
 const program = new Command();
@@ -129,7 +162,12 @@ program
   .addOption(releaseArchitectureOption())
   .option("--local-registry <value>", "local npm registry: auto, false, or an explicit URL", "auto")
   .option("--local-pypi <value>", "local PyPI index: auto, false, or an explicit URL", "auto")
-  .option("--python-root <path>", "Python workspace package root", "packages/py")
+  .option("--python-root <path>", "Python workspace package root")
+  .option("--no-release-summary", "skip optional AI release summary generation")
+  .option(
+    "--release-summary-providers <providers>",
+    "comma-separated provider order: cursor,codex,claude",
+  )
   .option("--no-local-cargo", "skip local Cargo publication")
   .option("--approve", "merge the release branch directly into the release base")
   .action(
@@ -142,7 +180,9 @@ program
       arch: ReleaseArch[];
       localRegistry: string;
       localPypi: string;
-      pythonRoot: string;
+      pythonRoot?: string;
+      releaseSummary: boolean;
+      releaseSummaryProviders?: string;
       localCargo: boolean;
       approve: boolean;
     }) => {
@@ -247,6 +287,14 @@ program
         localCargo: opts.localCargo,
       });
       run(releaseRoot, process.execPath, [versionCheckScript]);
+      const releaseSummary = opts.releaseSummary
+        ? await generateReleaseSummary({
+            root: releaseRoot,
+            version: next.version,
+            fromRef: `${opts.prefix}${next.base}`,
+            providers: releaseSummaryProviders(opts.releaseSummaryProviders),
+          })
+        : undefined;
 
       git(releaseRoot, ["add", "-A"]);
       const staged = git(releaseRoot, ["diff", "--cached", "--name-only"], { capture: true });
@@ -267,8 +315,14 @@ program
         `Source commit: ${git(releaseRoot, ["rev-parse", `${releaseBranch}^`], { capture: true })}`,
         "",
         "Merging this PR updates VERSION on main and starts the public release workflow.",
+        ...(releaseSummary ? ["", releaseSummary] : []),
       ].join("\n");
-      const githubEnvironment = { ...process.env, GH_TOKEN: account.token };
+      const githubEnvironment = {
+        ...process.env,
+        GH_HOST: account.hostname,
+        GH_REPO: githubRepositorySpecifier(account),
+        [githubTokenEnvironmentName(account.hostname)]: account.token,
+      };
       const ensurePullRequest = (): void => {
         if (commandSucceeds(root, "gh", ["pr", "view", releaseBranch], githubEnvironment)) return;
         run(

package/tasks/release-summary.ts

@@ -0,0 +1,270 @@
+#!/usr/bin/env -S bun
+/**
+ * Optional AI-generated release summary with CLI fallback.
+ *
+ * @module
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { json, log, object, string } from "@dbx-tools/shared-core";
+import {
+  RELEASE_SUMMARY_PROVIDER_NAMES,
+  releaseSummaryFile,
+  type ReleaseSummaryProviderName,
+} from "../src/release-dispatch.ts";
+
+const logger = log.logger("projen:release-summary");
+
+export interface ReleaseSummaryProvider {
+  readonly name: ReleaseSummaryProviderName;
+  readonly command: string;
+  readonly probeArgs: readonly string[];
+  args(root: string, prompt: string): string[];
+}
+
+export const RELEASE_SUMMARY_PROVIDERS: readonly ReleaseSummaryProvider[] = [
+  {
+    name: "cursor",
+    command: "cursor",
+    probeArgs: ["agent", "--version"],
+    args: (root, prompt) => [
+      "agent",
+      "--print",
+      "--mode",
+      "ask",
+      "--output-format",
+      "stream-json",
+      "--trust",
+      "--workspace",
+      root,
+      prompt,
+    ],
+  },
+  {
+    name: "codex",
+    command: "codex",
+    probeArgs: ["--version"],
+    args: (root, prompt) => [
+      "exec",
+      "--sandbox",
+      "read-only",
+      "--skip-git-repo-check",
+      "--json",
+      "--color",
+      "never",
+      "-C",
+      root,
+      prompt,
+    ],
+  },
+  {
+    name: "claude",
+    command: "claude",
+    probeArgs: ["--version"],
+    args: (_root, prompt) => [
+      "--print",
+      "--no-session-persistence",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--tools",
+      "",
+      prompt,
+    ],
+  },
+];
+
+export type ReleaseSummaryRunner = (
+  provider: ReleaseSummaryProvider,
+  root: string,
+  prompt: string,
+) => string | undefined | Promise<string | undefined>;
+
+function capture(root: string, command: string, args: string[]): string {
+  const result = exec.spawnSync(command, args, {
+    cwd: root,
+    stdout: "capture",
+    stderr: "ignore",
+    stdin: "ignore",
+    check: false,
+  });
+  return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : "";
+}
+
+function contentText(value: unknown): string | undefined {
+  if (typeof value === "string") return string.trimToNull(value) ?? undefined;
+  if (!Array.isArray(value)) return undefined;
+  const text = value
+    .flatMap((item) => (object.isRecord(item) && typeof item.text === "string" ? [item.text] : []))
+    .join("");
+  return string.trimToNull(text) ?? undefined;
+}
+
+function eventText(event: Record<string, unknown>): string | undefined {
+  if (typeof event.result === "string") return string.trimToNull(event.result) ?? undefined;
+  const item = object.isRecord(event.item) ? event.item : undefined;
+  if (item?.type === "agent_message" && typeof item.text === "string") {
+    return string.trimToNull(item.text) ?? undefined;
+  }
+  const message = object.isRecord(event.message) ? event.message : undefined;
+  return contentText(message?.content);
+}
+
+function eventType(event: Record<string, unknown>): string {
+  const item = object.isRecord(event.item) ? event.item : undefined;
+  return [event.type, item?.type].filter((value) => typeof value === "string").join(":") || "event";
+}
+
+function eventDetail(event: Record<string, unknown>): string | undefined {
+  const item = object.isRecord(event.item) ? event.item : undefined;
+  for (const value of [item?.message, event.message, event.error]) {
+    if (typeof value === "string") return string.trimToNull(value) ?? undefined;
+  }
+  return undefined;
+}
+
+async function runProvider(
+  provider: ReleaseSummaryProvider,
+  root: string,
+  prompt: string,
+): Promise<string | undefined> {
+  if (!capture(root, provider.command, [...provider.probeArgs])) return undefined;
+  let summary: string | undefined;
+  const textOutput: string[] = [];
+  const process = exec.spawn(provider.command, provider.args(root, prompt), {
+    cwd: root,
+    stdout: [
+      "capture",
+      (line) => {
+        const event = json.parseRecord(line);
+        if (!event) {
+          const text = string.trimToNull(line);
+          if (text) {
+            textOutput.push(text);
+            logger.info("provider-event", { provider: provider.name, type: "text", text });
+          }
+          return;
+        }
+        const text = eventText(event);
+        const detail = eventDetail(event);
+        if (text) summary = text;
+        logger.info("provider-event", {
+          provider: provider.name,
+          type: eventType(event),
+          ...(text ? { text } : {}),
+          ...(detail ? { detail } : {}),
+        });
+      },
+    ],
+    stderr: (line) => {
+      const message = string.trimToNull(line);
+      if (message) logger.warn("provider-stderr", { provider: provider.name, message });
+    },
+    stdin: "ignore",
+    check: false,
+  });
+  const result = await process;
+  if (result.exitCode !== 0) {
+    logger.warn("provider-failed", { provider: provider.name, exitCode: result.exitCode });
+    return undefined;
+  }
+  return summary ?? (textOutput.length ? textOutput.join("\n") : undefined);
+}
+
+/** Return the first non-empty provider response in Cursor, Codex, Claude order. */
+export async function selectReleaseSummary(
+  root: string,
+  prompt: string,
+  runner: ReleaseSummaryRunner = runProvider,
+  providers: readonly ReleaseSummaryProviderName[] = RELEASE_SUMMARY_PROVIDER_NAMES,
+): Promise<{ provider: ReleaseSummaryProvider["name"]; summary: string } | undefined> {
+  for (const name of providers) {
+    const provider = RELEASE_SUMMARY_PROVIDERS.find((candidate) => candidate.name === name);
+    if (!provider) continue;
+    const summary = (await runner(provider, root, prompt))?.trim();
+    if (summary) return { provider: provider.name, summary };
+  }
+  return undefined;
+}
+
+function summaryPrompt(
+  version: string,
+  fromRef: string | undefined,
+  commits: string,
+  changedFiles: string,
+  diffStat: string,
+): string {
+  return [
+    `Write a concise user-facing Markdown release summary for dbx-tools ${version}.`,
+    "Use only the supplied Git context. Do not run commands, edit files, speculate,",
+    "mention commit hashes, use emojis, or use em/en dashes.",
+    "Return no title and no fenced block. Start with one short paragraph, then",
+    "group concrete changes under brief Markdown headings with bullets.",
+    "",
+    `Comparison base: ${fromRef ?? "repository root"}`,
+    "",
+    "Commits:",
+    commits || "(none)",
+    "",
+    "Changed files:",
+    changedFiles || "(none)",
+    "",
+    "Diff stat:",
+    diffStat || "(none)",
+  ].join("\n");
+}
+
+/** Generate one immutable versioned summary, or remove a stale retry artifact. */
+export async function generateReleaseSummary(options: {
+  readonly root: string;
+  readonly version: string;
+  readonly fromRef?: string;
+  readonly toRef?: string;
+  readonly providers?: readonly ReleaseSummaryProviderName[];
+  readonly runner?: ReleaseSummaryRunner;
+}): Promise<string | undefined> {
+  const relativeOutput = releaseSummaryFile(options.version);
+  const output = join(options.root, relativeOutput);
+  if (existsSync(output)) rmSync(output);
+  const target =
+    options.toRef && capture(options.root, "git", ["rev-parse", "--verify", options.toRef])
+      ? options.toRef
+      : "HEAD";
+  const range =
+    options.fromRef && capture(options.root, "git", ["rev-parse", "--verify", options.fromRef])
+      ? `${options.fromRef}..${target}`
+      : target;
+  const commits = capture(options.root, "git", ["log", "--no-merges", "--format=%s%n%b", range]);
+  const changedFiles = capture(options.root, "git", [
+    "diff",
+    "--name-status",
+    range,
+    "--",
+    ".",
+    `:(exclude)${relativeOutput}`,
+  ]);
+  const diffStat = capture(options.root, "git", [
+    "diff",
+    "--stat",
+    range,
+    "--",
+    ".",
+    `:(exclude)${relativeOutput}`,
+  ]);
+  const result = await selectReleaseSummary(
+    options.root,
+    summaryPrompt(options.version, options.fromRef, commits, changedFiles, diffStat),
+    options.runner,
+    options.providers,
+  );
+  if (!result) {
+    logger.info("no supported AI CLI available; skipping release summary");
+    return undefined;
+  }
+  const content = `# Release ${options.version}\n\n${result.summary.trim()}\n`;
+  mkdirSync(dirname(output), { recursive: true });
+  writeFileSync(output, content);
+  logger.info("generated", { provider: result.provider, path: output });
+  return content;
+}