@williamthorsen/release-kit 11.0.0 → 12.0.0

package/dist/esm/releasePrepare.d.ts

@@ -8,12 +8,11 @@ import type { ReleaseConfig, ReleaseType } from './types.js';
  */
 export interface ReleasePrepareOptions {
     /**
-     * Release even when no commits or no bump-worthy commits exist since the last tag
-     * (monorepo only). Orthogonal to `bumpOverride`: when `bumpOverride` is not given,
-     * the release falls back to `patch`.
+     * Release even when no commits or no bump-worthy commits exist since the last tag.
+     * Orthogonal to `bumpOverride`: when `bumpOverride` is not given, the release falls back to `patch`.
      */
     force?: boolean;
-    /** Override the bump type instead of determining it from commits. */
+    /** Choose the level of a release instead of the level that the changelog items call for; triggers no release. */
     bumpOverride?: ReleaseType;
     /**
      * Explicit target version (canonical `N.N.N`) that bypasses commit-derived bump logic.
@@ -39,11 +38,11 @@ export interface ReleasePrepareOptions {
 /**
  * Orchestrate the release preparation workflow for a single package.
  *
- * 1. Gets commits since the last tag.
- * 2. Determines the bump type from commits (or uses the override).
+ * 1. Reads the release history once.
+ * 2. Decides the release from the history's bump, `--force`, and `--bump` (or takes `--set-version`).
  * 3. Bumps all configured package.json version fields.
- * 4. Generates changelogs via git-cliff.
- * 5. Runs the optional format command.
+ * 4. Generates changelogs from the same history.
+ * 5. Renders the optional format command.
  *
  * Returns a structured `PrepareResult` with all data needed for presentation.
  */

package/dist/esm/releasePrepare.js

@@ -1,13 +1,11 @@
 import { join as joinPath } from 'node:path';
-import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
+import { readReleaseHistory, toChangelogEntries } from "./buildChangelogEntries.js";
 import { buildEmptyReleaseEntry } from "./buildEmptyReleaseEntry.js";
 import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
 import { applyChangelogOverrides, formatStaleOverrideKeyWarning, loadOverridesForScopes, } from "./changelogOverrides.js";
-import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
-import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
-import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
-import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { decideRelease } from "./decideRelease.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
 import { resolveWorkTypes } from "./loadConfig.js";
 import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
@@ -15,46 +13,32 @@ import { planVersionBump, planVersionSet } from "./planVersionBump.js";
 import { renderChangelogMarkdown } from "./renderChangelogMarkdown.js";
 import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
 export function releasePrepare(config, options) {
-    const { bumpOverride, setVersion, withReleaseNotes } = options;
+    const { bumpOverride, force, setVersion, withReleaseNotes } = options;
     const writes = [];
-    const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
-    const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-    const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
     const overridesResult = loadOverridesForScopes({ project: '.' });
     if (overridesResult.errors.length > 0) {
         throw new Error(`Failed to load changelog overrides:\n  - ${overridesResult.errors.join('\n  - ')}`);
     }
     const overrides = overridesResult.project;
-    const { tag, commits } = getCommitsSinceTarget([config.tagPrefix]);
+    const history = readReleaseHistory(config, { tagPrefixes: [config.tagPrefix] });
+    const { commits } = history.unreleased;
+    const tag = history.previousTag;
+    const since = tag === undefined ? '(no previous release found)' : `since ${tag}`;
     let releaseType;
-    let parsedCommitCount;
-    let unparseableCommits;
-    const collector = createPolicyViolationCollector();
     let bump;
-    if (setVersion !== undefined) {
-        bump = planVersionSet(config.packageFiles, setVersion);
-    }
-    else {
-        if (bumpOverride === undefined) {
-            const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases, {
-                breakingPolicies,
-                onPolicyViolation: collector.onPolicyViolation,
-            });
-            parsedCommitCount = determination.parsedCommitCount;
-            unparseableCommits = determination.unparseableCommits;
-            releaseType = determination.releaseType;
-        }
-        else {
-            releaseType = bumpOverride;
-        }
-        if (releaseType === undefined) {
-            const skipped = buildSkippedSinglePackage({
-                commitCount: commits.length,
-                previousTag: tag,
-                parsedCommitCount,
-                unparseableCommits,
-                policyViolations: collector.violations.length > 0 ? collector.violations : undefined,
-            });
+    if (setVersion === undefined) {
+        const decision = decideRelease({
+            naturalBump: history.unreleased.bump,
+            commitCount: commits.length,
+            force,
+            bumpOverride,
+            skipReasons: {
+                noCommits: `No commits ${since}. Pass --force to release at patch. Skipping.`,
+                noBumpWorthy: `No bump-worthy commits ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`,
+            },
+        });
+        if (decision.outcome === 'skip') {
+            const skipped = buildSkippedSinglePackage(history, decision.skipReason);
             return {
                 workspaces: [skipped],
                 tags: [],
@@ -63,14 +47,18 @@ export function releasePrepare(config, options) {
                 formatCommand: undefined,
             };
         }
+        releaseType = decision.releaseType;
         bump = planVersionBump(config.packageFiles, releaseType);
     }
+    else {
+        bump = planVersionSet(config.packageFiles, setVersion);
+    }
     writes.push(...bump.writes);
     const newTag = `${config.tagPrefix}${bump.newVersion}`;
     const planWarnings = [];
     const changelogs = planSinglePackageChangelogs({
         config,
-        commits,
+        history,
         newTag,
         newVersion: bump.newVersion,
         overrides,
@@ -90,15 +78,12 @@ export function releasePrepare(config, options) {
         formatCommand = { command: `${formatCommandStr} ${modifiedFiles.join(' ')}`, files: modifiedFiles };
     }
     const released = buildReleasedSinglePackage({
-        commits,
+        history,
         bump,
         newTag,
         changelogFiles,
-        previousTag: tag,
-        parsedCommitCount,
         releaseType,
-        unparseableCommits,
-        policyViolations: collector.violations.length > 0 ? collector.violations : undefined,
+        bumpOverride: setVersion === undefined ? bumpOverride : undefined,
         setVersion,
         previewFiles: previewWrites.map((write) => write.path),
     });
@@ -114,28 +99,26 @@ export function releasePrepare(config, options) {
     }
     return plan;
 }
-function buildSkippedSinglePackage(args) {
+function buildSkippedSinglePackage(history, skipReason) {
+    const { unreleased } = history;
     const skipped = {
         status: 'skipped',
-        commitCount: args.commitCount,
-        skipReason: 'No release-worthy changes found. Skipping.',
+        commitCount: unreleased.commits.length,
+        parsedCommitCount: unreleased.parsedCommitCount,
+        skipReason,
     };
-    if (args.previousTag !== undefined) {
-        skipped.previousTag = args.previousTag;
-    }
-    if (args.parsedCommitCount !== undefined) {
-        skipped.parsedCommitCount = args.parsedCommitCount;
+    if (history.previousTag !== undefined) {
+        skipped.previousTag = history.previousTag;
     }
-    if (args.unparseableCommits !== undefined) {
-        skipped.unparseableCommits = args.unparseableCommits;
-    }
-    if (args.policyViolations !== undefined) {
-        skipped.policyViolations = args.policyViolations;
+    if (unreleased.unparseableCommits !== undefined) {
+        skipped.unparseableCommits = unreleased.unparseableCommits;
     }
+    attachChangelogDiagnostics(skipped, unreleased.diagnostics);
     return skipped;
 }
 function buildReleasedSinglePackage(args) {
-    const { commits, bump, newTag, changelogFiles, previousTag, parsedCommitCount, releaseType, unparseableCommits, policyViolations, setVersion, } = args;
+    const { history, bump, newTag, changelogFiles, releaseType, bumpOverride, setVersion } = args;
+    const { commits, diagnostics, parsedCommitCount, unparseableCommits } = history.unreleased;
     const released = {
         status: 'released',
         commitCount: commits.length,
@@ -146,21 +129,20 @@ function buildReleasedSinglePackage(args) {
         changelogFiles,
         commits,
     };
-    if (previousTag !== undefined) {
-        released.previousTag = previousTag;
-    }
-    if (parsedCommitCount !== undefined) {
-        released.parsedCommitCount = parsedCommitCount;
+    if (history.previousTag !== undefined) {
+        released.previousTag = history.previousTag;
     }
     if (releaseType !== undefined) {
         released.releaseType = releaseType;
+        released.parsedCommitCount = parsedCommitCount;
+        if (unparseableCommits !== undefined) {
+            released.unparseableCommits = unparseableCommits;
+        }
     }
-    if (unparseableCommits !== undefined) {
-        released.unparseableCommits = unparseableCommits;
-    }
-    if (policyViolations !== undefined) {
-        released.policyViolations = policyViolations;
+    if (bumpOverride !== undefined) {
+        released.bumpOverride = bumpOverride;
     }
+    attachChangelogDiagnostics(released, diagnostics);
     if (setVersion !== undefined) {
         released.setVersion = setVersion;
     }
@@ -170,13 +152,11 @@ function buildReleasedSinglePackage(args) {
     return released;
 }
 function planSinglePackageChangelogs(args) {
-    const { config, commits, newTag, newVersion, overrides, overrideWarnings } = args;
-    const isEmptyRange = commits.length === 0;
+    const { config, history, newTag, newVersion, overrides, overrideWarnings } = args;
+    const isEmptyRange = history.unreleased.commits.length === 0;
     const today = new Date().toISOString().slice(0, 10);
-    const baseEntries = isEmptyRange
-        ? [buildEmptyReleaseEntry(newVersion, today)]
-        : buildChangelogEntries(config, newTag);
-    const applied = applyChangelogOverrides(baseEntries, overrides);
+    const builtEntries = isEmptyRange ? [buildEmptyReleaseEntry(newVersion, today)] : toChangelogEntries(history, newTag);
+    const applied = applyChangelogOverrides(builtEntries, overrides);
     if (applied.errors.length > 0) {
         throw new Error(`Changelog override application failed:\n  - ${applied.errors.join('\n  - ')}`);
     }

package/dist/esm/releasePrepareMono.js

@@ -1,18 +1,16 @@
 import { join as joinPath } from 'node:path';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
-import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
+import { readReleaseHistory, toChangelogEntries } from "./buildChangelogEntries.js";
 import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { buildEmptyReleaseEntry } from "./buildEmptyReleaseEntry.js";
 import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { buildSyntheticChangelogEntry } from "./buildSyntheticChangelogEntry.js";
 import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
 import { applyWorkspaceOverrides, createOverrideContext, formatStaleOverrideKeyWarning, } from "./changelogOverrides.js";
-import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { decideRelease } from "./decideRelease.js";
-import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
-import { buildTagPattern, getAllTagPrefixes } from "./generateChangelogs.js";
-import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { getAllTagPrefixes } from "./generateChangelogs.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
 import { resolveWorkTypes } from "./loadConfig.js";
 import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
@@ -33,10 +31,10 @@ export function releasePrepareMono(config, options) {
     const { directBumps, directResults, skippedResults } = determineDirectBumps(config, options);
     const previousTags = new Map();
     for (const result of directResults.values()) {
-        previousTags.set(result.workspace.dir, result.tag);
+        previousTags.set(result.workspace.dir, result.history.previousTag);
     }
     for (const skipped of skippedResults) {
-        previousTags.set(skipped.workspace.dir, skipped.tag);
+        previousTags.set(skipped.workspace.dir, skipped.history.previousTag);
     }
     const graph = buildDependencyGraph(config.workspaces);
     const fullReleaseSet = propagateBumps(directBumps, graph);
@@ -111,9 +109,6 @@ function determineDirectBumps(config, options) {
     if (setVersion !== undefined && config.workspaces.length !== 1) {
         throw new Error(`--set-version requires exactly one workspace; received ${config.workspaces.length}`);
     }
-    const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
-    const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-    const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
     const directBumps = new Map();
     const directResults = new Map();
     const skippedResults = [];
@@ -122,7 +117,8 @@ function determineDirectBumps(config, options) {
     for (const workspace of config.workspaces) {
         const name = workspace.dir;
         const stageLabel = workspaceStageLabel(workspace.dir);
-        const { tag, commits } = tryStage(stageLabel, () => getCommitsSinceTarget(getAllTagPrefixes(workspace), workspace.paths));
+        const history = tryStage(stageLabel, () => readReleaseHistory(config, { tagPrefixes: getAllTagPrefixes(workspace), paths: workspace.paths }));
+        const tag = history.previousTag;
         const since = tag === undefined ? '(no previous release found)' : `since ${tag}`;
         if (tag === undefined) {
             maybeEmitBaselineHint(workspace, knownPrefixes, hintState);
@@ -131,54 +127,32 @@ function determineDirectBumps(config, options) {
             directBumps.set(workspace.dir, { releaseType: 'patch', newVersionOverride: setVersion });
             directResults.set(workspace.dir, {
                 workspace,
-                tag,
-                commits,
+                history,
                 releaseType: undefined,
-                parsedCommitCount: undefined,
-                unparseableCommits: undefined,
-                policyViolations: undefined,
                 bumpOverride: undefined,
                 setVersion,
             });
             continue;
         }
-        const collector = createPolicyViolationCollector();
-        const decision = tryStage(stageLabel, () => decideRelease({
-            commits,
+        const decision = decideRelease({
+            naturalBump: history.unreleased.bump,
+            commitCount: history.unreleased.commits.length,
             force,
             bumpOverride,
-            workTypes,
-            versionPatterns,
-            scopeAliases: config.scopeAliases,
-            breakingPolicies,
-            onPolicyViolation: collector.onPolicyViolation,
             skipReasons: {
                 noCommits: `No commits for ${name} ${since}. Pass --force to release at patch. Skipping.`,
                 noBumpWorthy: `No bump-worthy commits for ${name} ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`,
             },
-        }));
-        const policyViolations = collector.violations.length > 0 ? collector.violations : undefined;
+        });
         if (decision.outcome === 'skip') {
-            skippedResults.push({
-                workspace,
-                tag,
-                commitCount: commits.length,
-                parsedCommitCount: decision.parsedCommitCount,
-                unparseableCommits: decision.unparseableCommits,
-                policyViolations,
-                skipReason: decision.skipReason,
-            });
+            skippedResults.push({ workspace, history, skipReason: decision.skipReason });
             continue;
         }
         directBumps.set(workspace.dir, { releaseType: decision.releaseType });
         directResults.set(workspace.dir, {
             workspace,
-            tag,
-            commits,
+            history,
             releaseType: decision.releaseType,
-            parsedCommitCount: decision.parsedCommitCount,
-            unparseableCommits: decision.unparseableCommits,
-            policyViolations,
             bumpOverride,
         });
     }
@@ -190,24 +164,21 @@ function collectSkippedWorkspaces(skippedResults, fullReleaseSet) {
         if (fullReleaseSet.has(skipped.workspace.dir)) {
             continue;
         }
+        const { previousTag, unreleased } = skipped.history;
         const result = {
             name: skipped.workspace.dir,
             status: 'skipped',
-            commitCount: skipped.commitCount,
+            commitCount: unreleased.commits.length,
+            parsedCommitCount: unreleased.parsedCommitCount,
             skipReason: skipped.skipReason,
         };
-        if (skipped.tag !== undefined) {
-            result.previousTag = skipped.tag;
-        }
-        if (skipped.parsedCommitCount !== undefined) {
-            result.parsedCommitCount = skipped.parsedCommitCount;
+        if (previousTag !== undefined) {
+            result.previousTag = previousTag;
         }
-        if (skipped.unparseableCommits !== undefined) {
-            result.unparseableCommits = skipped.unparseableCommits;
-        }
-        if (skipped.policyViolations !== undefined) {
-            result.policyViolations = skipped.policyViolations;
+        if (unreleased.unparseableCommits !== undefined) {
+            result.unparseableCommits = unreleased.unparseableCommits;
         }
+        attachChangelogDiagnostics(result, unreleased.diagnostics);
         workspaces.push(result);
     }
     return workspaces;
@@ -256,15 +227,13 @@ function executeWorkspaceRelease(args) {
     tags.push(newTag);
     writes.push(...bump.writes);
     modifiedFiles.push(...workspace.packageFiles, ...workspace.changelogPaths.map((changelogPath) => joinPath(changelogPath, 'CHANGELOG.md')));
-    const isPropagationOnly = directResult === undefined;
-    const isEmptyRange = directResult !== undefined && directResult.commits.length === 0;
+    const directCommits = directResult?.history.unreleased.commits;
     const { changelogFiles, previewFiles } = generateWorkspaceChangelogs({
         workspace,
         releaseEntry,
         newTag,
         newVersion: bump.newVersion,
-        isPropagationOnly,
-        isEmptyRange,
+        history: directResult?.history,
         config,
         today,
         modifiedFiles,
@@ -277,7 +246,7 @@ function executeWorkspaceRelease(args) {
     const released = {
         name: dir,
         status: 'released',
-        commitCount: directResult?.commits.length ?? 0,
+        commitCount: directCommits?.length ?? 0,
         currentVersion: bump.currentVersion,
         newVersion: bump.newVersion,
         tag: newTag,
@@ -286,7 +255,7 @@ function executeWorkspaceRelease(args) {
         ...(previewFiles.length > 0 && { previewFiles }),
     };
     attachReleasedWorkspaceOptionals(released, {
-        previousTag: directResult?.tag ?? previousTags.get(dir),
+        previousTag: directResult?.history.previousTag ?? previousTags.get(dir),
         directResult,
         releaseEntry,
         setVersionTarget,
@@ -298,20 +267,11 @@ function attachReleasedWorkspaceOptionals(released, args) {
     if (previousTag !== undefined) {
         released.previousTag = previousTag;
     }
-    if (directResult?.parsedCommitCount !== undefined) {
-        released.parsedCommitCount = directResult.parsedCommitCount;
-    }
     if (setVersionTarget === undefined) {
         released.releaseType = releaseEntry.releaseType;
     }
-    if (directResult?.commits !== undefined) {
-        released.commits = directResult.commits;
-    }
-    if (directResult?.unparseableCommits !== undefined) {
-        released.unparseableCommits = directResult.unparseableCommits;
-    }
-    if (directResult?.policyViolations !== undefined) {
-        released.policyViolations = directResult.policyViolations;
+    if (directResult !== undefined) {
+        attachDirectHistory(released, directResult.history.unreleased, setVersionTarget === undefined);
     }
     if (releaseEntry.propagatedFrom !== undefined) {
         released.propagatedFrom = releaseEntry.propagatedFrom;
@@ -323,19 +283,20 @@ function attachReleasedWorkspaceOptionals(released, args) {
         released.setVersion = setVersionTarget;
     }
 }
+function attachDirectHistory(released, unreleased, hasDecidedBump) {
+    released.commits = unreleased.commits;
+    if (hasDecidedBump) {
+        released.parsedCommitCount = unreleased.parsedCommitCount;
+        if (unreleased.unparseableCommits !== undefined) {
+            released.unparseableCommits = unreleased.unparseableCommits;
+        }
+    }
+    attachChangelogDiagnostics(released, unreleased.diagnostics);
+}
 function generateWorkspaceChangelogs(args) {
-    const { workspace, releaseEntry, newTag, newVersion, isPropagationOnly, isEmptyRange, config, today, modifiedFiles, writes, warnings, previewOptions, overrideContext, sectionOrder, } = args;
-    const newEntries = buildWorkspaceEntries({
-        workspace,
-        releaseEntry,
-        newTag,
-        newVersion,
-        isPropagationOnly,
-        isEmptyRange,
-        config,
-        today,
-    });
-    const applied = applyWorkspaceOverrides(newEntries, workspace.workspacePath, overrideContext);
+    const { workspace, releaseEntry, newTag, newVersion, history, config, today, modifiedFiles, writes, warnings, previewOptions, overrideContext, sectionOrder, } = args;
+    const entries = buildWorkspaceEntries({ workspace, releaseEntry, newTag, newVersion, history, today });
+    const applied = applyWorkspaceOverrides(entries, workspace.workspacePath, overrideContext);
     const changelogFiles = [];
     let firstMergedEntries;
     for (const changelogPath of workspace.changelogPaths) {
@@ -355,15 +316,17 @@ function generateWorkspaceChangelogs(args) {
     return { changelogFiles, previewFiles: previews.map((write) => write.path) };
 }
 function buildWorkspaceEntries(args) {
-    const { workspace, releaseEntry, newTag, newVersion, isPropagationOnly, isEmptyRange, config, today } = args;
-    if (isPropagationOnly && releaseEntry.propagatedFrom !== undefined) {
+    const { workspace, releaseEntry, newTag, newVersion, history, today } = args;
+    if (history === undefined) {
+        if (releaseEntry.propagatedFrom === undefined) {
+            throw new Error(`Workspace '${workspace.dir}' has neither a direct release nor a propagation source`);
+        }
         return [buildSyntheticChangelogEntry(releaseEntry.propagatedFrom, newVersion, today)];
     }
-    if (isEmptyRange) {
+    if (history.unreleased.commits.length === 0) {
         return [buildEmptyReleaseEntry(newVersion, today)];
     }
-    const tagPattern = buildTagPattern(getAllTagPrefixes(workspace));
-    return buildChangelogEntries(config, newTag, { tagPattern, includePaths: workspace.paths });
+    return toChangelogEntries(history, newTag);
 }
 function planPreviews(workspace, newTag, entries, previewOptions, warnings) {
     if (!previewOptions.enabled || entries === undefined) {

package/dist/esm/releasePrepareProject.d.ts

@@ -40,7 +40,7 @@ export interface ReleasePrepareProjectArgs {
 /**
  * Run the project-level release stage.
  *
- * Mirrors the per-workspace pipeline shape — find baseline tag → derive bump → bump version →
+ * Mirrors the per-workspace pipeline shape — read the history → decide the bump → bump version →
  * regenerate CHANGELOG → optionally emit changelog.json and release-notes previews — but
  * targets the root `package.json` and the root `CHANGELOG.md`. Contributing paths come from
  * the resolved `project.paths`, which defaults to the union of every (already-filtered)

package/dist/esm/releasePrepareProject.js

@@ -1,13 +1,11 @@
 import { join as joinPath } from 'node:path';
-import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
+import { readReleaseHistory, toChangelogEntries } from "./buildChangelogEntries.js";
 import { buildEmptyReleaseEntry } from "./buildEmptyReleaseEntry.js";
 import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
 import { applyChangelogOverrides } from "./changelogOverrides.js";
-import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { decideRelease } from "./decideRelease.js";
-import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
-import { buildTagPattern } from "./generateChangelogs.js";
-import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { DEFAULT_WORK_TYPES } from "./defaults.js";
 import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
 import { planVersionBump } from "./planVersionBump.js";
 import { renderChangelogMarkdown } from "./renderChangelogMarkdown.js";
@@ -23,54 +21,43 @@ export function releasePrepareProject(args) {
         throw new Error('releasePrepareProject called without a configured project block');
     }
     const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
-    const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-    const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
-    const contributingPaths = project.paths;
-    const { tag, commits } = getCommitsSinceTarget([project.tagPrefix], contributingPaths);
+    const history = readReleaseHistory(config, { tagPrefixes: [project.tagPrefix], paths: project.paths });
+    const { commits, diagnostics, parsedCommitCount, unparseableCommits } = history.unreleased;
+    const tag = history.previousTag;
     const since = tag === undefined ? '(no previous release found)' : `since ${tag}`;
-    const collector = createPolicyViolationCollector();
     const decision = decideRelease({
-        commits,
+        naturalBump: history.unreleased.bump,
+        commitCount: commits.length,
         force,
         bumpOverride,
-        workTypes,
-        versionPatterns,
-        scopeAliases: config.scopeAliases,
-        breakingPolicies,
-        onPolicyViolation: collector.onPolicyViolation,
         skipReasons: {
             noCommits: `No commits ${since}. Pass --force to release at patch. Skipping.`,
             noBumpWorthy: `No bump-worthy commits ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`,
         },
     });
-    const policyViolations = collector.violations.length > 0 ? collector.violations : undefined;
     if (decision.outcome === 'skip') {
         const skipped = {
             status: 'skipped',
             commitCount: commits.length,
-            parsedCommitCount: decision.parsedCommitCount,
+            parsedCommitCount,
             skipReason: decision.skipReason,
         };
         if (tag !== undefined) {
             skipped.previousTag = tag;
         }
-        if (decision.unparseableCommits !== undefined) {
-            skipped.unparseableCommits = decision.unparseableCommits;
-        }
-        if (policyViolations !== undefined) {
-            skipped.policyViolations = policyViolations;
+        if (unparseableCommits !== undefined) {
+            skipped.unparseableCommits = unparseableCommits;
         }
+        attachChangelogDiagnostics(skipped, diagnostics);
         return skipped;
     }
-    const { releaseType, parsedCommitCount, unparseableCommits } = decision;
+    const { releaseType } = decision;
     const bump = planVersionBump([ROOT_PACKAGE_FILE], releaseType);
     writes.push(...bump.writes);
     const newTag = `${project.tagPrefix}${bump.newVersion}`;
     const changelogs = planProjectChangelogs({
         config,
-        project,
-        commits,
-        contributingPaths,
+        history,
         newTag,
         newVersion: bump.newVersion,
         rootOverrides,
@@ -114,12 +101,10 @@ export function releasePrepareProject(args) {
     if (unparseableCommits !== undefined) {
         result.unparseableCommits = unparseableCommits;
     }
-    if (policyViolations !== undefined) {
-        result.policyViolations = policyViolations;
-    }
     if (bumpOverride !== undefined) {
         result.bumpOverride = bumpOverride;
     }
+    attachChangelogDiagnostics(result, diagnostics);
     return result;
 }
 function resolveOptionalOverrideArgs(args) {
@@ -131,14 +116,11 @@ function resolveOptionalOverrideArgs(args) {
     };
 }
 function planProjectChangelogs(args) {
-    const { config, project, commits, contributingPaths, newTag, newVersion, rootOverrides, overrideWarnings, globalMatchedRootKeys, } = args;
-    const isEmptyRange = commits.length === 0;
+    const { config, history, newTag, newVersion, rootOverrides, overrideWarnings, globalMatchedRootKeys } = args;
+    const isEmptyRange = history.unreleased.commits.length === 0;
     const today = new Date().toISOString().slice(0, 10);
-    const tagPattern = buildTagPattern([project.tagPrefix]);
-    const newEntries = isEmptyRange
-        ? [buildEmptyReleaseEntry(newVersion, today)]
-        : buildChangelogEntries(config, newTag, { tagPattern, includePaths: contributingPaths });
-    const applied = applyChangelogOverrides(newEntries, rootOverrides);
+    const builtEntries = isEmptyRange ? [buildEmptyReleaseEntry(newVersion, today)] : toChangelogEntries(history, newTag);
+    const applied = applyChangelogOverrides(builtEntries, rootOverrides);
     if (applied.errors.length > 0) {
         throw new Error(`Changelog override application failed:\n  - ${applied.errors.join('\n  - ')}`);
     }