@williamthorsen/release-kit 5.0.0 → 5.1.0

package/dist/esm/releasePrepare.js

@@ -1,9 +1,10 @@
 import { execSync } from "node:child_process";
+import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.js";
+import { resolveChangelogJsonPath, upsertChangelogJson } from "./changelogJsonFile.js";
 import { isForwardVersion } from "./compareVersions.js";
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
-import { generateChangelogJson } from "./generateChangelogJson.js";
 import { generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
@@ -43,19 +44,22 @@ function releasePrepare(config, options) {
       releaseType = bumpOverride;
     }
     if (releaseType === void 0) {
+      const skipped = {
+        status: "skipped",
+        commitCount: commits.length,
+        skipReason: "No release-worthy changes found. Skipping."
+      };
+      if (tag !== void 0) {
+        skipped.previousTag = tag;
+      }
+      if (parsedCommitCount !== void 0) {
+        skipped.parsedCommitCount = parsedCommitCount;
+      }
+      if (unparseableCommits !== void 0) {
+        skipped.unparseableCommits = unparseableCommits;
+      }
       return {
-        workspaces: [
-          {
-            status: "skipped",
-            previousTag: tag,
-            commitCount: commits.length,
-            parsedCommitCount,
-            unparseableCommits,
-            bumpedFiles: [],
-            changelogFiles: [],
-            skipReason: "No release-worthy changes found. Skipping."
-          }
-        ],
+        workspaces: [skipped],
         tags: [],
         dryRun
       };
@@ -64,12 +68,7 @@ function releasePrepare(config, options) {
   }
   const newTag = `${config.tagPrefix}${bump.newVersion}`;
   const changelogFiles = generateChangelogs(config, newTag, dryRun);
-  const changelogJsonFiles = [];
-  if (config.changelogJson.enabled) {
-    for (const changelogPath of config.changelogPaths) {
-      changelogJsonFiles.push(...generateChangelogJson(config, changelogPath, newTag, dryRun));
-    }
-  }
+  const changelogJsonFiles = config.changelogJson.enabled ? buildAndPersistChangelogJson(config, newTag, dryRun) : [];
   maybeWriteSinglePackagePreviews(withReleaseNotes === true, config, newTag, changelogJsonFiles[0], dryRun);
   const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
   let formatCommand;
@@ -86,36 +85,81 @@ function releasePrepare(config, options) {
       try {
         execSync(fullCommand, { stdio: "inherit" });
       } catch (error) {
-        throw new Error(
-          `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
-        );
+        const baseMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`format stage: ${baseMessage} (command: '${fullCommand}')`, { cause: error });
       }
       formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
     }
   }
+  const released = buildReleasedSinglePackage({
+    commits,
+    bump,
+    newTag,
+    changelogFiles,
+    previousTag: tag,
+    parsedCommitCount,
+    releaseType,
+    unparseableCommits,
+    setVersion
+  });
   return {
-    workspaces: [
-      {
-        status: "released",
-        previousTag: tag,
-        commitCount: commits.length,
-        parsedCommitCount,
-        releaseType,
-        currentVersion: bump.currentVersion,
-        newVersion: bump.newVersion,
-        tag: newTag,
-        bumpedFiles: bump.files,
-        changelogFiles,
-        commits,
-        unparseableCommits,
-        ...setVersion === void 0 ? {} : { setVersion }
-      }
-    ],
+    workspaces: [released],
     tags: [newTag],
     formatCommand,
     dryRun
   };
 }
+function buildReleasedSinglePackage(args) {
+  const {
+    commits,
+    bump,
+    newTag,
+    changelogFiles,
+    previousTag,
+    parsedCommitCount,
+    releaseType,
+    unparseableCommits,
+    setVersion
+  } = args;
+  const released = {
+    status: "released",
+    commitCount: commits.length,
+    currentVersion: bump.currentVersion,
+    newVersion: bump.newVersion,
+    tag: newTag,
+    bumpedFiles: bump.files,
+    changelogFiles,
+    commits
+  };
+  if (previousTag !== void 0) {
+    released.previousTag = previousTag;
+  }
+  if (parsedCommitCount !== void 0) {
+    released.parsedCommitCount = parsedCommitCount;
+  }
+  if (releaseType !== void 0) {
+    released.releaseType = releaseType;
+  }
+  if (unparseableCommits !== void 0) {
+    released.unparseableCommits = unparseableCommits;
+  }
+  if (setVersion !== void 0) {
+    released.setVersion = setVersion;
+  }
+  return released;
+}
+function buildAndPersistChangelogJson(config, newTag, dryRun) {
+  const changelogJsonFiles = [];
+  const entries = buildChangelogEntries(config, newTag);
+  for (const changelogPath of config.changelogPaths) {
+    const jsonPath = resolveChangelogJsonPath(config, changelogPath);
+    if (!dryRun) {
+      upsertChangelogJson(jsonPath, entries);
+    }
+    changelogJsonFiles.push(jsonPath);
+  }
+  return changelogJsonFiles;
+}
 function maybeWriteSinglePackagePreviews(withReleaseNotes, config, newTag, changelogJsonPath, dryRun) {
   if (!withReleaseNotes) {
     return;

package/dist/esm/releasePrepareMono.js

@@ -1,17 +1,20 @@
 import { execSync } from "node:child_process";
+import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { buildDependencyGraph } from "./buildDependencyGraph.js";
+import { buildSyntheticChangelogEntry } from "./buildSyntheticChangelogEntry.js";
 import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.js";
+import { resolveChangelogJsonPath, upsertChangelogJson } from "./changelogJsonFile.js";
 import { isForwardVersion } from "./compareVersions.js";
+import { decideRelease } from "./decideRelease.js";
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
-import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
-import { generateChangelogJson, generateSyntheticChangelogJson } from "./generateChangelogJson.js";
 import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
 import { resolveWorkTypes } from "./loadConfig.js";
 import { propagateBumps } from "./propagateBumps.js";
 import { readCurrentVersion } from "./readCurrentVersion.js";
+import { releasePrepareProject } from "./releasePrepareProject.js";
 import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
 import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
 import { writeSyntheticChangelog } from "./writeSyntheticChangelog.js";
@@ -59,13 +62,18 @@ function releasePrepareMono(config, options) {
     const orderB = configOrder.get(b.name ?? "") ?? 0;
     return orderA - orderB;
   });
+  let project;
+  if (config.project !== void 0) {
+    project = tryStage("project release stage", () => releasePrepareProject({ config, options, modifiedFiles, tags }));
+  }
   const formatCommand = runFormatCommand(config, tags, modifiedFiles, dryRun);
   return {
     workspaces,
     tags,
     formatCommand,
     dryRun,
-    ...warnings.length > 0 ? { warnings } : {}
+    ...warnings.length > 0 ? { warnings } : {},
+    ...project === void 0 ? {} : { project }
   };
 }
 function determineDirectBumps(config, options) {
@@ -83,14 +91,18 @@ function determineDirectBumps(config, options) {
   const knownPrefixes = config.workspaces.flatMap(getAllTagPrefixes);
   for (const workspace of config.workspaces) {
     const name = workspace.dir;
-    const { tag, commits } = getCommitsSinceTarget(getAllTagPrefixes(workspace), workspace.paths);
+    const stageLabel = workspaceStageLabel(workspace.dir);
+    const { tag, commits } = tryStage(
+      stageLabel,
+      () => getCommitsSinceTarget(getAllTagPrefixes(workspace), workspace.paths)
+    );
     const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
     if (tag === void 0) {
       maybeEmitBaselineHint(workspace, knownPrefixes, hintState);
     }
     const primaryPackageFile = workspace.packageFiles[0];
     if (primaryPackageFile !== void 0) {
-      const currentVersion = readCurrentVersion(primaryPackageFile);
+      const currentVersion = tryStage(stageLabel, () => readCurrentVersion(primaryPackageFile));
       if (currentVersion !== void 0) {
         currentVersions.set(workspace.dir, currentVersion);
       }
@@ -113,51 +125,46 @@ function determineDirectBumps(config, options) {
         releaseType: void 0,
         parsedCommitCount: void 0,
         unparseableCommits: void 0,
+        bumpOverride: void 0,
         setVersion
       });
       continue;
     }
-    if (commits.length === 0 && !force) {
-      skippedResults.push({
-        workspace,
-        tag,
-        commitCount: 0,
-        parsedCommitCount: void 0,
-        unparseableCommits: void 0,
-        skipReason: `No changes for ${name} ${since}. Skipping.`
-      });
-      continue;
-    }
-    let releaseType;
-    let parsedCommitCount;
-    let unparseableCommits;
-    if (bumpOverride === void 0) {
-      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases);
-      parsedCommitCount = determination.parsedCommitCount;
-      unparseableCommits = determination.unparseableCommits;
-      releaseType = determination.releaseType;
-    } else {
-      releaseType = bumpOverride;
-    }
-    if (releaseType === void 0) {
+    const decision = tryStage(
+      stageLabel,
+      () => decideRelease({
+        commits,
+        force,
+        bumpOverride,
+        workTypes,
+        versionPatterns,
+        scopeAliases: config.scopeAliases,
+        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,
         tag,
         commitCount: commits.length,
-        parsedCommitCount,
-        unparseableCommits,
-        skipReason: `No release-worthy changes for ${name} ${since}. Skipping.`
+        parsedCommitCount: decision.parsedCommitCount,
+        unparseableCommits: decision.unparseableCommits,
+        skipReason: decision.skipReason
       });
       continue;
     }
-    directBumps.set(workspace.dir, { releaseType });
+    directBumps.set(workspace.dir, { releaseType: decision.releaseType });
     directResults.set(workspace.dir, {
       workspace,
       tag,
       commits,
-      releaseType,
-      parsedCommitCount,
-      unparseableCommits
+      releaseType: decision.releaseType,
+      parsedCommitCount: decision.parsedCommitCount,
+      unparseableCommits: decision.unparseableCommits,
+      bumpOverride
     });
   }
   return { directBumps, directResults, skippedResults, currentVersions };
@@ -168,17 +175,22 @@ function collectSkippedWorkspaces(skippedResults, fullReleaseSet) {
     if (fullReleaseSet.has(skipped.workspace.dir)) {
       continue;
     }
-    workspaces.push({
+    const result = {
       name: skipped.workspace.dir,
       status: "skipped",
-      previousTag: skipped.tag,
       commitCount: skipped.commitCount,
-      parsedCommitCount: skipped.parsedCommitCount,
-      unparseableCommits: skipped.unparseableCommits,
-      bumpedFiles: [],
-      changelogFiles: [],
       skipReason: skipped.skipReason
-    });
+    };
+    if (skipped.tag !== void 0) {
+      result.previousTag = skipped.tag;
+    }
+    if (skipped.parsedCommitCount !== void 0) {
+      result.parsedCommitCount = skipped.parsedCommitCount;
+    }
+    if (skipped.unparseableCommits !== void 0) {
+      result.unparseableCommits = skipped.unparseableCommits;
+    }
+    workspaces.push(result);
   }
   return workspaces;
 }
@@ -195,20 +207,23 @@ function executeReleaseSet(sortedDirs, fullReleaseSet, config, directResults, pr
     if (workspace === void 0) {
       continue;
     }
-    executeWorkspaceRelease({
-      dir,
-      workspace,
-      releaseEntry,
-      directResult: directResults.get(dir),
-      previousTags,
-      config,
-      dryRun,
-      today,
-      tags,
-      modifiedFiles,
-      workspaces,
-      previewOptions
-    });
+    tryStage(
+      workspaceStageLabel(dir),
+      () => executeWorkspaceRelease({
+        dir,
+        workspace,
+        releaseEntry,
+        directResult: directResults.get(dir),
+        previousTags,
+        config,
+        dryRun,
+        today,
+        tags,
+        modifiedFiles,
+        workspaces,
+        previewOptions
+      })
+    );
   }
   return { tags, modifiedFiles };
 }
@@ -245,25 +260,42 @@ function executeWorkspaceRelease(args) {
     modifiedFiles,
     previewOptions
   });
-  workspaces.push({
+  const released = {
     name: dir,
     status: "released",
-    previousTag: directResult?.tag ?? previousTags.get(dir),
     commitCount: directResult?.commits.length ?? 0,
-    parsedCommitCount: directResult?.parsedCommitCount,
-    // For --set-version workspaces releaseType is left undefined so reporting can branch
-    // on the override case without conflating it with a bump type.
-    releaseType: setVersionTarget === void 0 ? releaseEntry.releaseType : void 0,
     currentVersion: bump.currentVersion,
     newVersion: bump.newVersion,
     tag: newTag,
     bumpedFiles: bump.files,
-    changelogFiles,
-    commits: directResult?.commits,
-    unparseableCommits: directResult?.unparseableCommits,
-    propagatedFrom: releaseEntry.propagatedFrom,
-    ...setVersionTarget === void 0 ? {} : { setVersion: setVersionTarget }
-  });
+    changelogFiles
+  };
+  const previousTag = directResult?.tag ?? previousTags.get(dir);
+  if (previousTag !== void 0) {
+    released.previousTag = previousTag;
+  }
+  if (directResult?.parsedCommitCount !== void 0) {
+    released.parsedCommitCount = directResult.parsedCommitCount;
+  }
+  if (setVersionTarget === void 0) {
+    released.releaseType = releaseEntry.releaseType;
+  }
+  if (directResult?.commits !== void 0) {
+    released.commits = directResult.commits;
+  }
+  if (directResult?.unparseableCommits !== void 0) {
+    released.unparseableCommits = directResult.unparseableCommits;
+  }
+  if (releaseEntry.propagatedFrom !== void 0) {
+    released.propagatedFrom = releaseEntry.propagatedFrom;
+  }
+  if (directResult?.bumpOverride !== void 0) {
+    released.bumpOverride = directResult.bumpOverride;
+  }
+  if (setVersionTarget !== void 0) {
+    released.setVersion = setVersionTarget;
+  }
+  workspaces.push(released);
 }
 function generateWorkspaceChangelogs(args) {
   const {
@@ -293,17 +325,14 @@ function generateWorkspaceChangelogs(args) {
       );
     }
     if (config.changelogJson.enabled) {
+      const syntheticEntry = buildSyntheticChangelogEntry(releaseEntry.propagatedFrom, newVersion, today);
       for (const changelogPath of workspace.changelogPaths) {
-        const jsonFiles = generateSyntheticChangelogJson(
-          config,
-          changelogPath,
-          newVersion,
-          today,
-          releaseEntry.propagatedFrom,
-          dryRun
-        );
-        modifiedFiles.push(...jsonFiles);
-        firstChangelogJsonPath ??= jsonFiles[0];
+        const jsonPath = resolveChangelogJsonPath(config, changelogPath);
+        if (!dryRun) {
+          upsertChangelogJson(jsonPath, [syntheticEntry]);
+        }
+        modifiedFiles.push(jsonPath);
+        firstChangelogJsonPath ??= jsonPath;
       }
     }
     maybeWritePreviews(workspace, newTag, firstChangelogJsonPath, previewOptions, dryRun);
@@ -319,13 +348,17 @@ function generateWorkspaceChangelogs(args) {
     );
   }
   if (config.changelogJson.enabled) {
+    const entries = buildChangelogEntries(config, newTag, {
+      tagPattern,
+      includePaths: workspace.paths
+    });
     for (const changelogPath of workspace.changelogPaths) {
-      const jsonFiles = generateChangelogJson(config, changelogPath, newTag, dryRun, {
-        tagPattern,
-        includePaths: workspace.paths
-      });
-      modifiedFiles.push(...jsonFiles);
-      firstChangelogJsonPath ??= jsonFiles[0];
+      const jsonPath = resolveChangelogJsonPath(config, changelogPath);
+      if (!dryRun) {
+        upsertChangelogJson(jsonPath, entries);
+      }
+      modifiedFiles.push(jsonPath);
+      firstChangelogJsonPath ??= jsonPath;
     }
   }
   maybeWritePreviews(workspace, newTag, firstChangelogJsonPath, previewOptions, dryRun);
@@ -355,15 +388,28 @@ function runFormatCommand(config, tags, modifiedFiles, dryRun) {
   try {
     execSync(fullCommand, { stdio: "inherit" });
   } catch (error) {
-    throw new Error(
-      `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
-    );
+    const baseMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`format stage: ${baseMessage} (command: '${fullCommand}')`, { cause: error });
   }
   return { command: fullCommand, executed: true, files: modifiedFiles };
 }
 function findWorkspace(workspaces, dir) {
   return workspaces.find((w) => w.dir === dir);
 }
+function wrapStageError(stageLabel, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new Error(`${stageLabel}: ${message}`, { cause: error });
+}
+function tryStage(stageLabel, fn) {
+  try {
+    return fn();
+  } catch (error) {
+    throw wrapStageError(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;

package/dist/esm/releasePrepareProject.d.ts

@@ -0,0 +1,9 @@
+import type { ReleasePrepareOptions } from './releasePrepare.ts';
+import type { MonorepoReleaseConfig, ProjectPrepareResult } from './types.ts';
+export interface ReleasePrepareProjectArgs {
+    config: MonorepoReleaseConfig;
+    options: ReleasePrepareOptions;
+    modifiedFiles: string[];
+    tags: string[];
+}
+export declare function releasePrepareProject(args: ReleasePrepareProjectArgs): ProjectPrepareResult;

package/dist/esm/releasePrepareProject.js

@@ -0,0 +1,109 @@
+import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import { bumpAllVersions } from "./bumpAllVersions.js";
+import { resolveChangelogJsonPath, writeChangelogJson } from "./changelogJsonFile.js";
+import { decideRelease } from "./decideRelease.js";
+import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
+import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
+import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
+const ROOT_PACKAGE_FILE = "./package.json";
+const ROOT_CHANGELOG_PATH = ".";
+function releasePrepareProject(args) {
+  const { config, options, modifiedFiles, tags } = args;
+  const { dryRun, bumpOverride, withReleaseNotes, force } = options;
+  const project = config.project;
+  if (project === void 0) {
+    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 contributingPaths = config.workspaces.flatMap((workspace) => workspace.paths);
+  const { tag, commits } = getCommitsSinceTarget([project.tagPrefix], contributingPaths);
+  const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+  const decision = decideRelease({
+    commits,
+    force,
+    bumpOverride,
+    workTypes,
+    versionPatterns,
+    scopeAliases: config.scopeAliases,
+    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 = {
+      status: "skipped",
+      commitCount: commits.length,
+      parsedCommitCount: decision.parsedCommitCount,
+      skipReason: decision.skipReason
+    };
+    if (tag !== void 0) {
+      skipped.previousTag = tag;
+    }
+    if (decision.unparseableCommits !== void 0) {
+      skipped.unparseableCommits = decision.unparseableCommits;
+    }
+    return skipped;
+  }
+  const { releaseType, parsedCommitCount, unparseableCommits } = decision;
+  const bump = bumpAllVersions([ROOT_PACKAGE_FILE], releaseType, dryRun);
+  const newTag = `${project.tagPrefix}${bump.newVersion}`;
+  const tagPattern = buildTagPattern([project.tagPrefix]);
+  const changelogFiles = generateChangelog(config, ROOT_CHANGELOG_PATH, newTag, dryRun, {
+    tagPattern,
+    includePaths: contributingPaths
+  });
+  const changelogJsonFiles = [];
+  if (config.changelogJson.enabled) {
+    const changelogJsonPath = resolveChangelogJsonPath(config, ROOT_CHANGELOG_PATH);
+    const entries = buildChangelogEntries(config, newTag, {
+      tagPattern,
+      includePaths: contributingPaths
+    });
+    if (!dryRun) {
+      writeChangelogJson(changelogJsonPath, entries);
+    }
+    changelogJsonFiles.push(changelogJsonPath);
+  }
+  const firstChangelogJsonPath = changelogJsonFiles[0];
+  if (withReleaseNotes === true && config.changelogJson.enabled && firstChangelogJsonPath !== void 0) {
+    const sectionOrder = deriveSectionOrder(workTypes);
+    writeReleaseNotesPreviews({
+      workspacePath: ROOT_CHANGELOG_PATH,
+      tag: newTag,
+      changelogJsonPath: firstChangelogJsonPath,
+      sectionOrder,
+      dryRun
+    });
+  }
+  tags.push(newTag);
+  modifiedFiles.push(ROOT_PACKAGE_FILE, ...changelogFiles, ...changelogJsonFiles);
+  const result = {
+    status: "released",
+    commitCount: commits.length,
+    parsedCommitCount,
+    releaseType,
+    currentVersion: bump.currentVersion,
+    newVersion: bump.newVersion,
+    tag: newTag,
+    bumpedFiles: bump.files,
+    changelogFiles,
+    commits
+  };
+  if (tag !== void 0) {
+    result.previousTag = tag;
+  }
+  if (unparseableCommits !== void 0) {
+    result.unparseableCommits = unparseableCommits;
+  }
+  if (bumpOverride !== void 0) {
+    result.bumpOverride = bumpOverride;
+  }
+  return result;
+}
+export {
+  releasePrepareProject
+};