@williamthorsen/release-kit 4.8.0 → 5.0.0

package/dist/esm/reportPrepare.js

@@ -1,86 +1,58 @@
 import { bold, dim, sectionHeader } from "./format.js";
 function reportPrepare(result) {
-  const isMultiComponent = result.components.some((c) => c.name !== void 0);
-  if (isMultiComponent) {
-    return formatMultiComponent(result);
+  const isMultiWorkspace = result.workspaces.some((w) => w.name !== void 0);
+  if (isMultiWorkspace) {
+    return formatMultiWorkspace(result);
   }
-  return formatSingleComponent(result);
+  return formatSingleWorkspace(result);
 }
-function formatSingleComponent(result) {
+function formatSingleWorkspace(result) {
   const lines = [];
-  const component = result.components[0];
-  if (component === void 0) {
+  const workspace = result.workspaces[0];
+  if (workspace === void 0) {
     return "";
   }
-  const since = component.previousTag === void 0 ? "the beginning" : component.previousTag;
-  lines.push(dim(`Found ${component.commitCount} commits since ${since}`));
-  if (component.parsedCommitCount !== void 0) {
-    lines.push(dim(`  Parsed ${component.parsedCommitCount} typed commits`));
+  const since = workspace.previousTag === void 0 ? "the beginning" : workspace.previousTag;
+  lines.push(dim(`Found ${workspace.commitCount} commits since ${since}`));
+  if (workspace.parsedCommitCount !== void 0) {
+    lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
   }
-  formatUnparseableWarning(lines, component);
-  if (component.status === "skipped") {
-    lines.push(`\u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
+  formatUnparseableWarning(lines, workspace);
+  if (workspace.status === "skipped") {
+    lines.push(`\u23ED\uFE0F  ${workspace.skipReason ?? "Skipped"}`);
     return lines.join("\n");
   }
-  if (component.parsedCommitCount === void 0 && component.releaseType !== void 0) {
-    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})`);
+  if (workspace.setVersion !== void 0) {
+    lines.push(`  Using version override: ${workspace.setVersion}`);
+  } else if (workspace.parsedCommitCount === void 0 && workspace.releaseType !== void 0) {
+    lines.push(`  Using bump override: ${workspace.releaseType}`);
+  }
+  if (workspace.releaseType !== void 0) {
+    lines.push(dim(`Bumping versions (${workspace.releaseType})...`));
+  } else if (workspace.setVersion !== void 0) {
+    lines.push(dim(`Bumping versions (version override)...`));
+  }
+  if (workspace.currentVersion !== void 0 && workspace.newVersion !== void 0) {
+    if (workspace.setVersion !== void 0) {
+      lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
+    } else if (workspace.releaseType !== void 0) {
+      lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (${workspace.releaseType})`);
+    }
   }
-  formatBumpFiles(lines, component, result.dryRun);
+  formatBumpFiles(lines, workspace, result.dryRun);
   lines.push(dim("Generating changelogs..."));
-  formatChangelogFiles(lines, component, result.dryRun);
+  formatChangelogFiles(lines, workspace, result.dryRun);
   formatFormatCommand(lines, result);
   lines.push(`\u2705 Release preparation complete.`);
-  if (component.tag !== void 0) {
-    lines.push(`   \u{1F3F7}\uFE0F  ${bold(component.tag)}`);
+  if (workspace.tag !== void 0) {
+    lines.push(`   \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
   }
   return lines.join("\n");
 }
-function formatMultiComponent(result) {
+function formatMultiWorkspace(result) {
   const lines = [];
-  for (const component of result.components) {
-    if (component.name !== void 0) {
-      lines.push(`
-${sectionHeader(component.name)}`);
-    }
-    const since = component.previousTag === void 0 ? "(no previous release found)" : `since ${component.previousTag}`;
-    lines.push(dim(`  Found ${component.commitCount} commits ${since}`));
-    if (component.status === "skipped") {
-      lines.push(`  \u23ED\uFE0F  ${component.skipReason ?? "Skipped"}`);
-      continue;
-    }
-    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`));
-    }
-    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) {
-      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..."));
-    formatChangelogFiles(lines, component, result.dryRun, "  ");
-    if (component.tag !== void 0) {
-      lines.push(`  \u{1F3F7}\uFE0F  ${bold(component.tag)}`);
-    }
+  for (const workspace of result.workspaces) {
+    formatWorkspaceSection(lines, workspace, result.dryRun);
   }
   formatFormatCommand(lines, result);
   formatWarnings(lines, result);
@@ -92,12 +64,67 @@ ${sectionHeader(component.name)}`);
     }
   } else {
     lines.push(`
-\u23ED\uFE0F  No components had release-worthy changes.`);
+\u23ED\uFE0F  No workspaces had release-worthy changes.`);
   }
   return lines.join("\n");
 }
-function formatBumpFiles(lines, component, dryRun, indent = "") {
-  for (const file of component.bumpedFiles) {
+function formatWorkspaceSection(lines, workspace, dryRun) {
+  if (workspace.name !== void 0) {
+    lines.push(`
+${sectionHeader(workspace.name)}`);
+  }
+  const since = workspace.previousTag === void 0 ? "(no previous release found)" : `since ${workspace.previousTag}`;
+  lines.push(dim(`  Found ${workspace.commitCount} commits ${since}`));
+  if (workspace.status === "skipped") {
+    lines.push(`  \u23ED\uFE0F  ${workspace.skipReason ?? "Skipped"}`);
+    return;
+  }
+  const { propagatedFrom } = workspace;
+  const isPropagatedOnly = propagatedFrom !== void 0 && workspace.commitCount === 0;
+  formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly);
+  formatUnparseableWarning(lines, workspace, "  ");
+  formatBumpLabels(lines, workspace, isPropagatedOnly);
+  formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly);
+  formatBumpFiles(lines, workspace, dryRun, "  ");
+  lines.push(dim("  Generating changelogs..."));
+  formatChangelogFiles(lines, workspace, dryRun, "  ");
+  if (workspace.tag !== void 0) {
+    lines.push(`  \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
+  }
+}
+function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
+  if (isPropagatedOnly && propagatedFrom !== void 0) {
+    const depNames = propagatedFrom.map((p) => p.packageName).join(", ");
+    lines.push(dim(`  0 commits (bumped via dependency: ${depNames})`));
+  } else if (workspace.parsedCommitCount !== void 0) {
+    lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
+  }
+}
+function formatBumpLabels(lines, workspace, isPropagatedOnly) {
+  if (workspace.setVersion !== void 0) {
+    lines.push(`  Using version override: ${workspace.setVersion}`);
+  } else if (workspace.parsedCommitCount === void 0 && workspace.releaseType !== void 0 && !isPropagatedOnly) {
+    lines.push(`  Using bump override: ${workspace.releaseType}`);
+  }
+  if (workspace.releaseType !== void 0) {
+    lines.push(dim(`  Bumping versions (${workspace.releaseType})...`));
+  } else if (workspace.setVersion !== void 0) {
+    lines.push(dim(`  Bumping versions (version override)...`));
+  }
+}
+function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly) {
+  if (workspace.currentVersion === void 0 || workspace.newVersion === void 0) {
+    return;
+  }
+  if (workspace.setVersion !== void 0) {
+    lines.push(`  \u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
+  } else if (workspace.releaseType !== void 0) {
+    const suffix = isPropagatedOnly ? formatPropagationSuffix(propagatedFrom) : "";
+    lines.push(`  \u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (${workspace.releaseType}${suffix})`);
+  }
+}
+function formatBumpFiles(lines, workspace, dryRun, indent = "") {
+  for (const file of workspace.bumpedFiles) {
     if (dryRun) {
       lines.push(dim(`${indent}  [dry-run] Would bump ${file}`));
     } else {
@@ -105,8 +132,8 @@ function formatBumpFiles(lines, component, dryRun, indent = "") {
     }
   }
 }
-function formatChangelogFiles(lines, component, dryRun, indent = "") {
-  for (const file of component.changelogFiles) {
+function formatChangelogFiles(lines, workspace, dryRun, indent = "") {
+  for (const file of workspace.changelogFiles) {
     if (dryRun) {
       lines.push(dim(`${indent}  [dry-run] Would run: npx --yes git-cliff ... --output ${file}`));
     } else {
@@ -114,13 +141,13 @@ function formatChangelogFiles(lines, component, dryRun, indent = "") {
     }
   }
 }
-function formatUnparseableWarning(lines, component, indent = "") {
-  const unparseable = component.unparseableCommits;
+function formatUnparseableWarning(lines, workspace, indent = "") {
+  const unparseable = workspace.unparseableCommits;
   if (unparseable === void 0 || unparseable.length === 0) {
     return;
   }
   const count = unparseable.length;
-  const isPatchFloor = component.parsedCommitCount === 0;
+  const isPatchFloor = workspace.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) {

package/dist/esm/resolveCliffConfigPath.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { findPackageRoot } from "./findPackageRoot.js";
+import { findPackageRoot } from "@williamthorsen/nmr-core";
 function resolveCliffConfigPath(cliffConfigPath, metaUrl) {
   if (cliffConfigPath !== void 0) {
     return cliffConfigPath;

package/dist/esm/resolveCommandTags.d.ts

@@ -1,2 +1,2 @@
 import type { ResolvedTag } from './resolveReleaseTags.ts';
-export declare function resolveCommandTags(only: string[] | undefined): Promise<ResolvedTag[]>;
+export declare function resolveCommandTags(tags: string[] | undefined): Promise<ResolvedTag[]>;

package/dist/esm/resolveCommandTags.js

@@ -1,7 +1,7 @@
-import { basename } from "node:path";
+import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
-async function resolveCommandTags(only) {
+async function resolveCommandTags(tags) {
   let discoveredPaths;
   try {
     discoveredPaths = await discoverWorkspaces();
@@ -9,25 +9,29 @@ async function resolveCommandTags(only) {
     console.error(`Error discovering workspaces: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
-  if (only !== void 0 && discoveredPaths === void 0) {
-    console.error("Error: --only is only supported for monorepo configurations");
-    process.exit(1);
+  let workspaces;
+  if (discoveredPaths !== void 0) {
+    try {
+      workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+    } catch (error) {
+      console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
   }
-  const workspaceMap = discoveredPaths === void 0 ? void 0 : new Map(discoveredPaths.map((p) => [basename(p), p]));
-  let resolvedTags = resolveReleaseTags(workspaceMap);
+  let resolvedTags = resolveReleaseTags(workspaces);
   if (resolvedTags.length === 0) {
     console.error("Error: No release tags found on HEAD. Create tags with `release-kit tag` first.");
     process.exit(1);
   }
-  if (only !== void 0) {
-    const availableNames = resolvedTags.map((t) => t.dir);
-    for (const name of only) {
-      if (!availableNames.includes(name)) {
-        console.error(`Error: Unknown package "${name}" in --only. Available: ${availableNames.join(", ")}`);
+  if (tags !== void 0) {
+    const availableTagNames = resolvedTags.map((t) => t.tag);
+    for (const name of tags) {
+      if (!availableTagNames.includes(name)) {
+        console.error(`Error: Unknown tag "${name}" in --tags. Available: ${availableTagNames.join(", ")}`);
         process.exit(1);
       }
     }
-    resolvedTags = resolvedTags.filter((t) => only.includes(t.dir));
+    resolvedTags = resolvedTags.filter((t) => tags.includes(t.tag));
   }
   return resolvedTags;
 }

package/dist/esm/resolveReleaseNotesConfig.d.ts

@@ -2,5 +2,12 @@ import type { ReleaseNotesConfig } from './types.ts';
 export interface ResolvedReleaseNotesConfig {
     releaseNotes: ReleaseNotesConfig;
     changelogJsonOutputPath: string;
+    sectionOrder: string[];
 }
-export declare function resolveReleaseNotesConfig(): Promise<ResolvedReleaseNotesConfig>;
+export interface ResolveReleaseNotesConfigOptions {
+    strictLoad?: boolean;
+}
+export declare function resolveReleaseNotesConfig(options?: ResolveReleaseNotesConfigOptions): Promise<ResolvedReleaseNotesConfig>;
+export declare function deriveSectionOrder(workTypes: Record<string, {
+    header: string;
+}>): string[];

package/dist/esm/resolveReleaseNotesConfig.js

@@ -1,19 +1,24 @@
 import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_RELEASE_NOTES_CONFIG } from "./defaults.js";
-import { loadConfig } from "./loadConfig.js";
+import { loadConfig, resolveWorkTypes } from "./loadConfig.js";
 import { validateConfig } from "./validateConfig.js";
-async function resolveReleaseNotesConfig() {
+async function resolveReleaseNotesConfig(options = {}) {
+  const { strictLoad = false } = options;
   let rawConfig;
   try {
     rawConfig = await loadConfig();
   } catch (error) {
-    console.warn(
-      `Warning: failed to load config; using defaults: ${error instanceof Error ? error.message : String(error)}`
-    );
+    const message = error instanceof Error ? error.message : String(error);
+    if (strictLoad) {
+      console.error(`Error: failed to load config: ${message}`);
+      process.exit(1);
+    }
+    console.warn(`Warning: failed to load config; using defaults: ${message}`);
   }
   if (rawConfig === void 0) {
     return {
       releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG },
-      changelogJsonOutputPath: DEFAULT_CHANGELOG_JSON_CONFIG.outputPath
+      changelogJsonOutputPath: DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+      sectionOrder: deriveSectionOrder(resolveWorkTypes())
     };
   }
   const { config, errors, warnings } = validateConfig(rawConfig);
@@ -29,9 +34,14 @@ async function resolveReleaseNotesConfig() {
   }
   return {
     releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG, ...config.releaseNotes },
-    changelogJsonOutputPath: config.changelogJson?.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath
+    changelogJsonOutputPath: config.changelogJson?.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+    sectionOrder: deriveSectionOrder(resolveWorkTypes(config.workTypes))
   };
 }
+function deriveSectionOrder(workTypes) {
+  return Object.values(workTypes).map((entry) => entry.header);
+}
 export {
+  deriveSectionOrder,
   resolveReleaseNotesConfig
 };

package/dist/esm/resolveReleaseTags.d.ts

@@ -1,6 +1,7 @@
+import type { WorkspaceConfig } from './types.ts';
 export interface ResolvedTag {
     tag: string;
     dir: string;
     workspacePath: string;
 }
-export declare function resolveReleaseTags(workspaceMap?: Map<string, string>): ResolvedTag[];
+export declare function resolveReleaseTags(workspaces?: readonly WorkspaceConfig[]): ResolvedTag[];

package/dist/esm/resolveReleaseTags.js

@@ -1,12 +1,13 @@
 import { execFileSync } from "node:child_process";
 const VERSION_PATTERN = /^v\d+\.\d+\.\d+/;
-function resolveReleaseTags(workspaceMap) {
+const SEMVER_SUFFIX_PATTERN = /^\d+\.\d+\.\d+/;
+function resolveReleaseTags(workspaces) {
   const output = execFileSync("git", ["tag", "--points-at", "HEAD"], { encoding: "utf8" });
   const tags = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  if (workspaceMap === void 0) {
+  if (workspaces === void 0) {
     return resolveSinglePackageTags(tags);
   }
-  return resolveMonorepoTags(tags, workspaceMap);
+  return resolveMonorepoTags(tags, workspaces);
 }
 function resolveSinglePackageTags(tags) {
   const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
@@ -18,24 +19,28 @@ function resolveSinglePackageTags(tags) {
   }
   return matched.map((tag) => ({ tag, dir: ".", workspacePath: "." }));
 }
-function resolveMonorepoTags(tags, workspaceMap) {
+function resolveMonorepoTags(tags, workspaces) {
+  const sortedWorkspaces = [...workspaces].sort((a, b) => b.tagPrefix.length - a.tagPrefix.length);
   const resolved = [];
   for (const tag of tags) {
-    const dashV = tag.lastIndexOf("-v");
-    if (dashV === -1) {
-      continue;
+    const match = findMatchingWorkspace(tag, sortedWorkspaces);
+    if (match !== void 0) {
+      resolved.push({ tag, dir: match.dir, workspacePath: match.workspacePath });
     }
-    const dir = tag.slice(0, dashV);
-    const versionPart = tag.slice(dashV + 1);
-    if (!VERSION_PATTERN.test(versionPart)) {
+  }
+  return resolved;
+}
+function findMatchingWorkspace(tag, sortedWorkspaces) {
+  for (const workspace of sortedWorkspaces) {
+    if (!tag.startsWith(workspace.tagPrefix)) {
       continue;
     }
-    const workspacePath = workspaceMap.get(dir);
-    if (workspacePath !== void 0) {
-      resolved.push({ tag, dir, workspacePath });
+    const versionSuffix = tag.slice(workspace.tagPrefix.length);
+    if (SEMVER_SUFFIX_PATTERN.test(versionSuffix)) {
+      return workspace;
     }
   }
-  return resolved;
+  return void 0;
 }
 export {
   resolveReleaseTags

package/dist/esm/showTagPrefixesCommand.d.ts

@@ -0,0 +1 @@
+export declare function showTagPrefixesCommand(): Promise<number>;

package/dist/esm/showTagPrefixesCommand.js

@@ -0,0 +1,84 @@
+import { detectRepoType } from "./init/detectRepoType.js";
+import { previewTagPrefixes } from "./previewTagPrefixes.js";
+async function showTagPrefixesCommand() {
+  if (detectRepoType() === "single-package") {
+    process.stdout.write(renderSinglePackage());
+    return 0;
+  }
+  const preview = await previewTagPrefixes();
+  process.stdout.write(renderMonorepo(preview));
+  return computeExitCode(preview);
+}
+function renderSinglePackage() {
+  const lines = [
+    "Workspace   Derived prefix   Status",
+    ".           v                (single-package mode)",
+    ""
+  ];
+  return lines.join("\n");
+}
+function renderMonorepo(preview) {
+  const lines = ["Workspace tag prefixes:", ""];
+  for (const row of preview.workspaces) {
+    lines.push(...renderWorkspaceRow(row));
+  }
+  if (preview.collisions.length > 0) {
+    lines.push(
+      "",
+      ...preview.collisions.map(
+        (collision) => `\u26D4 tag prefix collision: '${collision.tagPrefix}' used by ${collision.workspacePaths.join(", ")}`
+      )
+    );
+  }
+  if (preview.undeclaredCandidates.length > 0) {
+    lines.push(
+      "",
+      "Undeclared tag prefixes:",
+      "",
+      ...preview.undeclaredCandidates.map(
+        (candidate) => `  '${candidate.prefix}' \u2014 ${candidate.tagCount} tags (e.g., ${candidate.exampleTags.join(", ")})`
+      ),
+      "",
+      "Suggested config snippet (adjust `dir` to match your workspace if the guess is wrong, and replace the `name` placeholder with the legacy npm name):",
+      "",
+      renderSuggestedSnippet(preview.undeclaredCandidates),
+      "",
+      "If the suggested `dir` does not match your workspace, adjust before pasting. Each legacy identity requires a `name` \u2014 replace the `TODO-fill-in-legacy-npm-name` placeholder with the package's prior npm name."
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderWorkspaceRow(row) {
+  const lines = [];
+  if (row.derivedPrefix === null) {
+    lines.push(`  ${row.workspacePath} \u2014 \u26D4 derivation failed: ${row.derivationError ?? "unknown error"}`);
+    return lines;
+  }
+  const statusMarker = row.derivedTagCount > 0 ? `\u2705 ${row.derivedTagCount} tags` : "\u26A0\uFE0F no existing tags";
+  lines.push(`  ${row.workspacePath} \u2014 derived prefix '${row.derivedPrefix}', ${statusMarker}`);
+  for (const entry of row.legacyEntries) {
+    if (entry.tagCount > 0) {
+      lines.push(`      \u2705 ${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`);
+    } else {
+      lines.push(`      \u26A0\uFE0F recorded legacy prefix '${entry.prefix}' has no tags`);
+    }
+  }
+  return lines;
+}
+function renderSuggestedSnippet(candidates) {
+  const entries = candidates.map(
+    (candidate) => `    { dir: '${candidate.suggestedDir}', legacyIdentities: [{ name: 'TODO-fill-in-legacy-npm-name', tagPrefix: '${candidate.prefix}' }] },`
+  ).join("\n");
+  return `  workspaces: [
+${entries}
+  ],`;
+}
+function computeExitCode(preview) {
+  const hasDerivationFailure = preview.workspaces.some((row) => row.derivedPrefix === null);
+  const hasCollision = preview.collisions.length > 0;
+  return hasDerivationFailure || hasCollision ? 1 : 0;
+}
+export {
+  showTagPrefixesCommand
+};

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

@@ -1,4 +1,4 @@
-import { reportWriteResult, writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
+import { reportWriteResult, writeFileWithCheck } from "@williamthorsen/nmr-core";
 import { discoverWorkspaces } from "../discoverWorkspaces.js";
 import { generateCommand, LABELS_OUTPUT_PATH } from "./generateCommand.js";
 import { SYNC_LABELS_CONFIG_PATH } from "./loadSyncLabelsConfig.js";

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

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { findPackageRoot } from "@williamthorsen/nmr-core";
 import { load } from "js-yaml";
-import { findPackageRoot } from "../findPackageRoot.js";
 import { isRecord } from "../typeGuards.js";
 function resolvePresetPath(presetName) {
   const root = findPackageRoot(import.meta.url);

package/dist/esm/tagCommand.js

@@ -1,4 +1,4 @@
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { createTags } from "./createTags.js";
 const tagFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" },

package/dist/esm/types.d.ts

@@ -2,6 +2,7 @@ export type ReleaseType = 'major' | 'minor' | 'patch';
 export type ChangelogAudience = 'all' | 'dev';
 export interface ChangelogItem {
     description: string;
+    body?: string;
 }
 export interface ChangelogSection {
     title: string;
@@ -20,7 +21,6 @@ export interface ChangelogJsonConfig {
 }
 export interface ReleaseNotesConfig {
     shouldInjectIntoReadme: boolean;
-    shouldCreateGithubRelease: boolean;
 }
 export interface PropagationSource {
     packageName: string;
@@ -31,7 +31,7 @@ export interface BumpResult {
     newVersion: string;
     files: string[];
 }
-export interface ComponentPrepareResult {
+export interface WorkspacePrepareResult {
     name?: string | undefined;
     status: 'released' | 'skipped';
     previousTag?: string | undefined;
@@ -47,9 +47,10 @@ export interface ComponentPrepareResult {
     unparseableCommits?: Commit[] | undefined;
     propagatedFrom?: PropagationSource[] | undefined;
     skipReason?: string | undefined;
+    setVersion?: string | undefined;
 }
 export interface PrepareResult {
-    components: ComponentPrepareResult[];
+    workspaces: WorkspacePrepareResult[];
     tags: string[];
     formatCommand?: {
         command: string;
@@ -68,7 +69,7 @@ export interface VersionPatterns {
     minor: string[];
 }
 export interface ReleaseKitConfig {
-    components?: ComponentOverride[];
+    workspaces?: WorkspaceOverride[];
     versionPatterns?: VersionPatterns;
     workTypes?: Record<string, WorkTypeConfig>;
     formatCommand?: string;
@@ -76,10 +77,21 @@ export interface ReleaseKitConfig {
     scopeAliases?: Record<string, string>;
     changelogJson?: Partial<ChangelogJsonConfig>;
     releaseNotes?: Partial<ReleaseNotesConfig>;
+    retiredPackages?: RetiredPackage[];
 }
-export interface ComponentOverride {
+export interface LegacyIdentity {
+    name: string;
+    tagPrefix: string;
+}
+export interface RetiredPackage {
+    name: string;
+    tagPrefix: string;
+    successor?: string;
+}
+export interface WorkspaceOverride {
     dir: string;
     shouldExclude?: boolean;
+    legacyIdentities?: LegacyIdentity[];
 }
 export interface Commit {
     message: string;
@@ -93,15 +105,18 @@ export interface ParsedCommit {
     scope?: string;
     breaking: boolean;
 }
-export interface ComponentConfig {
+export interface WorkspaceConfig {
     dir: string;
+    name: string;
     tagPrefix: string;
+    workspacePath: string;
     packageFiles: string[];
     changelogPaths: string[];
     paths: string[];
+    legacyIdentities?: LegacyIdentity[];
 }
 export interface MonorepoReleaseConfig {
-    components: ComponentConfig[];
+    workspaces: WorkspaceConfig[];
     workTypes?: Record<string, WorkTypeConfig>;
     versionPatterns?: VersionPatterns;
     formatCommand?: string;