@williamthorsen/release-kit 2.3.2 → 4.4.0

package/dist/esm/bin/release-kit.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { commitCommand } from "../commitCommand.js";
 import { initCommand } from "../init/initCommand.js";
 import { prepareCommand } from "../prepareCommand.js";
 import { publishCommand } from "../publishCommand.js";
@@ -6,12 +8,14 @@ import { generateCommand } from "../sync-labels/generateCommand.js";
 import { syncLabelsInitCommand } from "../sync-labels/initCommand.js";
 import { syncLabelsCommand } from "../sync-labels/syncCommand.js";
 import { tagCommand } from "../tagCommand.js";
+import { VERSION } from "../version.js";
 function showUsage() {
   console.info(`
 Usage: release-kit <command> [options]
 
 Commands:
   prepare       Run release preparation (auto-discovers workspaces)
+  commit        Stage changes and create the release commit
   tag           Create annotated git tags from the tags file
   publish       Publish packages with release tags on HEAD
   init          Initialize release-kit in the current repository
@@ -97,6 +101,18 @@ Options:
   --help, -h            Show this help message
 `);
 }
+function showCommitHelp() {
+  console.info(`
+Usage: release-kit commit [options]
+
+Stage all changes and create the release commit using tags and summary
+produced by \`prepare\`.
+
+Options:
+  --dry-run     Preview the commit message without creating it
+  --help, -h    Show this help message
+`);
+}
 function showTagHelp() {
   console.info(`
 Usage: release-kit tag [options]
@@ -119,12 +135,17 @@ Options:
   --dry-run              Preview without publishing
   --no-git-checks        Skip git checks (pnpm only)
   --only=name1,name2     Only publish the named packages (comma-separated, monorepo only)
+  --provenance           Generate provenance statement (requires OIDC, not supported by classic yarn)
   --help, -h             Show this help message
 `);
 }
 const args = process.argv.slice(2);
 const command = args[0];
 const flags = args.slice(1);
+if (command === "--version" || command === "-V") {
+  console.info(VERSION);
+  process.exit(0);
+}
 if (command === "--help" || command === "-h" || command === void 0) {
   showUsage();
   process.exit(0);
@@ -137,6 +158,19 @@ if (command === "prepare") {
   await prepareCommand(flags);
   process.exit(0);
 }
+if (command === "commit") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showCommitHelp();
+    process.exit(0);
+  }
+  try {
+    commitCommand(flags);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  process.exit(0);
+}
 if (command === "tag") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
     showTagHelp();
@@ -158,15 +192,19 @@ if (command === "init") {
     showInitHelp();
     process.exit(0);
   }
-  const knownInitFlags = /* @__PURE__ */ new Set(["--dry-run", "--force", "--with-config", "--help", "-h"]);
-  const unknownFlags = flags.filter((f) => !knownInitFlags.has(f));
-  if (unknownFlags.length > 0) {
-    console.error(`Error: Unknown option: ${unknownFlags[0]}`);
+  const initFlagSchema = {
+    dryRun: { long: "--dry-run", type: "boolean" },
+    force: { long: "--force", type: "boolean" },
+    withConfig: { long: "--with-config", type: "boolean" }
+  };
+  let parsed;
+  try {
+    parsed = parseArgs(flags, initFlagSchema);
+  } catch (error) {
+    console.error(`Error: ${translateParseError(error)}`);
     process.exit(1);
   }
-  const dryRun = flags.includes("--dry-run");
-  const force = flags.includes("--force");
-  const withConfig = flags.includes("--with-config");
+  const { dryRun, force, withConfig } = parsed.flags;
   const exitCode = initCommand({ dryRun, force, withConfig });
   process.exit(exitCode);
 }
@@ -182,14 +220,18 @@ if (command === "sync-labels") {
       showSyncLabelsInitHelp();
       process.exit(0);
     }
