@williamthorsen/release-kit 4.8.0 → 5.0.0

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

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { commitCommand } from "../commitCommand.js";
-import { githubReleaseCommand } from "../githubReleaseCommand.js";
+import { createGithubReleaseCommand } from "../createGithubReleaseCommand.js";
 import { initCommand } from "../init/initCommand.js";
 import { prepareCommand } from "../prepareCommand.js";
 import { publishCommand } from "../publishCommand.js";
 import { pushCommand } from "../pushCommand.js";
+import { showTagPrefixesCommand } from "../showTagPrefixesCommand.js";
 import { generateCommand } from "../sync-labels/generateCommand.js";
 import { syncLabelsInitCommand } from "../sync-labels/initCommand.js";
 import { syncLabelsCommand } from "../sync-labels/syncCommand.js";
@@ -21,7 +22,8 @@ Commands:
   tag              Create annotated git tags from the tags file
   push             Push release commit and tags (one push per tag)
   publish          Publish packages with release tags on HEAD
-  github-release   Create GitHub Releases from changelog.json for tags on HEAD
+  create-github-release  Create GitHub Releases from changelog.json for tags on HEAD
+  show-tag-prefixes  Show derived and declared legacy tag prefixes per workspace
   init             Initialize release-kit in the current repository
   sync-labels      Manage GitHub label synchronization
 
@@ -100,9 +102,13 @@ Run release preparation with automatic workspace discovery.
 
 Options:
   --dry-run             Run without modifying any files
-  --bump=major|minor|patch  Override the bump type for all components
+  --bump=major|minor|patch  Override the bump type for all workspaces
+  --set-version=X.Y.Z   Set an explicit version; bypasses commit-derived bumps. Requires --only in monorepo mode.
   --no-git-checks, -n   Skip the clean-working-tree check
-  --only=name1,name2    Only process the named components (comma-separated, monorepo only)
+  --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only)
+  --with-release-notes  Also write per-workspace release-notes previews under {workspacePath}/docs/
+                         (docs/README.v{version}.md and docs/RELEASE_NOTES.v{version}.md).
+                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).
   --help, -h            Show this help message
 `);
 }
@@ -139,23 +145,36 @@ fires a separate workflow run per tag.
 
 Options:
   --dry-run              Preview without pushing
-  --only=name1,name2     Only push tags for the named packages (comma-separated, monorepo only)
+  --tags=tag1,tag2       Only push the named tags (comma-separated, full tag names)
   --tags-only            Skip the branch push (push tags only)
   --help, -h             Show this help message
 `);
 }
-function showGithubReleaseHelp() {
+function showCreateGithubReleaseHelp() {
   console.info(`
-Usage: release-kit github-release [options]
+Usage: release-kit create-github-release [options]
 
 Create GitHub Releases from changelog.json for tags on HEAD.
 
 Options:
   --dry-run              Preview without creating releases
-  --only=name1,name2     Only create releases for the named packages (comma-separated, monorepo only)
+  --tags=tag1,tag2       Only create releases for the named tags (comma-separated, full tag names)
   --help, -h             Show this help message
 `);
 }
+function showShowTagPrefixesHelp() {
+  console.info(`
+Usage: release-kit show-tag-prefixes [options]
+
+Print a per-workspace table of derived tag prefixes, tag counts, and declared
+legacy tag prefixes. Surfaces any release-shaped tags whose prefix is neither a
+derived prefix nor declared in \`legacyIdentities\`, with a copy-pasteable
+config snippet.
+
+Options:
+  --help, -h    Show this help message
+`);
+}
 function showPublishHelp() {
   console.info(`
 Usage: release-kit publish [options]
@@ -165,7 +184,7 @@ Publish packages that have release tags on HEAD.
 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)
+  --tags=tag1,tag2       Only publish the named tags (comma-separated, full tag names)
   --provenance           Generate provenance statement (requires OIDC, not supported by classic yarn)
   --help, -h             Show this help message
 `);
@@ -218,12 +237,12 @@ if (command === "push") {
   await pushCommand(flags);
   process.exit(0);
 }
-if (command === "github-release") {
+if (command === "create-github-release") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
-    showGithubReleaseHelp();
+    showCreateGithubReleaseHelp();
     process.exit(0);
   }
-  await githubReleaseCommand(flags);
+  await createGithubReleaseCommand(flags);
   process.exit(0);
 }
 if (command === "publish") {
@@ -234,6 +253,18 @@ if (command === "publish") {
   await publishCommand(flags);
   process.exit(0);
 }
+if (command === "show-tag-prefixes") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showShowTagPrefixesHelp();
+    process.exit(0);
+  }
+  if (flags.length > 0) {
+    console.error(`Error: Unknown option: ${flags[0]}`);
+    process.exit(1);
+  }
+  const exitCode = await showTagPrefixesCommand();
+  process.exit(exitCode);
+}
 if (command === "init") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
     showInitHelp();

