@dbx-tools/projen 0.6.228 → 0.6.230

package/tasks/publish.ts

@@ -73,6 +73,7 @@ import {
   publishedNpmRelease,
   readNpmArchiveIdentity,
 } from "./publish-npm.ts";
+import type { ReleasePlan } from "../src/release-plan.ts";
 
 const logger = log.logger("dbx-tools:publish");
 
@@ -104,22 +105,23 @@ function workspaceMembers(root: string): string[] {
   return (doc?.packages ?? []).map((m) => resolve(root, m));
 }
 
-/** Whether every workspace member already carries the requested release version. */
-function manifestsMatchVersion(members: readonly string[], version: string): boolean {
+/** Whether selected workspace members carry their planned versions. */
+function manifestsMatchVersions(
+  root: string,
+  members: readonly string[],
+  expected: ReadonlyMap<string, string>,
+): boolean {
   return members.every((dir) => {
     const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as {
       version?: string;
     };
-    return pkg.version === version;
+    const path = dir.slice(resolve(root).length + 1).replaceAll("\\", "/");
+    return pkg.version === expected.get(path);
   });
 }
 
-/** Whether Bun's workspace lock records the requested version for every member. */
-function lockfileMatchesVersion(
-  root: string,
-  members: readonly string[],
-  version: string,
-): boolean {
+/** Whether Bun's workspace lock records each live workspace manifest version. */
+function lockfileMatchesManifestVersions(root: string, members: readonly string[]): boolean {
   const lockfile = join(root, "bun.lock");
   if (!existsSync(lockfile)) return false;
   try {
@@ -129,11 +131,14 @@ function lockfileMatchesVersion(
       workspaces?: Record<string, { version?: string }>;
     };
     return members.every((dir) => {
+      const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as {
+        version?: string;
+      };
       const relative = dir
         .slice(resolve(root).length + 1)
         .split("\\")
         .join("/");
-      return lock.workspaces?.[relative]?.version === version;
+      return lock.workspaces?.[relative]?.version === manifest.version;
     });
   } catch {
     return false;
@@ -256,10 +261,18 @@ function enrichedPath(root: string): string {
   return current.split(delimiter).includes(binDir) ? current : `${binDir}${delimiter}${current}`;
 }
 
-const [version, ...rest] = process.argv.slice(2);
-if (!version) {
+const argv = process.argv.slice(2);
+const version = argv[0] && !argv[0].startsWith("--") ? argv[0] : undefined;
+const rest = version ? argv.slice(1) : argv;
+const root = process.cwd();
+const planIdx = rest.indexOf("--plan");
+const plan =
+  planIdx >= 0
+    ? (JSON.parse(readFileSync(resolve(root, rest[planIdx + 1]), "utf8")) as ReleasePlan)
+    : undefined;
+if (!version && !plan) {
   logger.error(
-    "usage: bun tasks/publish.ts <version> [--registry <url>] [--exclude <dir>] [--dry-run]",
+    "usage: bun tasks/publish.ts <version> [--plan <path>] [--registry <url>] [--exclude <dir>] [--dry-run]",
   );
   process.exit(1);
 }
@@ -278,29 +291,40 @@ const excluded = new Set(
   rest.reduce<string[]>((acc, arg, i) => (arg === "--exclude" ? [...acc, rest[i + 1]] : acc), []),
 );
 
-const root = process.cwd();
 const path = enrichedPath(root);
 // Registered BEFORE the first manifest edit so no exit path can skip it: a clean
 // finish and a `bun publish` failure mid-loop both land here, so a publish that
 // dies partway does not leave half the workspace stamped.
 if (restore) process.on("exit", restoreManifests);
-const members = workspaceMembers(root)
+const allMembers = workspaceMembers(root)
   .filter((dir) => existsSync(join(dir, "package.json")))
   .filter((dir) => !excluded.has(resolve(root, dir).replace(`${resolve(root)}/`, "")));
+const expectedVersions = new Map(
+  plan
+    ? plan.nodePackages.map((pkg) => [pkg.path, pkg.version] as const)
+    : allMembers.map((dir) => [
+        dir.slice(resolve(root).length + 1).replaceAll("\\", "/"),
+        version!,
+      ]),
+);
+const members = plan
+  ? allMembers.filter((dir) =>
+      expectedVersions.has(dir.slice(resolve(root).length + 1).replaceAll("\\", "/")),
+    )
+  : allMembers;
 
-// Publication consumes the reviewed version state and never repairs it.
-if (!manifestsMatchVersion(members, version)) {
-  throw new Error(`workspace manifests do not all match release version ${version}; run projen`);
+if (!manifestsMatchVersions(root, members, expectedVersions)) {
+  throw new Error("workspace manifests do not match the reviewed release plan; run projen");
 }
-logger.info(`all ${members.length} member manifests carry ${version}`);
+logger.info(`validated ${members.length} selected member manifests`);
 
 // Ensure the lockfile resolves each `workspace:*` to the release version.
 // `bun publish`/`pm pack` reads workspace versions from the LOCKFILE, not just
 // live manifests. A normal bump's synth/install already makes it current; after
 // fallback stamping, deleting it before install is what forces re-resolution.
 const lockfile = join(root, "bun.lock");
-if (lockfileMatchesVersion(root, members, version)) {
-  logger.info(`workspace lock already resolves members at ${version}`);
+if (lockfileMatchesManifestVersions(root, allMembers)) {
+  logger.info("workspace lock already resolves live member versions");
 } else {
   if (existsSync(lockfile)) rmSync(lockfile);
   logger.info("refreshing lockfile so workspace deps resolve to the release version");
@@ -314,10 +338,16 @@ const publishArgs = [
   ...(registry ? ["--registry", registry] : []),
   ...(dryRun ? ["--dry-run"] : []),
 ];
-const publishable: Array<{ dir: string; name: string; compile: boolean }> = [];
+const publishable: Array<{
+  dir: string;
+  name: string;
+  version: string;
+  compile: boolean;
+}> = [];
 for (const dir of members) {
   const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as {
     name?: string;
+    version?: string;
     private?: boolean;
     dbxToolsConfig?: { uniffi?: boolean };
     scripts?: Record<string, string>;
@@ -330,9 +360,11 @@ for (const dir of members) {
     logger.info(`skip UniFFI ${pkg.name ?? dirname(dir)}`);
     continue;
   }
+  if (!pkg.version) throw new Error(`Missing package version for ${pkg.name ?? dirname(dir)}`);
   publishable.push({
     dir,
     name: pkg.name ?? dirname(dir),
+    version: pkg.version,
     compile: Boolean(pkg.scripts && typeof pkg.scripts === "object" && "prepack" in pkg.scripts),
   });
 }
@@ -355,29 +387,27 @@ for (const { dir } of publishable) {
 logger.info(
   `${dryRun ? "dry-run packing" : "publishing"} ${publishable.length} packages with concurrency ${concurrency}`,
 );
-await runConcurrent(publishable, concurrency, async ({ dir, name }) => {
+await runConcurrent(publishable, concurrency, async ({ dir, name, version: packageVersion }) => {
   if (!dryRun) {
     const packed = mkdtempSync(join(tmpdir(), "dbx-tools-npm-release-"));
     try {
       const archive = packNpmPackage(dir, packed, path);
       const local = readNpmArchiveIdentity(archive);
-      if (local.name !== name || local.version !== version) {
+      if (local.name !== name || local.version !== packageVersion) {
         throw new Error(
-          `Packed npm identity ${local.name}@${local.version} does not match ${name}@${version}`,
+          `Packed npm identity ${local.name}@${local.version} does not match ${name}@${packageVersion}`,
         );
       }
       const published = await publishedNpmRelease(local.name, local.version, registry);
       if (npmReleaseMatches(local, published)) {
-        logger.info(`skip published ${name} @ ${version}`);
+        logger.info(`skip published ${name} @ ${packageVersion}`);
         return;
       }
     } finally {
       rmSync(packed, { recursive: true, force: true });
     }
   }
-  logger.info(`${dryRun ? "dry-run publishing" : "publishing"} ${name} @ ${version}`);
+  logger.info(`${dryRun ? "dry-run publishing" : "publishing"} ${name} @ ${packageVersion}`);
   await runAsync(dir, "bun", ["publish", ...publishArgs], path);
 });
-logger.success(
-  `${dryRun ? "dry-run: packed" : "published"} ${publishable.length} packages @ ${version}`,
-);
+logger.success(`${dryRun ? "dry-run: packed" : "published"} ${publishable.length} packages`);

package/tasks/release-bootstrap.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env -S bun
+/** Bootstrap Release Please state from the generated release-unit graph. */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { project } from "@dbx-tools/core";
+import { json, log } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
+
+const logger = log.logger("projen:release-bootstrap");
+
+function readGraph(root: string): ReleaseUnitGraph {
+  const path = join(root, ".projen/release-units.json");
+  const graph = json.parse(readFileSync(path, "utf8")) as ReleaseUnitGraph;
+  if (graph.schemaVersion !== 1) {
+    throw new Error(`Unsupported release-unit graph schema: ${String(graph.schemaVersion)}`);
+  }
+  return graph;
+}
+
+export function bootstrapReleaseUnits(root: string): void {
+  const graph = readGraph(root);
+  const manifestPath = join(root, ".release-please-manifest.json");
+  const expected = Object.fromEntries(
+    graph.units.map((unit) => [`.release-units/${unit.component}`, unit.version]),
+  );
+  if (existsSync(manifestPath)) {
+    const current = json.parseRecord(readFileSync(manifestPath, "utf8"));
+    for (const [path, version] of Object.entries(expected)) {
+      if (current?.[path] !== version) {
+        throw new Error(
+          `Release Please manifest already contains ${path}=${String(current?.[path])}; expected ${version}`,
+        );
+      }
+    }
+  } else {
+    writeFileSync(manifestPath, `${JSON.stringify(expected, null, 2)}\n`);
+  }
+
+  for (const unit of graph.units) {
+    const directory = join(root, ".release-units", unit.component);
+    mkdirSync(directory, { recursive: true });
+    const versionPath = join(directory, "version.txt");
+    if (!existsSync(versionPath)) writeFileSync(versionPath, `${unit.version}\n`);
+    const changelogPath = join(directory, "CHANGELOG.md");
+    if (!existsSync(changelogPath)) writeFileSync(changelogPath, "# Changelog\n");
+  }
+  logger.success(`bootstrapped ${graph.units.length} release units`);
+}
+
+if (import.meta.main) {
+  new Command()
+    .option("--root <path>", "repository root")
+    .action((options: { root?: string }) => {
+      bootstrapReleaseUnits(resolve(options.root ?? project.root() ?? process.cwd()));
+    })
+    .parse();
+}

package/tasks/release-plan.ts

@@ -0,0 +1,89 @@
+#!/usr/bin/env -S bun
+/** Build the affected release plan for the reviewed manifest change. */
+
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { json, log } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
+import { buildRecoveryReleasePlan, buildReleasePlan } from "../src/release-plan.ts";
+
+const logger = log.logger("projen:release-plan");
+
+function graphAtRef(root: string, ref: string): ReleaseUnitGraph | undefined {
+  const result = exec.spawnSync("git", ["show", `${ref}:.projen/release-units.json`], {
+    cwd: root,
+    stdout: "capture",
+    stderr: "ignore",
+    stdin: "ignore",
+    check: false,
+  });
+  if (result.exitCode !== 0 || !result.stdout) return undefined;
+  return json.parse(result.stdout) as ReleaseUnitGraph;
+}
+
+function writeOutput(name: string, value: unknown): void {
+  const output = process.env.GITHUB_OUTPUT;
+  if (output) {
+    const rendered = typeof value === "string" ? value : JSON.stringify(value);
+    appendFileSync(output, `${name}=${rendered}\n`);
+  }
+}
+
+new Command()
+  .option("--root <path>", "repository root", ".")
+  .option("--base-ref <ref>", "previous release graph ref", "HEAD^")
+  .option("--component <component>", "component to recover")
+  .option("--version <version>", "component version to recover")
+  .option("--docs", "include documentation without a package release")
+  .option("--output <path>", "release plan output", "dist/release-plan.json")
+  .action(
+    (options: {
+      root: string;
+      baseRef: string;
+      output: string;
+      component?: string;
+      version?: string;
+      docs?: boolean;
+    }) => {
+      const root = resolve(options.root);
+      const current = json.parse(
+        readFileSync(resolve(root, ".projen/release-units.json"), "utf8"),
+      ) as ReleaseUnitGraph;
+      if (Boolean(options.component) !== Boolean(options.version)) {
+        throw new Error("Recovery requires both --component and --version");
+      }
+      const planned =
+        options.component && options.version
+          ? buildRecoveryReleasePlan(current, options.component, options.version)
+          : buildReleasePlan(current, graphAtRef(root, options.baseRef));
+      const plan = options.docs
+        ? {
+            ...planned,
+            stages: { ...planned.stages, docs: true },
+            omittedStages: planned.omittedStages.filter((stage) => stage !== "docs"),
+          }
+        : planned;
+      const output = resolve(root, options.output);
+      mkdirSync(dirname(output), { recursive: true });
+      writeFileSync(output, `${JSON.stringify(plan, null, 2)}\n`);
+      writeOutput("plan", plan);
+      writeOutput("release_sha", process.env.GITHUB_SHA ?? "");
+      writeOutput("units", plan.units);
+      writeOutput("node_packages", plan.nodePackages);
+      writeOutput("python_packages", plan.pythonPackages);
+      writeOutput("rust_packages", plan.rustPackages);
+      writeOutput("artifacts", plan.artifacts);
+      writeOutput("rust_targets", plan.rustTargets);
+      writeOutput("stages", plan.stages);
+      for (const [stage, enabled] of Object.entries(plan.stages)) {
+        writeOutput(stage, enabled);
+      }
+      logger.success("release plan generated", {
+        units: plan.units.length,
+        omittedStages: plan.omittedStages,
+      });
+    },
+  )
+  .parse();

package/tasks/release-please.ts

@@ -0,0 +1,163 @@
+#!/usr/bin/env -S bun
+/** Run Release Please with the generated cross-language release-unit plugin. */
+
+import { appendFileSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { log } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import { GitHub } from "release-please";
+import { Manifest } from "release-please/build/src/manifest.js";
+import type { Scm } from "release-please/build/src/scm.js";
+import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
+import { addReleaseUnitPlugin } from "../src/release-please.ts";
+
+const logger = log.logger("projen:release-please");
+
+export interface ReleasePleaseRunOptions {
+  readonly github: Scm;
+  readonly targetBranch: string;
+  readonly graph: ReleaseUnitGraph;
+  readonly configFile?: string;
+  readonly manifestFile?: string;
+}
+
+/** Create component releases and refresh the combined release pull request. */
+export async function runReleasePlease(options: ReleasePleaseRunOptions) {
+  const configFile = options.configFile ?? "release-please-config.json";
+  const manifestFile = options.manifestFile ?? ".release-please-manifest.json";
+  const manifest = await Manifest.fromManifest(
+    options.github,
+    options.targetBranch,
+    configFile,
+    manifestFile,
+  );
+  addReleaseUnitPlugin(
+    manifest.plugins,
+    options.github,
+    options.targetBranch,
+    manifest.repositoryConfig,
+    options.graph,
+    manifestFile,
+  );
+  const releases = (await manifest.createReleases()).filter(
+    (release): release is NonNullable<typeof release> => release !== undefined,
+  );
+  const pullRequests = (await manifest.createPullRequests()).filter(
+    (pullRequest): pullRequest is NonNullable<typeof pullRequest> => pullRequest !== undefined,
+  );
+  return { releases, pullRequests };
+}
+
+function writeOutput(name: string, value: unknown): void {
+  const output = process.env.GITHUB_OUTPUT;
+  if (!output) return;
+  appendFileSync(output, `${name}=${JSON.stringify(value)}\n`);
+}
+
+/** Parse GitHub owner and repository from HTTPS, SSH, or SSH-alias syntax. */
+export function parseGitHubRepository(remote: string): { owner: string; repo: string } {
+  const location = remote
+    .replace(/^git@[^:]+:/, "")
+    .replace(/^ssh:\/\/git@[^/]+\//, "")
+    .replace(/^https?:\/\/[^/]+\//, "")
+    .replace(/\.git$/, "");
+  const [owner, repo, ...extra] = location.split("/");
+  if (!owner || !repo || extra.length > 0) {
+    throw new Error(`Could not resolve GitHub repository from ${remote}`);
+  }
+  return { owner, repo };
+}
+
+/** Resolve GitHub owner and repository from environment or the configured remote. */
+export function repositoryCoordinates(root: string): { owner: string; repo: string } {
+  const configured = process.env.GITHUB_REPOSITORY;
+  const remote = configured
+    ? configured
+    : (exec
+        .spawnSync("git", ["remote", "get-url", "origin"], {
+          cwd: root,
+          stdout: "capture",
+          stderr: "ignore",
+          stdin: "ignore",
+          check: true,
+        })
+        .stdout?.trim() ?? "");
+  return parseGitHubRepository(remote);
+}
+
+function githubToken(): string {
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+  return (
+    exec
+      .spawnSync("gh", ["auth", "token"], {
+        stdout: "capture",
+        stderr: "inherit",
+        stdin: "ignore",
+        check: true,
+      })
+      .stdout?.trim() ?? ""
+  );
+}
+
+if (import.meta.main) {
+  await new Command()
+    .option("--owner <owner>", "GitHub repository owner")
+    .option("--repo <repo>", "GitHub repository name")
+    .option("--target-branch <branch>", "release target branch", "main")
+    .option("--root <path>", "repository root", ".")
+    .option("--config-file <path>", "Release Please config", "release-please-config.json")
+    .option(
+      "--manifest-file <path>",
+      "Release Please version manifest",
+      ".release-please-manifest.json",
+    )
+    .option("--approve", "compatibility alias for the Release Please release pass")
+    .action(
+      async (options: {
+        owner?: string;
+        repo?: string;
+        targetBranch: string;
+        root: string;
+        configFile: string;
+        manifestFile: string;
+      }) => {
+        const root = resolve(options.root);
+        const repository =
+          options.owner && options.repo
+            ? { owner: options.owner, repo: options.repo }
+            : repositoryCoordinates(root);
+        const graph = JSON.parse(
+          readFileSync(resolve(root, ".projen/release-units.json"), "utf8"),
+        ) as ReleaseUnitGraph;
+        const github = await GitHub.create({
+          owner: repository.owner,
+          repo: repository.repo,
+          defaultBranch: options.targetBranch,
+          token: githubToken(),
+          ...(process.env.GITHUB_API_URL ? { apiUrl: process.env.GITHUB_API_URL } : {}),
+          ...(process.env.GITHUB_GRAPHQL_URL
+            ? {
+                graphqlUrl: process.env.GITHUB_GRAPHQL_URL.replace(/\/graphql\/?$/, ""),
+              }
+            : {}),
+        });
+        const result = await runReleasePlease({
+          github,
+          targetBranch: options.targetBranch,
+          graph,
+          configFile: options.configFile,
+          manifestFile: options.manifestFile,
+        });
+        logger.success("release state refreshed", {
+          releases: result.releases.length,
+          pullRequests: result.pullRequests.length,
+        });
+        writeOutput("releases_created", result.releases.length > 0);
+        writeOutput("prs_created", result.pullRequests.length > 0);
+        writeOutput("releases", result.releases);
+        writeOutput("prs", result.pullRequests);
+      },
+    )
+    .parseAsync();
+}

package/tasks/release-summary-units.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env -S bun
+/** Generate component-qualified release notes from an affected release plan. */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { log } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import { generateReleaseSummary } from "./release-summary.ts";
+import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
+import type { ReleasePlan } from "../src/release-plan.ts";
+
+const logger = log.logger("projen:release-summary-units");
+
+if (import.meta.main) {
+  await new Command()
+    .option("--root <path>", "repository root", ".")
+    .option("--plan <path>", "affected release plan", "dist/release-plan.json")
+    .option("--from-ref <ref>", "summary base ref", "origin/main")
+    .option("--to-ref <ref>", "summary target ref", "HEAD")
+    .action(async (options: { root: string; plan: string; fromRef: string; toRef: string }) => {
+      const root = resolve(options.root);
+      const plan = JSON.parse(readFileSync(resolve(root, options.plan), "utf8")) as ReleasePlan;
+      const graph = JSON.parse(
+        readFileSync(resolve(root, ".projen/release-units.json"), "utf8"),
+      ) as ReleaseUnitGraph;
+      for (const planned of plan.units) {
+        const unit = graph.units.find((candidate) => candidate.id === planned.id);
+        if (!unit) throw new Error(`Release plan references unknown unit ${planned.id}`);
+        const paths = graph.projects
+          .filter((project) => project.unit === unit.id)
+          .map((project) => project.path);
+        await generateReleaseSummary({
+          root,
+          component: planned.component,
+          version: planned.newVersion,
+          paths,
+          fromRef: options.fromRef,
+          toRef: options.toRef,
+        });
+      }
+      logger.success(`generated ${plan.units.length} component release summaries`);
+    })
+    .parseAsync();
+}

package/tasks/release-summary.ts

@@ -15,6 +15,8 @@ import {
 } from "../src/release-dispatch.ts";
 
 const logger = log.logger("projen:release-summary");
+const PROVIDER_TIMEOUT_MS = 60_000;
+const PROVIDER_KILL_GRACE_MS = 5_000;
 
 export interface ReleaseSummaryProvider {
   readonly name: ReleaseSummaryProviderName;
@@ -132,7 +134,7 @@ async function runProvider(
   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), {
+  const child = exec.spawn(provider.command, provider.args(root, prompt), {
     cwd: root,
     stdout: [
       "capture",
@@ -164,7 +166,21 @@ async function runProvider(
     stdin: "ignore",
     check: false,
   });
-  const result = await process;
+  let escalation: ReturnType<typeof setTimeout> | undefined;
+  const timeout = setTimeout(() => {
+    logger.warn("provider-timeout", {
+      provider: provider.name,
+      timeoutMs: PROVIDER_TIMEOUT_MS,
+    });
+    child.kill("SIGTERM");
+    escalation = setTimeout(() => child.kill("SIGKILL"), PROVIDER_KILL_GRACE_MS);
+    escalation.unref();
+  }, PROVIDER_TIMEOUT_MS);
+  timeout.unref();
+  const result = await child.finally(() => {
+    clearTimeout(timeout);
+    if (escalation) clearTimeout(escalation);
+  });
   if (result.exitCode !== 0) {
     logger.warn("provider-failed", { provider: provider.name, exitCode: result.exitCode });
     return undefined;
@@ -247,12 +263,14 @@ function gitSummary(version: string, commits: string, changedFiles: string): str
 export async function generateReleaseSummary(options: {
   readonly root: string;
   readonly version: string;
+  readonly component?: string;
+  readonly paths?: readonly string[];
   readonly fromRef?: string;
   readonly toRef?: string;
   readonly providers?: readonly ReleaseSummaryProviderName[];
   readonly runner?: ReleaseSummaryRunner;
 }): Promise<string | undefined> {
-  const relativeOutput = releaseSummaryFile(options.version);
+  const relativeOutput = releaseSummaryFile(options.version, options.component);
   const output = join(options.root, relativeOutput);
   if (existsSync(output)) rmSync(output);
   const target =
@@ -263,13 +281,21 @@ export async function generateReleaseSummary(options: {
     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 scopedPaths = options.paths?.length ? [...options.paths] : ["."];
+  const commits = capture(options.root, "git", [
+    "log",
+    "--no-merges",
+    "--format=%s%n%b",
+    range,
+    "--",
+    ...scopedPaths,
+  ]);
   const changedFiles = capture(options.root, "git", [
     "diff",
     "--name-status",
     range,
     "--",
-    ".",
+    ...scopedPaths,
     `:(exclude)${relativeOutput}`,
   ]);
   const diffStat = capture(options.root, "git", [
@@ -277,7 +303,7 @@ export async function generateReleaseSummary(options: {
     "--stat",
     range,
     "--",
-    ".",
+    ...scopedPaths,
     `:(exclude)${relativeOutput}`,
   ]);
   const result = await selectReleaseSummary(
@@ -289,7 +315,7 @@ export async function generateReleaseSummary(options: {
   const summary = result?.summary ?? gitSummary(options.version, commits, changedFiles);
   const provider = result?.provider ?? "git";
   if (!result) logger.info("AI providers unavailable; using Git release summary");
-  const content = `# Release ${options.version}\n\n${summary.trim()}\n`;
+  const content = `# Release ${options.component ? `${options.component} ` : ""}${options.version}\n\n${summary.trim()}\n`;
   mkdirSync(dirname(output), { recursive: true });
   writeFileSync(output, content);
   logger.info("generated", { provider, path: output });

package/tasks/uniffi-python.d.ts

@@ -6,11 +6,15 @@ export interface TomlCodec {
 export interface PythonPackageMapping {
   readonly directory: string;
   readonly name: string;
+  readonly version: string;
+  readonly uniffi: boolean;
 }
 
 export interface PythonProjectInfo {
   readonly name: string;
+  readonly version: string;
   readonly private: boolean;
+  readonly uniffi: boolean;
 }
 
 /** Read the project identity and publication flag from parsed TOML metadata. */
@@ -22,6 +26,7 @@ export function stampPythonProject(
   options: {
     readonly packages: readonly PythonPackageMapping[];
     readonly rewriteDependencies?: boolean;
+    readonly usePackageVersions?: boolean;
     readonly toml: TomlCodec;
     readonly version: string;
   },