-    const knownFlags = /* @__PURE__ */ new Set(["--dry-run", "--force", "--help", "-h"]);
-    const unknownFlags = subflags.filter((f) => !knownFlags.has(f));
-    if (unknownFlags.length > 0) {
-      console.error(`Error: Unknown option: ${unknownFlags[0]}`);
+    const syncLabelsInitFlagSchema = {
+      dryRun: { long: "--dry-run", type: "boolean" },
+      force: { long: "--force", type: "boolean" }
+    };
+    let syncParsed;
+    try {
+      syncParsed = parseArgs(subflags, syncLabelsInitFlagSchema);
+    } catch (error) {
+      console.error(`Error: ${translateParseError(error)}`);
       process.exit(1);
     }
-    const dryRun = subflags.includes("--dry-run");
-    const force = subflags.includes("--force");
+    const { dryRun, force } = syncParsed.flags;
     const exitCode = await syncLabelsInitCommand({ dryRun, force });
     process.exit(exitCode);
   }

package/dist/esm/buildDependencyGraph.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentConfig } from './types.ts';
+export interface DependencyGraph {
+    packageNameToDir: Map<string, string>;
+    dirToPackageName: Map<string, string>;
+    dependentsOf: Map<string, ComponentConfig[]>;
+}
+export declare function buildDependencyGraph(components: readonly ComponentConfig[]): DependencyGraph;

