@williamthorsen/release-kit 14.0.0 → 14.2.0

package/dist/esm/releasePrepareMono.js

@@ -1,503 +0,0 @@
-import { join as joinPath } from 'node:path';
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
-import { assertTaggedBaseline, findUntaggedBaseline } from "./assertTaggedBaseline.js";
-import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
-import { readReleaseHistory, toReleaseEntries } from "./buildChangelogEntries.js";
-import { buildDependencyGraph } from "./buildDependencyGraph.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 { decideRelease } from "./decideRelease.js";
-import { deriveDependenciesHeader, deriveSectionOrder } from "./deriveReleaseNotesConfig.js";
-import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
-import { findTransitiveDependents } from "./findTransitiveDependents.js";
-import { findUnroutedEntryScopes } from "./findUnroutedEntryScopes.js";
-import { getAllTagPrefixes } from "./generateChangelogs.js";
-import { hasPrettierConfig } from "./hasPrettierConfig.js";
-import { resolveWorkTypes } from "./loadConfig.js";
-import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
-import { planVersionBump, planVersionSet } from "./planVersionBump.js";
-import { propagateBumps } from "./propagateBumps.js";
-import { planPreservedSections } from "./readChangelogSections.js";
-import { releasePrepareProject } from "./releasePrepareProject.js";
-import { renderChangelogMarkdown } from "./renderChangelogMarkdown.js";
-export function releasePrepareMono(fullConfig, options) {
-    const { only, withReleaseNotes } = options;
-    const writes = [];
-    const warnings = [];
-    const graph = buildDependencyGraph(fullConfig.workspaces);
-    const startDirs = selectStartDirs(fullConfig.workspaces, options);
-    const plannedDirs = findTransitiveDependents(graph, startDirs);
-    const config = {
-        ...fullConfig,
-        workspaces: fullConfig.workspaces.filter((workspace) => plannedDirs.has(workspace.dir)),
-    };
-    if (withReleaseNotes === true && !config.changelogJson.enabled) {
-        warnings.push('--with-release-notes requires changelogJson.enabled; skipping preview generation');
-    }
-    const workTypes = resolveWorkTypes(config.workTypes);
-    const sectionOrder = deriveSectionOrder(workTypes);
-    const dependenciesHeader = deriveDependenciesHeader(workTypes);
-    const overrideContext = createOverrideContext(config.workspaces);
-    const { directBumps, directResults, skippedResults, untaggedBaselines } = determineDirectBumps(config, options, startDirs);
-    reportUnroutedEntryScopes([...directResults.values(), ...skippedResults], config, fullConfig.workspaces.map((workspace) => workspace.dir));
-    const skippedHistories = new Map(skippedResults.map((skipped) => [skipped.workspace.dir, skipped.history]));
-    const fullReleaseSet = propagateBumps(directBumps, graph);
-    assertTaggedBaseline([...untaggedBaselines]
-        .filter(([dir]) => directBumps.has(dir) || !fullReleaseSet.has(dir))
-        .map(([, untagged]) => untagged));
-    const { sorted: sortedDirs, cyclicDirs } = topologicalSort(fullReleaseSet, graph);
-    if (cyclicDirs.length > 0) {
-        warnings.push(`Circular workspace dependencies detected among: ${cyclicDirs.join(', ')}. ` +
-            'Propagation metadata may be incomplete for these workspaces.');
-    }
-    const workspaces = collectSkippedWorkspaces(skippedResults, fullReleaseSet);
-    const previewOptions = {
-        enabled: withReleaseNotes === true && config.changelogJson.enabled,
-        sectionOrder,
-    };
-    const { tags, modifiedFiles } = executeReleaseSet({
-        sortedDirs,
-        fullReleaseSet,
-        config,
-        directResults,
-        skippedHistories,
-        writes,
-        warnings,
-        workspaces,
-        previewOptions,
-        overrideContext,
-        sectionOrder,
-        dependenciesHeader,
-    });
-    const configOrder = new Map(config.workspaces.map((w, i) => [w.dir, i]));
-    workspaces.sort((a, b) => {
-        const orderA = configOrder.get(a.name ?? '') ?? 0;
-        const orderB = configOrder.get(b.name ?? '') ?? 0;
-        return orderA - orderB;
-    });
-    let project;
-    if (config.project !== undefined) {
-        if (only === undefined) {
-            project = tryStage('project release stage', () => releasePrepareProject({
-                config,
-                options,
-                modifiedFiles,
-                writes,
-                tags,
-                warnings,
-                rootOverrides: overrideContext.project,
-                overrideWarnings: overrideContext.overrideWarnings,
-                globalMatchedRootKeys: overrideContext.globalMatchedRootKeys,
-            }));
-        }
-        else {
-            warnings.push(`Project release skipped: --only narrows this run to ${only.join(', ')}. ` +
-                'Run `release-kit prepare` without --only to include the project release.');
-        }
-    }
-    const formatCommand = planFormatCommand(config, tags, modifiedFiles);
-    for (const overrideKey of overrideContext.project.keys()) {
-        if (!overrideContext.globalMatchedRootKeys.has(overrideKey)) {
-            overrideContext.overrideWarnings.push(formatStaleOverrideKeyWarning(overrideKey));
-        }
-    }
-    const allWarnings = [...warnings, ...overrideContext.overrideWarnings];
-    return {
-        workspaces,
-        tags,
-        writes,
-        summary: buildReleaseSummary({ workspaces, ...(project !== undefined && { project }) }),
-        formatCommand,
-        ...(allWarnings.length > 0 && { warnings: allWarnings }),
-        ...(project !== undefined && { project }),
-    };
-}
-function selectStartDirs(workspaces, options) {
-    const { only, setVersions } = options;
-    if (only === undefined) {
-        return new Set(workspaces.map((workspace) => workspace.dir));
-    }
-    return new Set([...only, ...(setVersions?.keys() ?? [])]);
-}
-function determineDirectBumps(config, options, startDirs) {
-    const { force, bumpOverride, setVersions } = options;
-    const directBumps = new Map();
-    const directResults = new Map();
-    const skippedResults = [];
-    const untaggedBaselines = new Map();
-    const hintState = { emitted: false };
-    const knownPrefixes = config.workspaces.flatMap(getAllTagPrefixes);
-    for (const workspace of config.workspaces) {
-        const name = workspace.dir;
-        const stageLabel = workspaceStageLabel(workspace.dir);
-        const tagPrefixes = getAllTagPrefixes(workspace);
-        const history = tryStage(stageLabel, () => readReleaseHistory(config, { tagPrefixes, paths: workspace.paths, workspaceDir: workspace.dir }));
-        const untagged = tryStage(stageLabel, () => findUntaggedBaseline({
-            label: `workspace '${workspace.dir}'`,
-            packageFiles: workspace.packageFiles,
-            changelogPaths: workspace.changelogPaths,
-            tagPrefixes,
-            previousTag: history.previousTag,
-        }, config));
-        if (untagged !== undefined) {
-            untaggedBaselines.set(workspace.dir, untagged);
-        }
-        const tag = history.previousTag;
-        const since = tag === undefined ? '(no previous release found)' : `since ${tag}`;
-        if (tag === undefined) {
-            maybeEmitBaselineHint(workspace, knownPrefixes, hintState);
-        }
-        const setVersion = setVersions?.get(workspace.dir);
-        if (setVersion !== undefined) {
-            directBumps.set(workspace.dir, { releaseType: 'patch', newVersionOverride: setVersion });
-            directResults.set(workspace.dir, {
-                workspace,
-                history,
-                releaseType: undefined,
-                bumpOverride: undefined,
-                setVersion,
-            });
-            continue;
-        }
-        const decision = decideRelease({
-            naturalBump: history.unreleased.bump,
-            commitCount: history.unreleased.commits.length,
-            force: force === true && startDirs.has(workspace.dir),
-            bumpOverride,
-            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.`,
-            },
-        });
-        if (decision.outcome === 'skip') {
-            skippedResults.push({ workspace, history, skipReason: decision.skipReason });
-            continue;
-        }
-        directBumps.set(workspace.dir, { releaseType: decision.releaseType });
-        directResults.set(workspace.dir, {
-            workspace,
-            history,
-            releaseType: decision.releaseType,
-            bumpOverride,
-        });
-    }
-    return { directBumps, directResults, skippedResults, untaggedBaselines };
-}
-function reportUnroutedEntryScopes(results, config, configuredWorkspaceDirs) {
-    const findings = findUnroutedEntryScopes(results.map(({ workspace, history }) => ({ dir: workspace.dir, commits: history.unreleased.commits })), configuredWorkspaceDirs, config.scopeAliases ?? {});
-    for (const { workspace, history } of results) {
-        history.unreleased.diagnostics.unroutedEntryScopes = findings.get(workspace.dir) ?? [];
-    }
-}
-function collectSkippedWorkspaces(skippedResults, fullReleaseSet) {
-    const workspaces = [];
-    for (const skipped of skippedResults) {
-        if (fullReleaseSet.has(skipped.workspace.dir)) {
-            continue;
-        }
-        const { previousTag, unreleased } = skipped.history;
-        const result = {
-            name: skipped.workspace.dir,
-            status: 'skipped',
-            commitCount: unreleased.commits.length,
-            parsedCommitCount: unreleased.parsedCommitCount,
-            skipReason: skipped.skipReason,
-        };
-        if (previousTag !== undefined) {
-            result.previousTag = previousTag;
-        }
-        if (unreleased.unparseableCommits !== undefined) {
-            result.unparseableCommits = unreleased.unparseableCommits;
-        }
-        attachChangelogDiagnostics(result, unreleased.diagnostics);
-        workspaces.push(result);
-    }
-    return workspaces;
-}
-function executeReleaseSet(args) {
-    const { sortedDirs, fullReleaseSet, config, directResults, skippedHistories, writes, warnings, workspaces, previewOptions, overrideContext, sectionOrder, dependenciesHeader, } = args;
-    const tags = [];
-    const modifiedFiles = [];
-    const today = new Date().toISOString().slice(0, 10);
-    for (const dir of sortedDirs) {
-        const releaseEntry = fullReleaseSet.get(dir);
-        if (releaseEntry === undefined) {
-            continue;
-        }
-        const workspace = findWorkspace(config.workspaces, dir);
-        if (workspace === undefined) {
-            continue;
-        }
-        tryStage(workspaceStageLabel(dir), () => executeWorkspaceRelease({
-            dir,
-            workspace,
-            releaseEntry,
-            directResult: directResults.get(dir),
-            skippedHistory: skippedHistories.get(dir),
-            config,
-            today,
-            tags,
-            modifiedFiles,
-            writes,
-            warnings,
-            workspaces,
-            previewOptions,
-            overrideContext,
-            sectionOrder,
-            dependenciesHeader,
-        }));
-    }
-    return { tags, modifiedFiles };
-}
-function executeWorkspaceRelease(args) {
-    const { dir, workspace, releaseEntry, directResult, skippedHistory, config, today, tags, modifiedFiles, writes, warnings, workspaces, previewOptions, overrideContext, sectionOrder, dependenciesHeader, } = args;
-    const setVersionTarget = directResult?.setVersion;
-    const bump = setVersionTarget === undefined
-        ? planVersionBump(workspace.packageFiles, releaseEntry.releaseType)
-        : planVersionSet(workspace.packageFiles, setVersionTarget);
-    const newTag = `${workspace.tagPrefix}${bump.newVersion}`;
-    tags.push(newTag);
-    writes.push(...bump.writes);
-    modifiedFiles.push(...workspace.packageFiles, ...workspace.changelogPaths.map((changelogPath) => joinPath(changelogPath, 'CHANGELOG.md')));
-    const phase1History = directResult?.history ?? skippedHistory;
-    const { changelogFiles, changelogPreservation, previewFiles } = generateWorkspaceChangelogs({
-        workspace,
-        releaseEntry,
-        newTag,
-        newVersion: bump.newVersion,
-        history: directResult?.history,
-        config,
-        today,
-        modifiedFiles,
-        writes,
-        warnings,
-        previewOptions,
-        overrideContext,
-        sectionOrder,
-        dependenciesHeader,
-    });
-    const released = {
-        name: dir,
-        status: 'released',
-        commitCount: phase1History?.unreleased.commits.length ?? 0,
-        currentVersion: bump.currentVersion,
-        newVersion: bump.newVersion,
-        tag: newTag,
-        bumpedFiles: bump.writes.map((write) => write.path),
-        changelogFiles,
-        ...(previewFiles.length > 0 && { previewFiles }),
-        ...(changelogPreservation.length > 0 && { changelogPreservation }),
-    };
-    attachReleasedWorkspaceOptionals(released, {
-        previousTag: phase1History?.previousTag,
-        directResult,
-        skippedHistory,
-        releaseEntry,
-        setVersionTarget,
-    });
-    workspaces.push(released);
-}
-function attachReleasedWorkspaceOptionals(released, args) {
-    const { previousTag, directResult, skippedHistory, releaseEntry, setVersionTarget } = args;
-    if (previousTag !== undefined) {
-        released.previousTag = previousTag;
-    }
-    if (setVersionTarget === undefined) {
-        released.releaseType = releaseEntry.releaseType;
-    }
-    if (directResult !== undefined) {
-        attachDirectHistory(released, directResult.history.unreleased, setVersionTarget === undefined);
-    }
-    else {
-        attachPropagatedHistory(released, skippedHistory?.unreleased);
-    }
-    if (releaseEntry.propagatedFrom !== undefined) {
-        released.propagatedFrom = releaseEntry.propagatedFrom;
-    }
-    if (directResult?.bumpOverride !== undefined) {
-        released.bumpOverride = directResult.bumpOverride;
-    }
-    if (setVersionTarget !== undefined) {
-        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 attachPropagatedHistory(released, unreleased) {
-    released.propagatedOnly = true;
-    if (unreleased === undefined) {
-        return;
-    }
-    released.commits = unreleased.commits;
-    if (unreleased.unparseableCommits !== undefined) {
-        released.unparseableCommits = unreleased.unparseableCommits;
-    }
-    attachChangelogDiagnostics(released, unreleased.diagnostics);
-}
-function generateWorkspaceChangelogs(args) {
-    const { workspace, releaseEntry, newTag, newVersion, history, config, today, modifiedFiles, writes, warnings, previewOptions, overrideContext, sectionOrder, dependenciesHeader, } = args;
-    const entries = buildWorkspaceEntries({
-        workspace,
-        releaseEntry,
-        newTag,
-        newVersion,
-        history,
-        today,
-        dependenciesHeader,
-    });
-    const applied = applyWorkspaceOverrides(entries, workspace.workspacePath, overrideContext);
-    const changelogFiles = [];
-    const changelogPreservation = [];
-    let firstMergedEntries;
-    for (const changelogPath of workspace.changelogPaths) {
-        const jsonPath = resolveChangelogJsonPath(config, changelogPath);
-        const mergedEntries = mergeChangelogEntriesWithDisk(jsonPath, applied.entries);
-        if (config.changelogJson.enabled) {
-            writes.push({ path: jsonPath, content: renderChangelogJson(mergedEntries) });
-            modifiedFiles.push(jsonPath);
-            firstMergedEntries ??= mergedEntries;
-        }
-        const changelogFile = joinPath(changelogPath, 'CHANGELOG.md');
-        const preserved = planPreservedSections(changelogFile, mergedEntries);
-        writes.push({
-            path: changelogFile,
-            content: renderChangelogMarkdown(mergedEntries, { sectionOrder, preservedSections: preserved.sections }),
-        });
-        changelogFiles.push(changelogFile);
-        if (preserved.preservation !== undefined) {
-            changelogPreservation.push(preserved.preservation);
-        }
-    }
-    const previews = planPreviews(workspace, newTag, firstMergedEntries, previewOptions, warnings);
-    writes.push(...previews);
-    return { changelogFiles, changelogPreservation, previewFiles: previews.map((write) => write.path) };
-}
-function buildWorkspaceEntries(args) {
-    const { workspace, releaseEntry, newTag, newVersion, history, today, dependenciesHeader } = 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, dependenciesHeader)];
-    }
-    return toReleaseEntries(history, newTag, today);
-}
-function planPreviews(workspace, newTag, entries, previewOptions, warnings) {
-    if (!previewOptions.enabled || entries === undefined) {
-        return [];
-    }
-    const previews = planReleaseNotesPreviews({
-        workspacePath: workspace.workspacePath,
-        tag: newTag,
-        entries,
-        sectionOrder: previewOptions.sectionOrder,
-    });
-    warnings.push(...previews.warnings);
-    return previews.writes;
-}
-function planFormatCommand(config, tags, modifiedFiles) {
-    const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
-    if (tags.length === 0 || formatCommandStr === undefined) {
-        return undefined;
-    }
-    return { command: `${formatCommandStr} ${modifiedFiles.join(' ')}`, files: modifiedFiles };
-}
-function findWorkspace(workspaces, dir) {
-    return workspaces.find((w) => w.dir === dir);
-}
-function tryStage(stageLabel, fn) {
-    try {
-        return fn();
-    }
-    catch (error) {
-        throw chainError(stageLabel, error);
-    }
-}
-function workspaceStageLabel(dir) {
-    return `workspace '${dir}' release stage`;
-}
-function maybeEmitBaselineHint(workspace, knownPrefixes, state) {
-    if (state.emitted)
-        return;
-    if ((workspace.legacyIdentities?.length ?? 0) > 0)
-        return;
-    const candidates = detectUndeclaredTagPrefixes(knownPrefixes);
-    if (candidates.length === 0)
-        return;
-    const totalTags = candidates.reduce((sum, candidate) => sum + candidate.tagCount, 0);
-    const example = candidates[0]?.exampleTags[0] ?? `${candidates[0]?.prefix ?? ''}?`;
-    process.stderr.write(`Hint: no baseline tag found for ${workspace.dir} under '${workspace.tagPrefix}', but ` +
-        `${totalTags} candidate-shaped tags exist (e.g., ${example}). ` +
-        "Run 'release-kit show-tag-prefixes' to check for undeclared legacy prefixes.\n");
-    state.emitted = true;
-}
-function topologicalSort(releaseSet, graph) {
-    const releaseDirs = new Set(releaseSet.keys());
-    if (releaseDirs.size === 0) {
-        return { sorted: [], cyclicDirs: [] };
-    }
-    const inDegree = new Map();
-    const forwardEdges = new Map();
-    for (const dir of releaseDirs) {
-        inDegree.set(dir, 0);
-        forwardEdges.set(dir, []);
-    }
-    for (const [packageName, dependents] of graph.dependentsOf) {
-        const depDir = graph.packageNameToDir.get(packageName);
-        if (depDir === undefined || !releaseDirs.has(depDir)) {
-            continue;
-        }
-        for (const dependent of dependents) {
-            if (!releaseDirs.has(dependent.dir)) {
-                continue;
-            }
-            const edges = forwardEdges.get(depDir);
-            if (edges !== undefined) {
-                edges.push(dependent.dir);
-            }
-            inDegree.set(dependent.dir, (inDegree.get(dependent.dir) ?? 0) + 1);
-        }
-    }
-    const queue = [];
-    for (const [dir, degree] of inDegree) {
-        if (degree === 0) {
-            queue.push(dir);
-        }
-    }
-    const sorted = [];
-    while (queue.length > 0) {
-        const dir = queue.shift();
-        if (dir === undefined) {
-            break;
-        }
-        sorted.push(dir);
-        const dependents = forwardEdges.get(dir) ?? [];
-        for (const dependent of dependents) {
-            const newDegree = (inDegree.get(dependent) ?? 1) - 1;
-            inDegree.set(dependent, newDegree);
-            if (newDegree === 0) {
-                queue.push(dependent);
-            }
-        }
-    }
-    const sortedSet = new Set(sorted);
-    const cyclicDirs = [];
-    for (const dir of releaseDirs) {
-        if (sortedSet.has(dir)) {
-            continue;
-        }
-        sorted.push(dir);
-        cyclicDirs.push(dir);
-    }
-    return { sorted, cyclicDirs };
-}

package/dist/esm/releasePrepareProject.d.ts

@@ -1,47 +0,0 @@
-import type { PlannedWrite } from './releasePlan.js';
-import type { ReleasePrepareOptions } from './releasePrepare.js';
-import type { ChangelogOverride, MonorepoPrepareConfig, ProjectPrepareResult } from './types.js';
-/** Inputs to the project-release stage. */
-export interface ReleasePrepareProjectArgs {
-    /** Resolved monorepo config; `config.project` must be defined when this function is called. */
-    config: MonorepoPrepareConfig;
-    options: ReleasePrepareOptions;
-    /** Mutated in-place to append project-level files (root package.json, root CHANGELOG.md, root changelog.json). */
-    modifiedFiles: string[];
-    /** Mutated in-place to append every file that this stage intends to write. */
-    writes: PlannedWrite[];
-    /** Mutated in-place to append the project tag. */
-    tags: string[];
-    /**
-     * Mutated in-place to receive the warnings that this stage raises and that are not override-specific.
-     * Defaults to a discardable sink.
-     */
-    warnings?: string[];
-    /**
-     * Root-tier editorial overrides. Defaults to an empty map. The project changelog applies only the
-     * root-tier file: Per-workspace files describe per-workspace editorial intent and are
-     * meaningless at the aggregated project tier.
-     */
-    rootOverrides?: Map<string, ChangelogOverride>;
-    /**
-     * Mutated in-place to receive override-application warnings. Stale-key warnings are not among them: Those
-     * depend on the matches of every batch, which `globalMatchedRootKeys` collects. Defaults to a discardable sink.
-     */
-    overrideWarnings?: string[];
-    /**
-     * Mutated in-place to receive every root-tier override key that this stage matches, so that stale-key
-     * warnings can cover the whole run. Defaults to a discardable sink.
-     */
-    globalMatchedRootKeys?: Set<string>;
-}
-/**
- * Runs the project-level release stage: reads the history, decides the bump, and plans the root `package.json`
- * bump, the root `CHANGELOG.md`, and optionally `changelog.json` and release-notes previews. Contributing paths
- * come from the resolved `project.paths`, which defaults to the union of every (already-filtered) workspace's
- * `paths`.
- *
- * Returns a `skipped` result when neither commits nor `--force` provide a release signal, and throws when
- * `config.project` is undefined. A run narrowed by `--only` does not reach this stage, so it doesn't
- * read any narrowing flag.
- */
-export declare function releasePrepareProject(args: ReleasePrepareProjectArgs): ProjectPrepareResult;