@williamthorsen/release-kit 2.3.1 → 4.0.0

package/dist/esm/releasePrepareMono.js

@@ -1,103 +1,295 @@
 import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
-import { determineBumpType } from "./determineBumpType.js";
-import { generateChangelog } from "./generateChangelogs.js";
+import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
+import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
-import { parseCommitMessage } from "./parseCommitMessage.js";
+import { propagateBumps } from "./propagateBumps.js";
+import { writeSyntheticChangelog } from "./writeSyntheticChangelog.js";
 function releasePrepareMono(config, options) {
-  const { dryRun, force, bumpOverride } = options;
+  const { dryRun } = options;
+  const { directBumps, directResults, skippedResults, currentVersions } = determineDirectBumps(config, options);
+  const previousTags = /* @__PURE__ */ new Map();
+  for (const result of directResults.values()) {
+    previousTags.set(result.component.dir, result.tag);
+  }
+  for (const skipped of skippedResults) {
+    previousTags.set(skipped.component.dir, skipped.tag);
+  }
+  const graph = buildDependencyGraph(config.components);
+  const fullReleaseSet = propagateBumps(directBumps, graph, currentVersions);
+  const { sorted: sortedDirs, cyclicDirs } = topologicalSort(fullReleaseSet, graph);
+  const warnings = [];
+  if (cyclicDirs.length > 0) {
+    warnings.push(
+      `Circular workspace dependencies detected among: ${cyclicDirs.join(", ")}. Propagation metadata may be incomplete for these components.`
+    );
+  }
+  const components = collectSkippedComponents(skippedResults, fullReleaseSet);
+  const { tags, modifiedFiles } = executeReleaseSet(
+    sortedDirs,
+    fullReleaseSet,
+    config,
+    directResults,
+    previousTags,
+    dryRun,
+    components
+  );
+  const configOrder = new Map(config.components.map((c, i) => [c.dir, i]));
+  components.sort((a, b) => {
+    const orderA = configOrder.get(a.name ?? "") ?? 0;
+    const orderB = configOrder.get(b.name ?? "") ?? 0;
+    return orderA - orderB;
+  });
+  const formatCommand = runFormatCommand(config, tags, modifiedFiles, dryRun);
+  return {
+    components,
+    tags,
+    formatCommand,
+    dryRun,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function determineDirectBumps(config, options) {
+  const { force, bumpOverride } = options;
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-  const tags = [];
-  const modifiedFiles = [];
-  const components = [];
+  const directBumps = /* @__PURE__ */ new Map();
+  const directResults = /* @__PURE__ */ new Map();
+  const skippedResults = [];
+  const currentVersions = /* @__PURE__ */ new Map();
   for (const component of config.components) {
     const name = component.dir;
     const { tag, commits } = getCommitsSinceTarget(component.tagPrefix, component.paths);
     const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+    const primaryPackageFile = component.packageFiles[0];
+    if (primaryPackageFile !== void 0) {
+      const currentVersion = readCurrentVersion(primaryPackageFile);
+      if (currentVersion !== void 0) {
+        currentVersions.set(component.dir, currentVersion);
+      }
+    }
     if (commits.length === 0 && !force) {
-      components.push({
-        name,
-        status: "skipped",
-        previousTag: tag,
+      skippedResults.push({
+        component,
+        tag,
         commitCount: 0,
-        bumpedFiles: [],
-        changelogFiles: [],
+        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 parsedCommits = commits.map((c) => parseCommitMessage(c.message, c.hash, workTypes, config.workspaceAliases)).filter((c) => c !== void 0);
-      parsedCommitCount = parsedCommits.length;
-      releaseType = determineBumpType(parsedCommits, workTypes, versionPatterns);
+      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases);
+      parsedCommitCount = determination.parsedCommitCount;
+      unparseableCommits = determination.unparseableCommits;
+      releaseType = determination.releaseType;
     } else {
       releaseType = bumpOverride;
     }
     if (releaseType === void 0) {
-      components.push({
-        name,
-        status: "skipped",
-        previousTag: tag,
+      skippedResults.push({
+        component,
+        tag,
         commitCount: commits.length,
         parsedCommitCount,
-        bumpedFiles: [],
-        changelogFiles: [],
+        unparseableCommits,
         skipReason: `No release-worthy changes for ${name} ${since}. Skipping.`
       });
       continue;
     }
-    const bump = bumpAllVersions(component.packageFiles, releaseType, dryRun);
+    directBumps.set(component.dir, { releaseType });
+    directResults.set(component.dir, {
+      component,
+      tag,
+      commits,
+      releaseType,
+      parsedCommitCount,
+      unparseableCommits
+    });
+  }
+  return { directBumps, directResults, skippedResults, currentVersions };
+}
+function collectSkippedComponents(skippedResults, fullReleaseSet) {
+  const components = [];
+  for (const skipped of skippedResults) {
+    if (fullReleaseSet.has(skipped.component.dir)) {
+      continue;
+    }
+    components.push({
+      name: skipped.component.dir,
+      status: "skipped",
+      previousTag: skipped.tag,
+      commitCount: skipped.commitCount,
+      parsedCommitCount: skipped.parsedCommitCount,
+      unparseableCommits: skipped.unparseableCommits,
+      bumpedFiles: [],
+      changelogFiles: [],
+      skipReason: skipped.skipReason
+    });
+  }
+  return components;
+}
+function executeReleaseSet(sortedDirs, fullReleaseSet, config, directResults, previousTags, dryRun, components) {
+  const tags = [];
+  const modifiedFiles = [];
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  for (const dir of sortedDirs) {
+    const releaseEntry = fullReleaseSet.get(dir);
+    if (releaseEntry === void 0) {
+      continue;
+    }
+    const component = findComponent(config.components, dir);
+    if (component === void 0) {
+      continue;
+    }
+    const bump = bumpAllVersions(component.packageFiles, releaseEntry.releaseType, dryRun);
     const newTag = `${component.tagPrefix}${bump.newVersion}`;
     tags.push(newTag);
     modifiedFiles.push(...component.packageFiles, ...component.changelogPaths.map((p) => `${p}/CHANGELOG.md`));
     const changelogFiles = [];
-    for (const changelogPath of component.changelogPaths) {
-      changelogFiles.push(
-        ...generateChangelog(config, changelogPath, newTag, dryRun, { includePaths: component.paths })
-      );
+    const directResult = directResults.get(dir);
+    const isPropagationOnly = directResult === void 0;
+    if (isPropagationOnly && releaseEntry.propagatedFrom !== void 0) {
+      for (const changelogPath of component.changelogPaths) {
+        changelogFiles.push(
+          writeSyntheticChangelog({
+            changelogPath,
+            newVersion: bump.newVersion,
+            date: today,
+            propagatedFrom: releaseEntry.propagatedFrom,
+            dryRun
+          })
+        );
+      }
+    } else {
+      for (const changelogPath of component.changelogPaths) {
+        changelogFiles.push(
+          ...generateChangelog(config, changelogPath, newTag, dryRun, {
+            tagPattern: buildTagPattern(component.tagPrefix),
+            includePaths: component.paths
+          })
+        );
+      }
     }
     components.push({
-      name,
+      name: dir,
       status: "released",
-      previousTag: tag,
-      commitCount: commits.length,
-      parsedCommitCount,
-      releaseType,
+      previousTag: directResult?.tag ?? previousTags.get(dir),
+      commitCount: directResult?.commits.length ?? 0,
+      parsedCommitCount: directResult?.parsedCommitCount,
+      releaseType: releaseEntry.releaseType,
       currentVersion: bump.currentVersion,
       newVersion: bump.newVersion,
       tag: newTag,
       bumpedFiles: bump.files,
-      changelogFiles
+      changelogFiles,
+      commits: directResult?.commits,
+      unparseableCommits: directResult?.unparseableCommits,
+      propagatedFrom: releaseEntry.propagatedFrom
     });
   }
+  return { tags, modifiedFiles };
+}
+function runFormatCommand(config, tags, modifiedFiles, dryRun) {
   const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
-  let formatCommand;
-  if (tags.length > 0 && formatCommandStr !== void 0) {
-    const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
-    if (dryRun) {
-      formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };
-    } else {
-      try {
-        execSync(fullCommand, { stdio: "inherit" });
-      } catch (error) {
-        throw new Error(
-          `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
-        );
+  if (tags.length === 0 || formatCommandStr === void 0) {
+    return void 0;
+  }
+  const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
+  if (dryRun) {
+    return { command: fullCommand, executed: false, files: modifiedFiles };
+  }
+  try {
+    execSync(fullCommand, { stdio: "inherit" });
+  } catch (error) {
+    throw new Error(
+      `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return { command: fullCommand, executed: true, files: modifiedFiles };
+}
+function findComponent(components, dir) {
+  return components.find((c) => c.dir === dir);
+}
+function hasVersionField(value) {
+  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
+}
+function readCurrentVersion(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (hasVersionField(parsed)) {
+      return parsed.version;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function topologicalSort(releaseSet, graph) {
+  const releaseDirs = new Set(releaseSet.keys());
+  if (releaseDirs.size === 0) {
+    return { sorted: [], cyclicDirs: [] };
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const forwardEdges = /* @__PURE__ */ 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 === void 0 || !releaseDirs.has(depDir)) {
+      continue;
+    }
+    for (const dependent of dependents) {
+      if (!releaseDirs.has(dependent.dir)) {
+        continue;
       }
-      formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
+      const edges = forwardEdges.get(depDir);
+      if (edges !== void 0) {
+        edges.push(dependent.dir);
+      }
+      inDegree.set(dependent.dir, (inDegree.get(dependent.dir) ?? 0) + 1);
     }
   }
-  return {
-    components,
-    tags,
-    formatCommand,
-    dryRun
-  };
+  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 === void 0) {
+      break;
+    }
+    sorted.push(dir);
+    for (const dependent of forwardEdges.get(dir) ?? []) {
+      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)) {
+      sorted.push(dir);
+      cyclicDirs.push(dir);
+    }
+  }
+  return { sorted, cyclicDirs };
 }
 export {
   releasePrepareMono

package/dist/esm/reportPrepare.js

@@ -17,6 +17,7 @@ function formatSingleComponent(result) {
   if (component.parsedCommitCount !== void 0) {
     lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
   }
+  formatUnparseableWarning(lines, component);
   if (component.status === "skipped") {
     lines.push(`\u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
     return lines.join("\n");
@@ -53,17 +54,26 @@ ${sectionHeader(component.name)}`);
       lines.push(`  \u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
       continue;
     }
-    if (component.parsedCommitCount !== void 0) {
+    const { propagatedFrom } = component;
+    const isPropagatedOnly = propagatedFrom !== void 0 && component.commitCount === 0;
+    if (isPropagatedOnly) {
+      const depNames = propagatedFrom.map((p) => p.packageName).join(", ");
+      lines.push(dim(`  0 commits (bumped via dependency: ${depNames})`));
+    } else if (component.parsedCommitCount !== void 0) {
       lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
     }
-    if (component.parsedCommitCount === void 0 && component.releaseType !== void 0) {
+    formatUnparseableWarning(lines, component, "  ");
+    if (component.parsedCommitCount === void 0 && component.releaseType !== void 0 && !isPropagatedOnly) {
       lines.push(`  Using bump override: ${component.releaseType}`);
     }
     if (component.releaseType !== void 0) {
       lines.push(dim(`  Bumping versions (${component.releaseType})...`));
     }
     if (component.currentVersion !== void 0 && component.newVersion !== void 0 && component.releaseType !== void 0) {
-      lines.push(`  \u{1F4E6} ${component.currentVersion} \u2192 ${bold(component.newVersion)} (${component.releaseType})`);
+      const suffix = isPropagatedOnly ? formatPropagationSuffix(propagatedFrom) : "";
+      lines.push(
+        `  \u{1F4E6} ${component.currentVersion} \u2192 ${bold(component.newVersion)} (${component.releaseType}${suffix})`
+      );
     }
     formatBumpFiles(lines, component, result.dryRun, "  ");
     lines.push(dim("  Generating changelogs..."));
@@ -73,6 +83,7 @@ ${sectionHeader(component.name)}`);
     }
   }
   formatFormatCommand(lines, result);
+  formatWarnings(lines, result);
   if (result.tags.length > 0) {
     lines.push(`
 \u2705 Release preparation complete.`);
@@ -103,6 +114,38 @@ function formatChangelogFiles(lines, component, dryRun, indent = "") {
     }
   }
 }
+function formatUnparseableWarning(lines, component, indent = "") {
+  const unparseable = component.unparseableCommits;
+  if (unparseable === void 0 || unparseable.length === 0) {
+    return;
+  }
+  const count = unparseable.length;
+  const isPatchFloor = component.parsedCommitCount === 0;
+  const suffix = isPatchFloor ? " (defaulting to patch bump)" : "";
+  lines.push(`${indent}  \u26A0\uFE0F  ${count} commit${count === 1 ? "" : "s"} could not be parsed${suffix}`);
+  for (const commit of unparseable) {
+    const shortHash = commit.hash.slice(0, 7);
+    const truncatedMessage = commit.message.length > 72 ? `${commit.message.slice(0, 69)}...` : commit.message;
+    lines.push(`${indent}    \xB7 ${shortHash} ${truncatedMessage}`);
+  }
+}
+function formatPropagationSuffix(propagatedFrom) {
+  if (propagatedFrom === void 0 || propagatedFrom.length === 0) {
+    return "";
+  }
+  const names = propagatedFrom.map((p) => p.packageName).join(", ");
+  return `, dependency: ${names}`;
+}
+function formatWarnings(lines, result) {
+  const { warnings } = result;
+  if (warnings === void 0 || warnings.length === 0) {
+    return;
+  }
+  lines.push("");
+  for (const warning of warnings) {
+    lines.push(`\u26A0\uFE0F  ${warning}`);
+  }
+}
 function formatFormatCommand(lines, result) {
   if (result.formatCommand === void 0) {
     return;

package/dist/esm/stripScope.d.ts

@@ -0,0 +1 @@
+export declare function stripScope(message: string): string;

package/dist/esm/stripScope.js

@@ -0,0 +1,24 @@
+import { COMMIT_PREPROCESSOR_PATTERNS } from "./parseCommitMessage.js";
+function stripScope(message) {
+  let ticketPrefix = "";
+  let remainder = message;
+  for (const pattern of COMMIT_PREPROCESSOR_PATTERNS) {
+    const match = remainder.match(pattern);
+    if (match) {
+      ticketPrefix += match[0];
+      remainder = remainder.slice(match[0].length);
+    }
+  }
+  const pipeMatch = remainder.match(/^[^|]+\|(.*)$/);
+  if (pipeMatch) {
+    return `${ticketPrefix}${pipeMatch[1]}`;
+  }
+  const parenMatch = remainder.match(/^(\w+)\([^)]+\)(.*)$/);
+  if (parenMatch) {
+    return `${ticketPrefix}${parenMatch[1]}${parenMatch[2]}`;
+  }
+  return message;
+}
+export {
+  stripScope
+};

package/dist/esm/sync-labels/templates.js

@@ -8,7 +8,7 @@ on:
 
 jobs:
   sync:
-    uses: williamthorsen/node-monorepo-tools/.github/workflows/sync-labels.yaml@sync-labels-v1
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/sync-labels.reusable.yaml@sync-labels-workflow-v1
 `;
 }
 function buildScopeLabels(workspacePaths) {

package/dist/esm/types.d.ts

@@ -1,4 +1,8 @@
 export type ReleaseType = 'major' | 'minor' | 'patch';
+export interface PropagationSource {
+    packageName: string;
+    newVersion: string;
+}
 export interface BumpResult {
     currentVersion: string;
     newVersion: string;
@@ -16,6 +20,9 @@ export interface ComponentPrepareResult {
     tag?: string | undefined;
     bumpedFiles: string[];
     changelogFiles: string[];
+    commits?: Commit[] | undefined;
+    unparseableCommits?: Commit[] | undefined;
+    propagatedFrom?: PropagationSource[] | undefined;
     skipReason?: string | undefined;
 }
 export interface PrepareResult {
@@ -27,6 +34,7 @@ export interface PrepareResult {
         files: string[];
     } | undefined;
     dryRun: boolean;
+    warnings?: string[] | undefined;
 }
 export interface WorkTypeConfig {
     header: string;
@@ -42,7 +50,7 @@ export interface ReleaseKitConfig {
     workTypes?: Record<string, WorkTypeConfig>;
     formatCommand?: string;
     cliffConfigPath?: string;
-    workspaceAliases?: Record<string, string>;
+    scopeAliases?: Record<string, string>;
 }
 export interface ComponentOverride {
     dir: string;
@@ -57,7 +65,7 @@ export interface ParsedCommit {
     hash: string;
     type: string;
     description: string;
-    workspace?: string;
+    scope?: string;
     breaking: boolean;
 }
 export interface ComponentConfig {
@@ -73,7 +81,7 @@ export interface MonorepoReleaseConfig {
     versionPatterns?: VersionPatterns;
     formatCommand?: string;
     cliffConfigPath?: string;
-    workspaceAliases?: Record<string, string>;
+    scopeAliases?: Record<string, string>;
 }
 export interface ReleaseConfig {
     tagPrefix: string;
@@ -83,5 +91,5 @@ export interface ReleaseConfig {
     versionPatterns?: VersionPatterns;
     formatCommand?: string;
     cliffConfigPath?: string;
-    workspaceAliases?: Record<string, string>;
+    scopeAliases?: Record<string, string>;
 }

package/dist/esm/validateConfig.js

@@ -11,7 +11,7 @@ function validateConfig(raw) {
     "workTypes",
     "formatCommand",
     "cliffConfigPath",
-    "workspaceAliases"
+    "scopeAliases"
   ]);
   for (const key of Object.keys(raw)) {
     if (!knownFields.has(key)) {
@@ -23,7 +23,7 @@ function validateConfig(raw) {
   validateWorkTypes(raw.workTypes, config, errors);
   validateStringField("formatCommand", raw.formatCommand, config, errors);
   validateStringField("cliffConfigPath", raw.cliffConfigPath, config, errors);
-  validateWorkspaceAliases(raw.workspaceAliases, config, errors);
+  validateScopeAliases(raw.scopeAliases, config, errors);
   return { config, errors };
 }
 function isStringArray(value) {
@@ -121,10 +121,10 @@ function validateStringField(fieldName, value, config, errors) {
   }
   config[fieldName] = value;
 }
-function validateWorkspaceAliases(value, config, errors) {
+function validateScopeAliases(value, config, errors) {
   if (value === void 0) return;
   if (!isRecord(value)) {
-    errors.push("'workspaceAliases' must be a record (object)");
+    errors.push("'scopeAliases' must be a record (object)");
     return;
   }
   const aliases = {};
@@ -133,12 +133,12 @@ function validateWorkspaceAliases(value, config, errors) {
     if (typeof v === "string") {
       aliases[key] = v;
     } else {
-      errors.push(`workspaceAliases.${key}: value must be a string`);
+      errors.push(`scopeAliases.${key}: value must be a string`);
       valid = false;
     }
   }
   if (valid) {
-    config.workspaceAliases = aliases;
+    config.scopeAliases = aliases;
   }
 }
 export {

package/dist/esm/writeSyntheticChangelog.d.ts

@@ -0,0 +1,9 @@
+import type { PropagationSource } from './types.ts';
+export interface WriteSyntheticChangelogParams {
+    changelogPath: string;
+    newVersion: string;
+    date: string;
+    propagatedFrom: PropagationSource[];
+    dryRun?: boolean;
+}
+export declare function writeSyntheticChangelog(params: WriteSyntheticChangelogParams): string;

package/dist/esm/writeSyntheticChangelog.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+function writeSyntheticChangelog(params) {
+  const { changelogPath, newVersion, date, propagatedFrom, dryRun } = params;
+  const filePath = `${changelogPath}/CHANGELOG.md`;
+  const bullets = propagatedFrom.map((dep) => `- Bumped \`${dep.packageName}\` to ${dep.newVersion}`).join("\n");
+  const section = `## ${newVersion} \u2014 ${date}
+
+### Dependency updates
+
+${bullets}
+`;
+  if (dryRun) {
+    return filePath;
+  }
+  let existingContent = "";
+  if (existsSync(filePath)) {
+    existingContent = readFileSync(filePath, "utf8");
+  }
+  const newContent = existingContent.length > 0 ? `${section}
+${existingContent}` : `${section}
+`;
+  writeFileSync(filePath, newContent, "utf8");
+  return filePath;
+}
+export {
+  writeSyntheticChangelog
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/release-kit",
-  "version": "2.3.1",
+  "version": "4.0.0",
   "description": "Version-bumping and changelog-generation toolkit for release workflows",
   "keywords": [],
   "homepage": "https://github.com/williamthorsen/node-monorepo-tools/tree/main/packages/release-kit#readme",