package/dist/esm/buildDependencyGraph.js

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+function isPackageJsonSubset(value) {
+  return typeof value === "object" && value !== null;
+}
+function buildDependencyGraph(components) {
+  const packageNameToDir = /* @__PURE__ */ new Map();
+  const dirToPackageName = /* @__PURE__ */ new Map();
+  const dependentsOf = /* @__PURE__ */ new Map();
+  const componentPackages = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    const primaryPackageFile = component.packageFiles[0];
+    if (primaryPackageFile === void 0) {
+      continue;
+    }
+    const pkg = readPackageJsonSubset(primaryPackageFile);
+    componentPackages.set(component, pkg);
+    if (pkg.name === void 0) {
+      continue;
+    }
+    packageNameToDir.set(pkg.name, component.dir);
+    dirToPackageName.set(component.dir, pkg.name);
+  }
+  for (const [component, pkg] of componentPackages) {
+    const allDeps = { ...pkg.dependencies, ...pkg.peerDependencies };
+    for (const [depName, depVersion] of Object.entries(allDeps)) {
+      if (typeof depVersion !== "string" || !depVersion.startsWith("workspace:")) {
+        continue;
+      }
+      const existing = dependentsOf.get(depName);
+      if (existing === void 0) {
+        dependentsOf.set(depName, [component]);
+      } else {
+        existing.push(component);
+      }
+    }
+  }
+  return { packageNameToDir, dirToPackageName, dependentsOf };
+}
+function readPackageJsonSubset(filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(`Failed to read ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isPackageJsonSubset(parsed)) {
+    throw new Error(`Invalid package.json at ${filePath}`);
+  }
+  return parsed;
+}
+export {
+  buildDependencyGraph
+};

package/dist/esm/buildReleaseSummary.d.ts

@@ -0,0 +1,2 @@
+import type { PrepareResult } from './types.ts';
+export declare function buildReleaseSummary(result: PrepareResult): string;

package/dist/esm/buildReleaseSummary.js

@@ -0,0 +1,22 @@
+import { stripScope } from "./stripScope.js";
+function buildReleaseSummary(result) {
+  const sections = [];
+  for (const component of result.components) {
+    if (component.status !== "released" || component.tag === void 0) {
+      continue;
+    }
+    const commits = component.commits;
+    if (commits === void 0 || commits.length === 0) {
+      continue;
+    }
+    const lines = [component.tag];
+    for (const commit of commits) {
+      lines.push(`- ${stripScope(commit.message)}`);
+    }
+    sections.push(lines.join("\n"));
+  }
+  return sections.join("\n\n");
+}
+export {
+  buildReleaseSummary
+};

package/dist/esm/commitCommand.d.ts

@@ -0,0 +1 @@
+export declare function commitCommand(argv: string[]): void;

package/dist/esm/commitCommand.js

@@ -0,0 +1,60 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./prepareCommand.js";
+const commitFlagSchema = {
+  dryRun: { long: "--dry-run", type: "boolean" }
+};
+function commitCommand(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, commitFlagSchema);
+  } catch (error) {
+    console.error(`Error: ${translateParseError(error)}`);
+    process.exit(1);
+  }
+  const dryRun = parsed.flags.dryRun;
+  let tagsContent;
+  try {
+    tagsContent = readFileSync(RELEASE_TAGS_FILE, "utf8");
+  } catch {
+    throw new Error("No tags file found. Run `release-kit prepare` first.");
+  }
+  const tags = tagsContent.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  if (tags.length === 0) {
+    throw new Error("Tags file is empty. Run `release-kit prepare` first.");
+  }
+  let summary = "";
+  try {
+    summary = readFileSync(RELEASE_SUMMARY_FILE, "utf8").trim();
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+    } else {
+      throw error;
+    }
+  }
+  const title = `release: ${tags.join(" ")}`;
+  const message = summary.length > 0 ? `${title}
+
+${summary}` : title;
+  if (dryRun) {
+    console.info("[dry-run] Would create commit with message:\n");
+    console.info(message);
+    try {
+      const status = execFileSync("git", ["status", "--porcelain"], { encoding: "utf8" });
+      if (status.trim().length > 0) {
+        console.info("\nUncommitted changes:");
+        console.info(status.trimEnd());
+      }
+    } catch {
+      console.info("(Could not determine uncommitted changes)");
+    }
+    return;
+  }
+  execFileSync("git", ["add", "-A"]);
+  execFileSync("git", ["commit", "-m", message]);
+  console.info(`Created release commit: ${title}`);
+}
+export {
+  commitCommand
+};

package/dist/esm/createTags.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
-import { readFileSync, unlinkSync } from "node:fs";
-import { RELEASE_TAGS_FILE } from "./prepareCommand.js";
+import { readFileSync } from "node:fs";
+import { deleteFileIfExists } from "./deleteFileIfExists.js";
+import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./prepareCommand.js";
 function createTags(options) {
   const { dryRun, noGitChecks } = options;
   let content;
@@ -42,19 +43,10 @@ function createTags(options) {
   for (const tag of tags) {
     console.info(`\u{1F3F7}\uFE0F ${tag}`);
   }
-  deleteTagsFile();
+  deleteFileIfExists(RELEASE_TAGS_FILE);
+  deleteFileIfExists(RELEASE_SUMMARY_FILE);
   return tags;
 }
-function deleteTagsFile() {
-  try {
-    unlinkSync(RELEASE_TAGS_FILE);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return;
-    }
-    throw error;
-  }
-}
 function assertCleanWorkingTree() {
   try {
     execFileSync("git", ["diff", "--quiet"]);

package/dist/esm/deleteFileIfExists.d.ts

@@ -0,0 +1 @@
+export declare function deleteFileIfExists(filePath: string): void;

package/dist/esm/deleteFileIfExists.js

@@ -0,0 +1,14 @@
+import { unlinkSync } from "node:fs";
+function deleteFileIfExists(filePath) {
+  try {
+    unlinkSync(filePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+export {
+  deleteFileIfExists
+};

package/dist/esm/determineBumpFromCommits.d.ts

@@ -4,4 +4,4 @@ export interface BumpDetermination {
     parsedCommitCount: number;
     unparseableCommits: Commit[] | undefined;
 }
-export declare function determineBumpFromCommits(commits: Commit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns, workspaceAliases: Record<string, string> | undefined): BumpDetermination;
+export declare function determineBumpFromCommits(commits: Commit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns, scopeAliases: Record<string, string> | undefined): BumpDetermination;

package/dist/esm/determineBumpFromCommits.js

@@ -1,10 +1,10 @@
 import { determineBumpType } from "./determineBumpType.js";
 import { parseCommitMessage } from "./parseCommitMessage.js";
-function determineBumpFromCommits(commits, workTypes, versionPatterns, workspaceAliases) {
+function determineBumpFromCommits(commits, workTypes, versionPatterns, scopeAliases) {
   const parsedCommits = [];
   const unparseable = [];
   for (const commit of commits) {
-    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, workspaceAliases);
+    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases);
     if (parsed === void 0) {
       unparseable.push(commit);
     } else {

package/dist/esm/generateChangelogs.d.ts

@@ -1,5 +1,7 @@
 import type { ReleaseConfig } from './types.ts';
+export declare function buildTagPattern(tagPrefix: string): string;
 export interface GenerateChangelogOptions {
+    tagPattern?: string;
     includePaths?: string[];
 }
 export declare function generateChangelog(config: Pick<ReleaseConfig, 'cliffConfigPath'>, changelogPath: string, tag: string, dryRun: boolean, options?: GenerateChangelogOptions): string[];

package/dist/esm/generateChangelogs.js

@@ -1,9 +1,15 @@
 import { execFileSync } from "node:child_process";
 import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
+function buildTagPattern(tagPrefix) {
+  return `${tagPrefix}[0-9].*`;
+}
 function generateChangelog(config, changelogPath, tag, dryRun, options) {
   const cliffConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
   const outputFile = `${changelogPath}/CHANGELOG.md`;
   const args = ["--config", cliffConfigPath, "--output", outputFile, "--tag", tag];
+  if (options?.tagPattern !== void 0) {
+    args.push("--tag-pattern", options.tagPattern);
+  }
   for (const includePath of options?.includePaths ?? []) {
     args.push("--include-path", includePath);
   }
@@ -19,13 +25,15 @@ function generateChangelog(config, changelogPath, tag, dryRun, options) {
   return [outputFile];
 }
 function generateChangelogs(config, tag, dryRun) {
+  const tagPattern = buildTagPattern(config.tagPrefix);
   const results = [];
   for (const changelogPath of config.changelogPaths) {
-    results.push(...generateChangelog(config, changelogPath, tag, dryRun));
+    results.push(...generateChangelog(config, changelogPath, tag, dryRun, { tagPattern }));
   }
   return results;
 }
 export {
+  buildTagPattern,
   generateChangelog,
   generateChangelogs
 };

package/dist/esm/index.d.ts

@@ -7,19 +7,23 @@ export type { ResolvedTag } from './resolveReleaseTags.ts';
 export type { LabelDefinition, SyncLabelsConfig } from './sync-labels/types.ts';
 export type { BumpResult, Commit, ComponentConfig, ComponentOverride, ComponentPrepareResult, MonorepoReleaseConfig, ParsedCommit, PrepareResult, ReleaseConfig, ReleaseKitConfig, ReleaseType, VersionPatterns, WorkTypeConfig, } from './types.ts';
 export { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from './defaults.ts';
+export { buildReleaseSummary } from './buildReleaseSummary.ts';
 export { bumpAllVersions } from './bumpAllVersions.ts';
 export { bumpVersion } from './bumpVersion.ts';
+export { commitCommand } from './commitCommand.ts';
 export { component } from './component.ts';
 export { createTags } from './createTags.ts';
+export { deleteFileIfExists } from './deleteFileIfExists.ts';
 export { detectPackageManager } from './detectPackageManager.ts';
 export { determineBumpType } from './determineBumpType.ts';
 export { discoverWorkspaces } from './discoverWorkspaces.ts';
 export { generateChangelog, generateChangelogs } from './generateChangelogs.ts';
 export { getCommitsSinceTarget } from './getCommitsSinceTarget.ts';
 export { COMMIT_PREPROCESSOR_PATTERNS, parseCommitMessage } from './parseCommitMessage.ts';
-export { RELEASE_TAGS_FILE, writeReleaseTags } from './prepareCommand.ts';
+export { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE, writeReleaseTags } from './prepareCommand.ts';
 export { publish } from './publish.ts';
 export { releasePrepare } from './releasePrepare.ts';
 export { releasePrepareMono } from './releasePrepareMono.ts';
 export { reportPrepare } from './reportPrepare.ts';
 export { resolveReleaseTags } from './resolveReleaseTags.ts';
+export { stripScope } from './stripScope.ts';

package/dist/esm/index.js

@@ -1,29 +1,37 @@
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { bumpVersion } from "./bumpVersion.js";
+import { commitCommand } from "./commitCommand.js";
 import { component } from "./component.js";
 import { createTags } from "./createTags.js";
+import { deleteFileIfExists } from "./deleteFileIfExists.js";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { determineBumpType } from "./determineBumpType.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { generateChangelog, generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { COMMIT_PREPROCESSOR_PATTERNS, parseCommitMessage } from "./parseCommitMessage.js";
-import { RELEASE_TAGS_FILE, writeReleaseTags } from "./prepareCommand.js";
+import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE, writeReleaseTags } from "./prepareCommand.js";
 import { publish } from "./publish.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
+import { stripScope } from "./stripScope.js";
 export {
   COMMIT_PREPROCESSOR_PATTERNS,
   DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES,
+  RELEASE_SUMMARY_FILE,
   RELEASE_TAGS_FILE,
+  buildReleaseSummary,
   bumpAllVersions,
   bumpVersion,
+  commitCommand,
   component,
   createTags,
+  deleteFileIfExists,
   detectPackageManager,
   determineBumpType,
   discoverWorkspaces,
@@ -36,5 +44,6 @@ export {
   releasePrepareMono,
   reportPrepare,
   resolveReleaseTags,
+  stripScope,
   writeReleaseTags
 };

package/dist/esm/init/initCommand.js

@@ -56,8 +56,10 @@ function initCommand({ dryRun, force, withConfig }) {
   const configHint = withConfig ? "1. (Optional) Customize .config/release-kit.config.ts and .config/git-cliff.toml." : "1. (Optional) Run again with --with-config to scaffold config files.";
   console.info(`
   ${configHint}
-  2. Test by running: npx @williamthorsen/release-kit prepare --dry-run
-  3. Commit the generated files.
+  2. If this is a public repo, set provenance: true in .github/workflows/publish.yaml.
+  3. Test by running: npx @williamthorsen/release-kit prepare --dry-run
+  4. Commit the generated files.
+  5. Register each package as a trusted publisher on npmjs.com.
 `);
   return 0;
 }

package/dist/esm/init/scaffold.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
 import { findPackageRoot } from "../findPackageRoot.js";
-import { releaseConfigScript, releaseWorkflow } from "./templates.js";
+import { publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
 function copyCliffTemplate(dryRun, overwrite) {
   const destPath = ".config/git-cliff.toml";
   const root = findPackageRoot(import.meta.url);
@@ -21,7 +21,8 @@ function copyCliffTemplate(dryRun, overwrite) {
 }
 function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
   const results = [
-    writeFileWithCheck(".github/workflows/release.yaml", releaseWorkflow(repoType), { dryRun, overwrite })
+    writeFileWithCheck(".github/workflows/release.yaml", releaseWorkflow(repoType), { dryRun, overwrite }),
+    writeFileWithCheck(".github/workflows/publish.yaml", publishWorkflow(repoType), { dryRun, overwrite })
   ];
   if (withConfig) {
     results.push(

package/dist/esm/init/templates.d.ts

@@ -1,3 +1,4 @@
 import type { RepoType } from './detectRepoType.ts';
 export declare function releaseConfigScript(repoType: RepoType): string;
+export declare function publishWorkflow(repoType: RepoType): string;
 export declare function releaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/templates.js

@@ -35,6 +35,27 @@ const config: ReleaseKitConfig = {
 export default config;
 `;
 }
+function publishWorkflow(repoType) {
+  const tagPattern = repoType === "monorepo" ? "'*-v[0-9]*'" : "'v[0-9]*'";
+  return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+name: Publish
+
+on:
+  push:
+    tags:
+      - ${tagPattern}
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/publish.reusable.yaml@publish-workflow-v1
+    with:
+      provenance: false # Set to true for public repos to generate npm provenance attestations
+`;
+}
 function releaseWorkflow(repoType) {
   if (repoType === "monorepo") {
     return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
@@ -68,7 +89,7 @@ permissions:
 
 jobs:
   release:
-    uses: williamthorsen/node-monorepo-tools/.github/workflows/release-workflow.yaml@release-workflow-v1
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/release.reusable.yaml@release-workflow-v1
     with:
       only: \${{ inputs.only }}
       bump: \${{ inputs.bump }}
@@ -102,13 +123,14 @@ permissions:
 
 jobs:
   release:
-    uses: williamthorsen/node-monorepo-tools/.github/workflows/release-workflow.yaml@release-workflow-v1
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/release.reusable.yaml@release-workflow-v1
     with:
       bump: \${{ inputs.bump }}
       force: \${{ inputs.force }}
 `;
 }
 export {
+  publishWorkflow,
   releaseConfigScript,
   releaseWorkflow
 };

package/dist/esm/loadConfig.js

@@ -47,9 +47,9 @@ function mergeMonorepoConfig(discoveredPaths, userConfig) {
   if (cliffConfigPath !== void 0) {
     result.cliffConfigPath = cliffConfigPath;
   }
-  const workspaceAliases = userConfig?.workspaceAliases;
-  if (workspaceAliases !== void 0) {
-    result.workspaceAliases = workspaceAliases;
+  const scopeAliases = userConfig?.scopeAliases;
+  if (scopeAliases !== void 0) {
+    result.scopeAliases = scopeAliases;
   }
   return result;
 }
@@ -71,9 +71,9 @@ function mergeSinglePackageConfig(userConfig) {
   if (cliffConfigPath !== void 0) {
     result.cliffConfigPath = cliffConfigPath;
   }
-  const workspaceAliases = userConfig?.workspaceAliases;
-  if (workspaceAliases !== void 0) {
-    result.workspaceAliases = workspaceAliases;
+  const scopeAliases = userConfig?.scopeAliases;
+  if (scopeAliases !== void 0) {
+    result.scopeAliases = scopeAliases;
   }
   return result;
 }

package/dist/esm/parseCommitMessage.d.ts

@@ -1,3 +1,3 @@
 import type { ParsedCommit, WorkTypeConfig } from './types.ts';
 export declare const COMMIT_PREPROCESSOR_PATTERNS: readonly RegExp[];
-export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, workspaceAliases?: Record<string, string>): ParsedCommit | undefined;
+export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, scopeAliases?: Record<string, string>): ParsedCommit | undefined;

package/dist/esm/parseCommitMessage.js

@@ -1,14 +1,15 @@
 const COMMIT_PREPROCESSOR_PATTERNS = [/^#\d+\s+/, /^[A-Z]+-\d+\s+/];
-function parseCommitMessage(message, hash, workTypes, workspaceAliases) {
+function parseCommitMessage(message, hash, workTypes, scopeAliases) {
   const stripped = stripTicketPrefix(message);
-  const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(!)?:\s*(.*)$/);
+  const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/);
   if (!match) {
     return void 0;
   }
-  const workspace = match[1];
+  const pipeScope = match[1];
   const rawType = match[2];
-  const breakingMarker = match[3];
-  const description = match[4];
+  const parenthesizedScope = match[3];
+  const breakingMarker = match[4];
+  const description = match[5];
   if (rawType === void 0 || description === void 0) {
     return void 0;
   }
@@ -17,14 +18,15 @@ function parseCommitMessage(message, hash, workTypes, workspaceAliases) {
     return void 0;
   }
   const breaking = breakingMarker === "!" || message.includes("BREAKING CHANGE:");
-  const resolvedWorkspace = workspace !== void 0 && workspaceAliases !== void 0 ? workspaceAliases[workspace] ?? workspace : workspace;
+  const rawScope = pipeScope ?? parenthesizedScope;
+  const resolvedScope = rawScope !== void 0 && scopeAliases !== void 0 ? scopeAliases[rawScope] ?? rawScope : rawScope;
   return {
     message,
     hash,
     type: resolvedType,
     description,
     breaking,
-    ...resolvedWorkspace !== void 0 && { workspace: resolvedWorkspace }
+    ...resolvedScope !== void 0 && { scope: resolvedScope }
   };
 }
 function resolveType(rawType, workTypes) {

package/dist/esm/prepareCommand.d.ts

@@ -1,6 +1,7 @@
 import type { WriteResult } from '@williamthorsen/node-monorepo-core';
 import type { ReleaseType } from './types.ts';
 export declare const RELEASE_TAGS_FILE = "tmp/.release-tags";
+export declare const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
 export declare function parseArgs(argv: string[]): {
     dryRun: boolean;
     force: boolean;