package/dist/esm/buildDependencyGraph.d.ts

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

package/dist/esm/buildDependencyGraph.js

@@ -2,25 +2,25 @@ import { readFileSync } from "node:fs";
 function isPackageJsonSubset(value) {
   return typeof value === "object" && value !== null;
 }
-function buildDependencyGraph(components) {
+function buildDependencyGraph(workspaces) {
   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];
+  const workspacePackages = /* @__PURE__ */ new Map();
+  for (const workspace of workspaces) {
+    const primaryPackageFile = workspace.packageFiles[0];
     if (primaryPackageFile === void 0) {
       continue;
     }
     const pkg = readPackageJsonSubset(primaryPackageFile);
-    componentPackages.set(component, pkg);
+    workspacePackages.set(workspace, pkg);
     if (pkg.name === void 0) {
       continue;
     }
-    packageNameToDir.set(pkg.name, component.dir);
-    dirToPackageName.set(component.dir, pkg.name);
+    packageNameToDir.set(pkg.name, workspace.dir);
+    dirToPackageName.set(workspace.dir, pkg.name);
   }
-  for (const [component, pkg] of componentPackages) {
+  for (const [workspace, pkg] of workspacePackages) {
     const allDeps = { ...pkg.dependencies, ...pkg.peerDependencies };
     for (const [depName, depVersion] of Object.entries(allDeps)) {
       if (typeof depVersion !== "string" || !depVersion.startsWith("workspace:")) {
@@ -28,9 +28,9 @@ function buildDependencyGraph(components) {
       }
       const existing = dependentsOf.get(depName);
       if (existing === void 0) {
-        dependentsOf.set(depName, [component]);
+        dependentsOf.set(depName, [workspace]);
       } else {
-        existing.push(component);
+        existing.push(workspace);
       }
     }
   }

package/dist/esm/buildReleaseSummary.js

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

package/dist/esm/bumpAllVersions.d.ts

@@ -1,2 +1,3 @@
 import type { BumpResult, ReleaseType } from './types.ts';
 export declare function bumpAllVersions(packageFiles: readonly string[], releaseType: ReleaseType, dryRun: boolean): BumpResult;
+export declare function setAllVersions(packageFiles: readonly string[], newVersion: string, dryRun: boolean): BumpResult;

package/dist/esm/bumpAllVersions.js

@@ -11,6 +11,20 @@ function bumpAllVersions(packageFiles, releaseType, dryRun) {
   const firstPkg = readPackageJson(firstFile);
   const currentVersion = firstPkg.version;
   const newVersion = bumpVersion(currentVersion, releaseType);
+  writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
+  return { currentVersion, newVersion, files: [...packageFiles] };
+}
+function setAllVersions(packageFiles, newVersion, dryRun) {
+  const firstFile = packageFiles[0];
+  if (firstFile === void 0) {
+    throw new Error("No package files specified");
+  }
+  const firstPkg = readPackageJson(firstFile);
+  const currentVersion = firstPkg.version;
+  writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
+  return { currentVersion, newVersion, files: [...packageFiles] };
+}
+function writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun) {
   for (const filePath of packageFiles) {
     if (dryRun) {
       continue;
@@ -23,7 +37,6 @@ function bumpAllVersions(packageFiles, releaseType, dryRun) {
       throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  return { currentVersion, newVersion, files: [...packageFiles] };
 }
 function readPackageJson(filePath) {
   let content;
@@ -44,5 +57,6 @@ function readPackageJson(filePath) {
   return parsed;
 }
 export {
-  bumpAllVersions
+  bumpAllVersions,
+  setAllVersions
 };

package/dist/esm/bumpVersion.js

@@ -14,6 +14,9 @@ function bumpVersion(version, releaseType) {
   const patchNum = Number.parseInt(patch, 10);
   switch (releaseType) {
     case "major":
+      if (majorNum === 0) {
+        return `0.${minorNum + 1}.0`;
+      }
       return `${majorNum + 1}.0.0`;
     case "minor":
       return `${majorNum}.${minorNum + 1}.0`;

package/dist/esm/commitCommand.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./prepareCommand.js";
 const commitFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" }

package/dist/esm/compareVersions.d.ts

@@ -0,0 +1 @@
+export declare function isForwardVersion(current: string, target: string): boolean;

package/dist/esm/compareVersions.js

@@ -0,0 +1,27 @@
+const CANONICAL_SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/;
+function parseCanonicalSemver(version) {
+  const match = version.match(CANONICAL_SEMVER_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid semver version: '${version}'`);
+  }
+  const [, major = "", minor = "", patch = ""] = match;
+  return {
+    major: Number.parseInt(major, 10),
+    minor: Number.parseInt(minor, 10),
+    patch: Number.parseInt(patch, 10)
+  };
+}
+function isForwardVersion(current, target) {
+  const currentParsed = parseCanonicalSemver(current);
+  const targetParsed = parseCanonicalSemver(target);
+  if (targetParsed.major !== currentParsed.major) {
+    return targetParsed.major > currentParsed.major;
+  }
+  if (targetParsed.minor !== currentParsed.minor) {
+    return targetParsed.minor > currentParsed.minor;
+  }
+  return targetParsed.patch > currentParsed.patch;
+}
+export {
+  isForwardVersion
+};

package/dist/esm/createGithubRelease.d.ts

@@ -1,11 +1,15 @@
-import type { ReleaseNotesConfig } from './types.ts';
 export interface CreateGithubReleaseOptions {
     tag: string;
     changelogJsonPath: string;
     dryRun: boolean;
+    sectionOrder?: string[];
 }
 export declare function createGithubRelease(options: CreateGithubReleaseOptions): boolean;
+export interface CreateGithubReleasesOutcome {
+    created: string[];
+    skipped: string[];
+}
 export declare function createGithubReleases(tags: Array<{
     tag: string;
     workspacePath: string;
-}>, releaseNotes: ReleaseNotesConfig, changelogJsonOutputPath: string, dryRun: boolean): void;
+}>, changelogJsonOutputPath: string, dryRun: boolean, sectionOrder?: string[]): CreateGithubReleasesOutcome;

package/dist/esm/createGithubRelease.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
 function createGithubRelease(options) {
-  const { tag, changelogJsonPath, dryRun } = options;
+  const { tag, changelogJsonPath, dryRun, sectionOrder } = options;
   if (!existsSync(changelogJsonPath)) {
     console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
     return false;
@@ -25,7 +25,8 @@ function createGithubRelease(options) {
   }
   const body = renderReleaseNotesSingle(entry, {
     filter: matchesAudience("all"),
-    includeHeading: false
+    includeHeading: false,
+    ...sectionOrder === void 0 ? {} : { sectionOrder }
   });
   if (body.trim() === "") {
     return false;
@@ -35,24 +36,23 @@ function createGithubRelease(options) {
     console.info(`[dry-run] Would run: gh ${args.join(" ")}`);
     return true;
   }
-  try {
-    execFileSync("gh", args, { stdio: "inherit" });
-    return true;
-  } catch (error) {
-    console.warn(
-      `Warning: failed to create GitHub Release for ${tag}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return false;
-  }
+  execFileSync("gh", args, { stdio: "inherit" });
+  return true;
 }
-function createGithubReleases(tags, releaseNotes, changelogJsonOutputPath, dryRun) {
-  if (!releaseNotes.shouldCreateGithubRelease) {
-    return;
-  }
+function createGithubReleases(tags, changelogJsonOutputPath, dryRun, sectionOrder) {
+  const created = [];
+  const skipped = [];
   for (const { tag, workspacePath } of tags) {
     const changelogJsonPath = join(workspacePath, changelogJsonOutputPath);
-    createGithubRelease({ tag, changelogJsonPath, dryRun });
-  }
+    const result = createGithubRelease({
+      tag,
+      changelogJsonPath,
+      dryRun,
+      ...sectionOrder === void 0 ? {} : { sectionOrder }
+    });
+    (result ? created : skipped).push(tag);
+  }
+  return { created, skipped };
 }
 export {
   createGithubRelease,

package/dist/esm/createGithubReleaseCommand.d.ts

@@ -0,0 +1 @@
+export declare function createGithubReleaseCommand(argv: string[]): Promise<void>;

package/dist/esm/createGithubReleaseCommand.js

@@ -0,0 +1,41 @@
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
+import { createGithubReleases } from "./createGithubRelease.js";
+import { parseRequestedTags } from "./parseRequestedTags.js";
+import { resolveCommandTags } from "./resolveCommandTags.js";
+import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
+const createGithubReleaseFlagSchema = {
+  dryRun: { long: "--dry-run", type: "boolean" },
+  tags: { long: "--tags", type: "string" }
+};
+async function createGithubReleaseCommand(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, createGithubReleaseFlagSchema);
+  } catch (error) {
+    console.error(`Error: ${translateParseError(error)}`);
+    process.exit(1);
+  }
+  const { dryRun } = parsed.flags;
+  const requestedTags = parseRequestedTags(parsed.flags.tags);
+  const resolvedTags = await resolveCommandTags(requestedTags);
+  const { changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig({ strictLoad: true });
+  let outcome;
+  try {
+    outcome = createGithubReleases(resolvedTags, changelogJsonOutputPath, dryRun, sectionOrder);
+  } catch (error) {
+    console.error(`Error creating GitHub Releases: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  if (requestedTags !== void 0 && outcome.created.length === 0) {
+    console.error(
+      `Error: no GitHub Releases were created for requested tags: ${outcome.skipped.join(", ")}. Each was skipped (missing changelog entry, no all-audience content, or empty rendered body).`
+    );
+    process.exit(1);
+  }
+  if (outcome.skipped.length > 0) {
+    console.info(`Skipped ${outcome.skipped.length} tag(s) with no releasable content: ${outcome.skipped.join(", ")}.`);
+  }
+}
+export {
+  createGithubReleaseCommand
+};

package/dist/esm/defaults.js

@@ -11,6 +11,9 @@ const DEFAULT_WORK_TYPES = {
   ci: { header: "CI" },
   deps: { header: "Dependencies", aliases: ["dep"] },
   docs: { header: "Documentation", aliases: ["doc"] },
+  ai: { header: "Agentic support" },
+  // `fmt` is retained for bump-determination (`parseCommitMessage`), even though
+  // `cliff.toml.template` skips `fmt:` commits so they never enter the changelog.
   fmt: { header: "Formatting" }
 };
 const DEFAULT_VERSION_PATTERNS = {
@@ -20,11 +23,10 @@ const DEFAULT_VERSION_PATTERNS = {
 const DEFAULT_CHANGELOG_JSON_CONFIG = {
   enabled: true,
   outputPath: ".meta/changelog.json",
-  devOnlySections: ["CI", "Dependencies", "Formatting", "Internal", "Tests", "Tooling"]
+  devOnlySections: ["Agentic support", "CI", "Dependencies", "Internal", "Refactoring", "Tests", "Tooling"]
 };
 const DEFAULT_RELEASE_NOTES_CONFIG = {
-  shouldInjectIntoReadme: false,
-  shouldCreateGithubRelease: false
+  shouldInjectIntoReadme: false
 };
 export {
   DEFAULT_CHANGELOG_JSON_CONFIG,

package/dist/esm/deriveWorkspaceConfig.d.ts

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

package/dist/esm/deriveWorkspaceConfig.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { isRecord } from "./typeGuards.js";
+function deriveWorkspaceConfig(workspacePath) {
+  const dir = basename(workspacePath);
+  const packageJsonPath = `${workspacePath}/package.json`;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read ${packageJsonPath}: ${message}`);
+  }
+  const name = isRecord(parsed) ? parsed.name : void 0;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
+  }
+  const unscopedName = stripNpmScope(name);
+  return {
+    dir,
+    name,
+    tagPrefix: `${unscopedName}-v`,
+    workspacePath,
+    packageFiles: [packageJsonPath],
+    changelogPaths: [workspacePath],
+    paths: [`${workspacePath}/**`]
+  };
+}
+function stripNpmScope(name) {
+  if (name.startsWith("@") && name.includes("/")) {
+    return name.slice(name.indexOf("/") + 1);
+  }
+  return name;
+}
+export {
+  deriveWorkspaceConfig
+};

package/dist/esm/detectUndeclaredTagPrefixes.d.ts

@@ -0,0 +1,7 @@
+export interface UndeclaredTagPrefix {
+    prefix: string;
+    tagCount: number;
+    exampleTags: string[];
+    suggestedDir: string;
+}
+export declare function detectUndeclaredTagPrefixes(knownPrefixes: readonly string[]): UndeclaredTagPrefix[];

package/dist/esm/detectUndeclaredTagPrefixes.js

@@ -0,0 +1,46 @@
+import { execFileSync } from "node:child_process";
+const EXAMPLE_TAG_LIMIT = 3;
+const CANDIDATE_TAG_PATTERN = /^(?<prefix>[a-z][a-z0-9-]*-v)\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/;
+function detectUndeclaredTagPrefixes(knownPrefixes) {
+  const known = new Set(knownPrefixes);
+  let rawOutput;
+  try {
+    rawOutput = execFileSync("git", ["tag", "--list"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return [];
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const line of rawOutput.split("\n")) {
+    const tag = line.trim();
+    if (tag === "") continue;
+    const match = CANDIDATE_TAG_PATTERN.exec(tag);
+    if (match === null) continue;
+    const prefix = match.groups?.prefix ?? "";
+    if (prefix === "" || known.has(prefix)) continue;
+    let tags = grouped.get(prefix);
+    if (tags === void 0) {
+      tags = [];
+      grouped.set(prefix, tags);
+    }
+    tags.push(tag);
+  }
+  const results = [];
+  for (const [prefix, tags] of grouped) {
+    results.push({
+      prefix,
+      tagCount: tags.length,
+      exampleTags: tags.slice(0, EXAMPLE_TAG_LIMIT),
+      suggestedDir: stripTrailingTagMarker(prefix)
+    });
+  }
+  return results.sort((a, b) => a.prefix.localeCompare(b.prefix));
+}
+function stripTrailingTagMarker(prefix) {
+  return prefix.endsWith("-v") ? prefix.slice(0, -2) : prefix;
+}
+export {
+  detectUndeclaredTagPrefixes
+};

package/dist/esm/generateChangelogJson.js

@@ -115,12 +115,17 @@ function transformReleases(releases, devOnlySections) {
     for (const commit of release.commits ?? []) {
       const group = commit.group ?? "Other";
       const description = extractDescription(commit.message);
+      const body = extractBody(commit.message);
       let items = sectionMap.get(group);
       if (items === void 0) {
         items = [];
         sectionMap.set(group, items);
       }
-      items.push({ description });
+      const item = { description };
+      if (body !== void 0) {
+        item.body = body;
+      }
+      items.push(item);
     }
     const sections = [];
     for (const [title, items] of sectionMap) {
@@ -147,6 +152,37 @@ function extractDescription(message) {
   }
   return firstLine;
 }
+const TRAILER_PATTERNS = [
+  /^Signed-off-by:/i,
+  /^Co-authored-by:/i,
+  /^(Closes|Fixes|Resolves)\s+#\d+\s*$/i,
+  /^https?:\/\/\S+\/pull\/\d+\/?\s*$/
+];
+function extractBody(message) {
+  const lines = message.split("\n").slice(1);
+  let start = 0;
+  while (start < lines.length && (lines[start] ?? "").trim() === "") {
+    start += 1;
+  }
+  let end = lines.length;
+  while (end > start) {
+    const line = lines[end - 1] ?? "";
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      end -= 1;
+      continue;
+    }
+    if (TRAILER_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+      end -= 1;
+      continue;
+    }
+    break;
+  }
+  if (end <= start) {
+    return void 0;
+  }
+  return lines.slice(start, end).join("\n").trim();
+}
 function readExistingEntries(filePath) {
   if (!existsSync(filePath)) {
     return [];

package/dist/esm/generateChangelogs.d.ts

@@ -1,5 +1,5 @@
 import type { ReleaseConfig } from './types.ts';
-export declare function buildTagPattern(tagPrefix: string): string;
+export declare function buildTagPattern(tagPrefixes: readonly string[]): string;
 export interface GenerateChangelogOptions {
     tagPattern?: string;
     includePaths?: string[];

package/dist/esm/generateChangelogs.js

@@ -3,8 +3,19 @@ import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
-function buildTagPattern(tagPrefix) {
-  return `${tagPrefix}[0-9].*`;
+function buildTagPattern(tagPrefixes) {
+  if (tagPrefixes.length === 0) {
+    throw new Error("buildTagPattern: tagPrefixes must contain at least one entry");
+  }
+  if (tagPrefixes.length === 1) {
+    const single = tagPrefixes[0] ?? "";
+    return `${single}[0-9].*`;
+  }
+  const escaped = tagPrefixes.map(escapeRegex);
+  return `(${escaped.join("|")})[0-9].*`;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
 }
 function generateChangelog(config, changelogPath, tag, dryRun, options) {
   const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
@@ -41,7 +52,7 @@ function generateChangelog(config, changelogPath, tag, dryRun, options) {
   }
 }
 function generateChangelogs(config, tag, dryRun) {
-  const tagPattern = buildTagPattern(config.tagPrefix);
+  const tagPattern = buildTagPattern([config.tagPrefix]);
   const results = [];
   for (const changelogPath of config.changelogPaths) {
     results.push(...generateChangelog(config, changelogPath, tag, dryRun, { tagPattern }));

package/dist/esm/getCommitsSinceTarget.d.ts

@@ -1,5 +1,5 @@
 import type { Commit } from './types.ts';
-export declare function getCommitsSinceTarget(tagPrefix: string, paths?: string[]): {
+export declare function getCommitsSinceTarget(tagPrefixes: readonly string[], paths?: string[]): {
     tag: string | undefined;
     commits: Commit[];
 };