@williamthorsen/release-kit 10.9.0 → 12.0.0

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

@@ -2,6 +2,7 @@
 import { parseArgsOrExit, readPackageVersion, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { commitCommand } from "../commitCommand.js";
+import { configFlagSchema } from "../configFlagSchema.js";
 import { createGithubReleaseCommand } from "../createGithubReleaseCommand.js";
 import { showPrepareHelp } from "../help/prepareHelp.js";
 import { initCommand } from "../init/initCommand.js";
@@ -68,9 +69,10 @@ retired packages, then generate .github/labels.yaml. When the config file alread
 exists, print the block for manual paste instead of rewriting the file.
 
 Options:
-  --dry-run     Preview changes without writing files
-  --force       Overwrite existing files instead of skipping them
-  --help, -h    Show this help message
+  --config <path>  Path to config file (default: .config/release-kit.config.ts)
+  --dry-run        Preview changes without writing files
+  --force          Overwrite existing files instead of skipping them
+  --help, -h       Show this help message
 `);
 }
 function showSyncLabelsGenerateHelp() {
@@ -80,8 +82,9 @@ Usage: release-kit sync-labels generate [options]
 Regenerate .github/labels.yaml from the repoLabels block of .config/release-kit.config.ts.
 
 Options:
-  --check       Report whether .github/labels.yaml is stale instead of writing it
-  --help, -h    Show this help message
+  --check          Report whether .github/labels.yaml is stale instead of writing it
+  --config <path>  Path to config file (default: .config/release-kit.config.ts)
+  --help, -h       Show this help message
 `);
 }
 function showSyncLabelsSyncHelp() {
@@ -102,7 +105,7 @@ Initialize release-kit in the current repository.
 By default, scaffolds only the GitHub Actions workflow files.
 
 Options:
-  --with-config   Also scaffold .config/release-kit.config.ts and .config/git-cliff.toml
+  --with-config   Also scaffold .config/release-kit.config.ts
   --force         Overwrite existing files instead of skipping them
   --dry-run       Preview changes without writing files
   --help, -h      Show this help message
@@ -154,6 +157,7 @@ Create GitHub Releases from changelog.json for tags on HEAD. Private
 (package.json#private) workspaces are skipped with a warning and get no Release.
 
 Options:
+  --config <path>        Path to config file (default: .config/release-kit.config.ts)
   --dry-run              Preview without creating releases
   --tags=tag1,tag2       Only create releases for the named tags (comma-separated, full tag names)
   --help, -h             Show this help message
@@ -169,7 +173,8 @@ derived prefix nor declared in \`legacyIdentities\`, with a copy-pasteable
 config snippet.
 
 Options:
-  --help, -h    Show this help message
+  --config <path>  Path to config file (default: .config/release-kit.config.ts)
+  --help, -h       Show this help message
 `);
 }
 function showOverridesHelp() {
@@ -190,15 +195,17 @@ function showOverridesValidateHelp() {
 Usage: release-kit overrides validate
 
 Validate every \`.meta/changelog-overrides.json\` file across the project and per-workspace
-scopes. Reports schema/parse errors, ambiguous-prefix errors, and stale-key warnings.
+scopes. Reports schema/parse errors, ambiguous-prefix errors, conflicting-key errors, and
+stale-key warnings.
 
 Exit codes:
   0    Clean — no errors, no stale keys
   1    Stale-key warnings only (no errors)
-  2    Schema/parse or ambiguous-prefix errors (errors dominate)
+  2    Schema/parse, ambiguous-prefix, or conflicting-key errors (errors dominate)
 
 Options:
-  --help, -h    Show this help message
+  --config <path>  Path to config file (default: .config/release-kit.config.ts)
+  --help, -h       Show this help message
 `);
 }
 function showPublishHelp() {
@@ -211,6 +218,7 @@ silently filtered out. With --tags, an unpublishable tag is skipped with a warni
 any publishable tags still publish.
 
 Options:
+  --config <path>        Path to config file (default: .config/release-kit.config.ts)
   --dry-run              Preview without publishing
   --no-git-checks        Skip the clean-working-tree check
   --tags=tag1,tag2       Only publish the named tags (comma-separated, full tag names)
@@ -269,7 +277,7 @@ if (command === 'push') {
         showPushHelp();
         process.exit(0);
     }
-    await pushCommand(flags);
+    pushCommand(flags);
     process.exit(0);
 }
 if (command === 'create-github-release') {
@@ -293,11 +301,8 @@ if (command === 'show-tag-prefixes') {
         showShowTagPrefixesHelp();
         process.exit(0);
     }
-    if (flags.length > 0) {
-        reportError(`Unknown option: ${flags[0]}`);
-        process.exit(1);
-    }
-    const exitCode = await showTagPrefixesCommand(styles);
+    const { config } = parseArgsOrExit(flags, configFlagSchema).flags;
+    const exitCode = await showTagPrefixesCommand(styles, config);
     process.exit(exitCode);
 }
 if (command === 'init') {
@@ -327,11 +332,17 @@ if (command === 'sync-labels') {
             process.exit(0);
         }
         const syncLabelsInitFlagSchema = {
+            ...configFlagSchema,
             dryRun: { long: '--dry-run', type: 'boolean' },
             force: { long: '--force', type: 'boolean' },
         };
-        const { dryRun, force } = parseArgsOrExit(subflags, syncLabelsInitFlagSchema).flags;
-        const exitCode = await syncLabelsInitCommand({ dryRun, force, styles });
+        const { config, dryRun, force } = parseArgsOrExit(subflags, syncLabelsInitFlagSchema).flags;
+        const exitCode = await syncLabelsInitCommand({
+            ...(config !== undefined && { configPath: config }),
+            dryRun,
+            force,
+            styles,
+        });
         process.exit(exitCode);
     }
     if (subcommand === 'generate') {
@@ -340,10 +351,11 @@ if (command === 'sync-labels') {
             process.exit(0);
         }
         const generateFlagSchema = {
+            ...configFlagSchema,
             check: { long: '--check', type: 'boolean' },
         };
-        const { check } = parseArgsOrExit(subflags, generateFlagSchema).flags;
-        const exitCode = await generateCommand({ check, styles });
+        const { check, config } = parseArgsOrExit(subflags, generateFlagSchema).flags;
+        const exitCode = await generateCommand({ check, ...(config !== undefined && { configPath: config }), styles });
         process.exit(exitCode);
     }
     if (subcommand === 'sync') {
@@ -374,11 +386,8 @@ if (command === 'overrides') {
             showOverridesValidateHelp();
             process.exit(0);
         }
-        if (subflags.length > 0) {
-            reportError(`Unknown option: ${subflags[0]}`);
-            process.exit(1);
-        }
-        const result = await validateOverridesCommand(styles);
+        const { config } = parseArgsOrExit(subflags, configFlagSchema).flags;
+        const result = await validateOverridesCommand(styles, config);
         if (result.exitCode === 0) {
             console.info(result.message);
         }

package/dist/esm/buildChangelogEntries.d.ts

@@ -1,26 +1,68 @@
+import { type RawCommit } from './enumerateReleaseWindows.js';
 import type { GenerateChangelogOptions } from './generateChangelogs.js';
-import type { ChangelogEntry, ReleaseConfig } from './types.js';
+import type { ChangelogEntry, ChangelogSection, MalformedChangeRecordBlock, PolicyViolation, ReleaseConfig, ReleaseType, UndeclaredEntryType } from './types.js';
 /**
- * Strip cliff-template decorations from a group string, returning the bare section name.
+ * Strips a section title down to its bare name.
  *
- * The bundled `cliff.toml.template` encodes canonical row order as a hidden HTML comment
- * (e.g. `"<!-- 04 -->🐛 Bug fixes"`) so tera's `group_by` filter sorts groups predictably.
- * The body template's `striptags` filter erases the comment from the rendered heading,
- * but downstream consumers that read the raw `group` value (changelog.json titles, the
- * dev-vs-public classifier, the drift test) see the prefix and must strip it. The trailing
- * `stripEmojiPrefix` keeps the helper backward-compatible with consumer overrides written
- * as bare names.
+ * A default title carries a leading emoji (e.g. `"🐛 Bug fixes"`), while a consumer's
+ * `devOnlySections` or `workTypes` override may be written as a bare name. Comparing both sides
+ * through this helper lets the two forms match.
  */
 export declare function stripGroupDecorations(group: string): string;
 /**
- * Build structured changelog entries from git history using git-cliff `--context`.
+ * Builds structured changelog entries from the release windows of git history, naming the unreleased window `tag`.
  *
- * Pure data: invokes git-cliff, parses its `--context` output, and returns the transformed
- * `ChangelogEntry[]`. Performs no `changelog.json` I/O — callers persist the entries via
- * `renderChangelogJson`.
+ * Composes `readReleaseHistory` and `toChangelogEntries` for a caller that knows the tag before it reads. Performs no
+ * `changelog.json` I/O; callers persist the entries via `renderChangelogJson`.
+ */
+export declare function buildChangelogEntries(config: ReleaseHistoryConfig, tag: string, options: GenerateChangelogOptions): {
+    entries: ChangelogEntry[];
+    diagnostics: ChangelogDiagnostics;
+};
+/** What reading the unreleased window reports beyond its items. */
+export interface ChangelogDiagnostics {
+    malformedBlocks: MalformedChangeRecordBlock[];
+    /** Breaking-policy violations of the window's titles and change-record entries. */
+    policyViolations: PolicyViolation[];
+    undeclaredEntryTypes: UndeclaredEntryType[];
+}
+/**
+ * Reads a scope's release windows once and returns the changelog items of every window, with what the unreleased
+ * window decides: its commits, its bump, and its diagnostics.
  *
- * Always invokes git-cliff: dry-run is the caller's concern (it governs whether the file write happens,
- * not whether git-cliff runs). This means dry-run exercises the full git-cliff toolchain and surfaces missing-binary,
- * malformed-config, and template-resolution failures earlier than before.
+ * A commit whose last `change-record` block records entries yields one item per entry; any other commit is
+ * classified by its title through `classifyChangelogCommit`. A `release:` or merge subject yields nothing either
+ * way. Only the unreleased window records diagnostics, since the released windows were reported when they were
+ * prepared.
  */
-export declare function buildChangelogEntries(config: Pick<ReleaseConfig, 'breakingPolicies' | 'changelogJson' | 'cliffConfigPath' | 'workTypes'>, tag: string, options?: GenerateChangelogOptions): ChangelogEntry[];
+export declare function readReleaseHistory(config: ReleaseHistoryConfig, options: GenerateChangelogOptions): ReleaseHistory;
+/** The configuration that `readReleaseHistory` reads. */
+export type ReleaseHistoryConfig = Pick<ReleaseConfig, 'breakingPolicies' | 'changelogJson' | 'versionPatterns' | 'workTypes'>;
+/** One read of a scope's release windows. */
+export interface ReleaseHistory {
+    /** The newest matching tag that HEAD reaches; undefined when none does. */
+    previousTag: string | undefined;
+    /** Entries of the released windows, newest first; a window that yields no item contributes none. */
+    releasedEntries: ChangelogEntry[];
+    unreleased: UnreleasedWindowReading;
+}
+/** The unreleased window: its changelog sections and commits, and the bump and diagnostics that they determine. */
+export interface UnreleasedWindowReading {
+    /** The highest bump that the window's items call for; undefined when the window yields no item. */
+    bump: ReleaseType | undefined;
+    /** The window's commits, newest first, without release commits. */
+    commits: RawCommit[];
+    /** The date of the window's entry, from the time of the read. */
+    date: string;
+    diagnostics: ChangelogDiagnostics;
+    /** The number of commits that yield at least one item. */
+    parsedCommitCount: number;
+    sections: ChangelogSection[];
+    /**
+     * Commits that yield no item and that neither an exclusion nor a diagnostic accounts for, newest first; undefined
+     * when none.
+     */
+    unparseableCommits: RawCommit[] | undefined;
+}
+/** Labels the unreleased window of `history` with `tag` and returns the entries of every window, newest first. */
+export declare function toChangelogEntries(history: ReleaseHistory, tag: string): ChangelogEntry[];

package/dist/esm/buildChangelogEntries.js

@@ -1,145 +1,228 @@
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { extractVersion } from "./changelogJsonUtils.js";
-import { DEFAULT_BREAKING_POLICIES, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { classifyChangelogCommit, isNonChangeSubject, isReleaseSubject } from "./classifyChangelogCommit.js";
+import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { determineBumpType } from "./determineBumpType.js";
+import { enumerateReleaseWindows } from "./enumerateReleaseWindows.js";
 import { extractMigration } from "./extractMigration.js";
-import { COMMIT_PREPROCESSOR_PATTERNS, parseCommitMessage, PIPE_SCOPE_SOURCE } from "./parseCommitMessage.js";
-import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
-import { runGitCliff } from "./runGitCliff.js";
+import { parseChangeRecordBlock, stripChangeRecordBlocks } from "./parseChangeRecordBlock.js";
+import { COMMIT_PREPROCESSOR_PATTERNS, evaluateBreakingPolicy, PIPE_SCOPE_SOURCE, resolveType, } from "./parseCommitMessage.js";
 import { stripEmojiPrefix } from "./stripEmojiPrefix.js";
-import { isRecord, isUnknownArray } from "./typeGuards.js";
-const HTML_COMMENT_PREFIX_PATTERN = /^<!--[^>]*-->/;
+const UNRELEASED_TAG = 'unreleased';
 const CANONICAL_SECTION_ORDER = new Map(Object.values(DEFAULT_WORK_TYPES).map((config, index) => [stripGroupDecorations(config.header), index]));
 function canonicalSectionPriority(title) {
     const index = CANONICAL_SECTION_ORDER.get(stripGroupDecorations(title));
     return index ?? Infinity;
 }
 export function stripGroupDecorations(group) {
-    return stripEmojiPrefix(group.replace(HTML_COMMENT_PREFIX_PATTERN, ''));
+    return stripEmojiPrefix(group);
 }
 export function buildChangelogEntries(config, tag, options) {
-    const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
-    const cliffArgs = ['--context', '--tag', tag];
-    if (options?.tagPattern !== undefined) {
-        cliffArgs.push('--tag-pattern', options.tagPattern);
-    }
-    const includePaths = options?.includePaths ?? [];
-    for (const includePath of includePaths) {
-        cliffArgs.push('--include-path', includePath);
-    }
+    const history = readReleaseHistory(config, options);
+    return { entries: toChangelogEntries(history, tag), diagnostics: history.unreleased.diagnostics };
+}
+export function readReleaseHistory(config, options) {
     try {
-        const contextJson = runGitCliff(resolvedConfigPath, cliffArgs);
-        const releases = parseCliffContext(contextJson);
-        const devOnlySections = new Set(config.changelogJson.devOnlySections);
-        const workTypes = config.workTypes ?? DEFAULT_WORK_TYPES;
-        const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
-        return transformReleases(releases, devOnlySections, workTypes, breakingPolicies);
+        const windows = enumerateReleaseWindows({
+            ...(options.paths !== undefined && { paths: options.paths }),
+            tagPrefixes: options.tagPrefixes,
+            unreleasedTag: UNRELEASED_TAG,
+        });
+        const context = {
+            breakingPolicies: config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES,
+            devOnlySections: new Set(config.changelogJson.devOnlySections.map(stripGroupDecorations)),
+            versionPatterns: config.versionPatterns ?? DEFAULT_VERSION_PATTERNS,
+            workTypes: config.workTypes ?? DEFAULT_WORK_TYPES,
+        };
+        return transformReleases(windows, context);
     }
     catch (error) {
-        throw chainError(`Failed to build changelog entries for tag ${tag}`, error);
+        throw chainError(`Failed to read the release history for ${options.tagPrefixes.join(', ')}`, error);
     }
 }
-function parseCliffContext(json) {
-    const parsed = JSON.parse(json);
-    if (!isUnknownArray(parsed)) {
-        throw new TypeError('Expected git-cliff --context output to be an array');
+export function toChangelogEntries(history, tag) {
+    const { unreleased } = history;
+    if (unreleased.sections.length === 0) {
+        return [...history.releasedEntries];
     }
-    return parsed.map(toCliffContextRelease);
+    return [
+        { version: extractVersion(tag), date: unreleased.date, sections: unreleased.sections },
+        ...history.releasedEntries,
+    ];
 }
-function toCliffContextRelease(value) {
-    if (!isRecord(value)) {
-        return {};
+function transformReleases(windows, context) {
+    const [unreleasedWindow, baselineWindow] = windows;
+    const diagnostics = { malformedBlocks: [], policyViolations: [], undeclaredEntryTypes: [] };
+    const signals = [];
+    const unparseable = [];
+    let parsedCommitCount = 0;
+    const sectionMap = new Map();
+    const unreleasedCommits = unreleasedWindow?.commits ?? [];
+    for (const commit of unreleasedCommits) {
+        const reading = readCommit(commit, context, diagnostics);
+        for (const derived of reading.items) {
+            appendItem(sectionMap, derived.header, derived.item);
+            signals.push(derived.signal);
+        }
+        if (reading.items.length > 0) {
+            parsedCommitCount += 1;
+        }
+        else if (reading.isUnparseable) {
+            unparseable.push(commit);
+        }
     }
-    const release = {};
-    if (typeof value['version'] === 'string') {
-        release.version = value['version'];
+    const releasedEntries = [];
+    for (const release of windows.slice(1)) {
+        const releaseSections = new Map();
+        for (const commit of release.commits) {
+            for (const derived of readCommit(commit, context, undefined).items) {
+                appendItem(releaseSections, derived.header, derived.item);
+            }
+        }
+        const sections = buildSections(releaseSections, context.devOnlySections);
+        if (sections.length > 0) {
+            releasedEntries.push({ version: extractVersion(release.version), date: formatDate(release.timestamp), sections });
+        }
     }
-    if (typeof value['timestamp'] === 'number') {
-        release.timestamp = value['timestamp'];
+    return {
+        previousTag: baselineWindow?.version,
+        releasedEntries,
+        unreleased: {
+            bump: determineBumpType(signals, context.workTypes, context.versionPatterns),
+            commits: unreleasedCommits.filter((commit) => !isReleaseSubject(commit.subject)).toReversed(),
+            date: formatDate(unreleasedWindow?.timestamp ?? Math.floor(Date.now() / 1_000)),
+            diagnostics,
+            parsedCommitCount,
+            sections: buildSections(sectionMap, context.devOnlySections),
+            unparseableCommits: unparseable.length > 0 ? unparseable.toReversed() : undefined,
+        },
+    };
+}
+function readCommit(commit, context, diagnostics) {
+    if (isNonChangeSubject(commit.subject)) {
+        return { items: [], isUnparseable: false };
     }
-    if (isUnknownArray(value['commits'])) {
-        release.commits = value['commits'].map(toCliffContextCommit);
+    const reading = parseChangeRecordBlock(commit.message);
+    if (reading.kind === 'malformed') {
+        diagnostics?.malformedBlocks.push({
+            commitHash: commit.hash,
+            commitSubject: commit.subject,
+            reason: reading.reason,
+        });
     }
-    return release;
-}
-function toCliffContextCommit(value) {
-    if (!isRecord(value)) {
-        return { message: '' };
+    if (reading.kind === 'read' && reading.entries.length > 0) {
+        const items = reading.entries.flatMap((entry, entryIndex) => buildEntryItem(commit, entry, entryIndex + 1, reading.prNumber, context, diagnostics) ?? []);
+        return { items, isUnparseable: false };
     }
-    const commit = {
-        message: typeof value['message'] === 'string' ? value['message'] : '',
-    };
-    if (typeof value['group'] === 'string') {
-        commit.group = value['group'];
+    const classification = classifyChangelogCommit(commit, context.workTypes, {
+        breakingPolicies: context.breakingPolicies,
+        ...(diagnostics !== undefined && {
+            onPolicyViolation: (violating, type, surface) => {
+                diagnostics.policyViolations.push({
+                    commitHash: violating.hash,
+                    commitSubject: violating.subject,
+                    type,
+                    surface,
+                });
+            },
+        }),
+    });
+    if (classification.kind !== 'header') {
+        return { items: [], isUnparseable: classification.kind === 'unparseable' && reading.kind !== 'malformed' };
     }
-    if (typeof value['id'] === 'string') {
-        commit.id = value['id'];
+    const item = buildTitleItem(commit, classification.breaking);
+    return {
+        items: [
+            { header: classification.header, item, signal: { type: classification.type, breaking: item.breaking === true } },
+        ],
+        isUnparseable: false,
+    };
+}
+function buildSections(sectionMap, devOnlySections) {
+    const sections = [];
+    for (const [title, items] of sectionMap) {
+        sections.push({
+            title,
+            audience: devOnlySections.has(stripGroupDecorations(title)) ? 'dev' : 'all',
+            items,
+        });
     }
-    return commit;
+    return sections.toSorted((a, b) => canonicalSectionPriority(a.title) - canonicalSectionPriority(b.title));
 }
-function transformReleases(releases, devOnlySections, workTypes, breakingPolicies) {
-    const entries = [];
-    const devOnlyNormalised = new Set([...devOnlySections].map(stripGroupDecorations));
-    for (const release of releases) {
-        if (release.version === undefined) {
-            continue;
-        }
-        const version = extractVersion(release.version);
-        const date = release.timestamp !== undefined ? new Date(release.timestamp * 1_000).toISOString().slice(0, 10) : 'unreleased';
-        const sectionMap = new Map();
-        const commits = release.commits ?? [];
-        for (const commit of commits) {
-            const group = stripCommentPrefix(commit.group ?? 'Other');
-            const description = extractDescription(commit.message);
-            const body = extractBody(commit.message);
-            const breaking = isBreakingUnderPolicy(commit, workTypes, breakingPolicies);
-            let items = sectionMap.get(group);
-            if (items === undefined) {
-                items = [];
-                sectionMap.set(group, items);
-            }
-            const item = { description };
-            if (body !== undefined) {
-                item.body = body;
-            }
-            if (breaking) {
-                item.breaking = true;
-            }
-            const migration = extractMigration(body);
-            if (migration !== undefined) {
-                item.migration = migration;
-            }
-            if (commit.id !== undefined && commit.id !== '') {
-                item.hash = commit.id;
-            }
-            items.push(item);
-        }
-        const sections = [];
-        for (const [title, items] of sectionMap) {
-            if (items.length === 0) {
-                continue;
-            }
-            sections.push({
-                title,
-                audience: devOnlyNormalised.has(stripGroupDecorations(title)) ? 'dev' : 'all',
-                items,
-            });
-        }
-        sections.sort((a, b) => canonicalSectionPriority(a.title) - canonicalSectionPriority(b.title));
-        if (sections.length > 0) {
-            entries.push({ version, date, sections });
-        }
+function formatDate(timestamp) {
+    return new Date(timestamp * 1_000).toISOString().slice(0, 10);
+}
+function appendItem(sectionMap, header, item) {
+    let items = sectionMap.get(header);
+    if (items === undefined) {
+        items = [];
+        sectionMap.set(header, items);
     }
-    return entries;
+    items.push(item);
 }
-function stripCommentPrefix(group) {
-    return group.replace(HTML_COMMENT_PREFIX_PATTERN, '');
+function buildEntryItem(commit, entry, position, prNumber, context, diagnostics) {
+    const { breakingPolicies, workTypes } = context;
+    const type = resolveType(entry.type, workTypes);
+    if (type === undefined) {
+        diagnostics?.undeclaredEntryTypes.push({
+            commitHash: commit.hash,
+            commitSubject: commit.subject,
+            entryPosition: position,
+            type: entry.type,
+        });
+        return undefined;
+    }
+    const config = workTypes[type];
+    if (config === undefined || config.excludedFromChangelog === true) {
+        return undefined;
+    }
+    const breaking = evaluateBreakingPolicy({
+        commit: { message: commit.message, subject: commit.subject, hash: commit.hash },
+        resolvedType: type,
+        hasPrefixBreaking: entry.breaking,
+        hasFooterBreaking: false,
+        policy: breakingPolicies[type] ?? 'optional',
+        prefixSurface: 'entry',
+        onPolicyViolation: diagnostics === undefined
+            ? undefined
+            : (violating, violatedType, surface) => {
+                diagnostics.policyViolations.push({
+                    commitHash: violating.hash,
+                    commitSubject: violating.subject,
+                    type: violatedType,
+                    surface,
+                    entryPosition: position,
+                });
+            },
+    });
+    const item = {
+        description: prNumber === undefined ? entry.text : `${entry.text} (#${prNumber})`,
+    };
+    if (breaking) {
+        item.breaking = true;
+    }
+    if (entry.migration !== undefined) {
+        item.migration = entry.migration;
+    }
+    item.hash = commit.hash;
+    item.entry = position;
+    return { header: config.header, item, signal: { type, breaking } };
 }
-function isBreakingUnderPolicy(commit, workTypes, breakingPolicies) {
-    if (!subjectHasBreakingMarker(commit.message)) {
-        return false;
+function buildTitleItem(commit, isParsedBreaking) {
+    const body = extractBody(stripChangeRecordBlocks(commit.message));
+    const item = { description: extractDescription(commit.message) };
+    if (body !== undefined) {
+        item.body = body;
+    }
+    if (isParsedBreaking && subjectHasBreakingMarker(commit.message)) {
+        item.breaking = true;
+    }
+    const migration = extractMigration(body);
+    if (migration !== undefined) {
+        item.migration = migration;
     }
-    const parsed = parseCommitMessage(commit.message, commit.id ?? '', workTypes, undefined, { breakingPolicies });
-    return parsed?.breaking ?? true;
+    item.hash = commit.hash;
+    return item;
 }
 const SUBJECT_BREAKING_MARKER_PATTERN = new RegExp(String.raw `^(?:${PIPE_SCOPE_SOURCE}\|)?\w+(?:\([^)]+\))?!:`);
 function subjectHasBreakingMarker(message) {
@@ -158,6 +241,7 @@ function extractDescription(message) {
     return firstLine;
 }
 const TRAILER_PATTERNS = [
+    /^Change:/i,
     /^Signed-off-by:/i,
     /^Co-authored-by:/i,
     /^(Closes|Fixes|Resolves)\s+#\d+\s*$/i,

package/dist/esm/buildReleaseSummary.js

@@ -11,7 +11,7 @@ export function buildReleaseSummary(result) {
         }
         const lines = [workspace.tag];
         for (const commit of commits) {
-            lines.push(`- ${stripScope(commit.message)}`);
+            lines.push(`- ${stripScope(commit.subject)}`);
         }
         sections.push(lines.join('\n'));
     }
@@ -19,7 +19,7 @@ export function buildReleaseSummary(result) {
     if (project !== undefined && project.status === 'released' && project.commits.length > 0) {
         const lines = [project.tag];
         for (const commit of project.commits) {
-            lines.push(`- ${stripScope(commit.message)}`);
+            lines.push(`- ${stripScope(commit.subject)}`);
         }
         sections.push(lines.join('\n'));
     }