@williamthorsen/release-kit 4.8.0 → 5.0.0

package/dist/esm/previewTagPrefixes.d.ts

@@ -0,0 +1,30 @@
+import type { UndeclaredTagPrefix } from './detectUndeclaredTagPrefixes.ts';
+export interface TagPrefixPreviewRow {
+    workspacePath: string;
+    dir: string;
+    derivedPrefix: string | null;
+    derivationError: string | null;
+    derivedTagCount: number;
+    legacyEntries: LegacyTagPrefixEntry[];
+}
+export interface LegacyTagPrefixEntry {
+    prefix: string;
+    tagCount: number;
+}
+export interface RetiredPackagePreviewEntry {
+    name: string;
+    tagPrefix: string;
+    successor?: string;
+    tagCount: number;
+}
+export interface TagPrefixCollision {
+    tagPrefix: string;
+    workspacePaths: string[];
+}
+export interface TagPrefixPreview {
+    workspaces: TagPrefixPreviewRow[];
+    collisions: TagPrefixCollision[];
+    undeclaredCandidates: UndeclaredTagPrefix[];
+    retiredPackages: RetiredPackagePreviewEntry[];
+}
+export declare function previewTagPrefixes(): Promise<TagPrefixPreview>;

package/dist/esm/previewTagPrefixes.js

@@ -0,0 +1,120 @@
+import { execFileSync } from "node:child_process";
+import { basename } from "node:path";
+import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
+import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { loadConfig } from "./loadConfig.js";
+import { validateConfig } from "./validateConfig.js";
+async function previewTagPrefixes() {
+  const workspacePaths = await discoverWorkspaces() ?? [];
+  const userConfig = await loadUserConfig();
+  const overridesByDir = buildOverrideMap(userConfig);
+  const workspaces = [];
+  for (const workspacePath of workspacePaths) {
+    workspaces.push(buildPreviewRow(workspacePath, overridesByDir));
+  }
+  const retiredPackages = buildRetiredPreviewEntries(userConfig?.retiredPackages ?? []);
+  const collisions = detectCollisions(workspaces);
+  const knownPrefixes = collectKnownPrefixes(workspaces, retiredPackages);
+  const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes);
+  return { workspaces, collisions, undeclaredCandidates, retiredPackages };
+}
+async function loadUserConfig() {
+  let raw;
+  try {
+    raw = await loadConfig();
+  } catch {
+    return void 0;
+  }
+  if (raw === void 0) return void 0;
+  const { config, errors } = validateConfig(raw);
+  return errors.length === 0 ? config : void 0;
+}
+function buildOverrideMap(userConfig) {
+  const map = /* @__PURE__ */ new Map();
+  if (userConfig?.workspaces === void 0) return map;
+  for (const entry of userConfig.workspaces) {
+    if (entry.legacyIdentities !== void 0) {
+      map.set(entry.dir, entry.legacyIdentities);
+    }
+  }
+  return map;
+}
+function buildPreviewRow(workspacePath, overridesByDir) {
+  const dir = basename(workspacePath);
+  let derivedPrefix = null;
+  let derivationError = null;
+  try {
+    derivedPrefix = deriveWorkspaceConfig(workspacePath).tagPrefix;
+  } catch (error) {
+    derivationError = error instanceof Error ? error.message : String(error);
+  }
+  const derivedTagCount = derivedPrefix === null ? 0 : countTagsMatching(derivedPrefix);
+  const declaredIdentities = overridesByDir.get(dir) ?? [];
+  const legacyEntries = declaredIdentities.map((identity) => ({
+    prefix: identity.tagPrefix,
+    tagCount: countTagsMatching(identity.tagPrefix)
+  }));
+  return {
+    workspacePath,
+    dir,
+    derivedPrefix,
+    derivationError,
+    derivedTagCount,
+    legacyEntries
+  };
+}
+function countTagsMatching(prefix) {
+  try {
+    const output = execFileSync("git", ["tag", "--list", `${prefix}*`], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.split("\n").filter((line) => line.trim() !== "").length;
+  } catch {
+    return 0;
+  }
+}
+function detectCollisions(rows) {
+  const pathsByPrefix = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.derivedPrefix === null) continue;
+    const existing = pathsByPrefix.get(row.derivedPrefix);
+    if (existing === void 0) {
+      pathsByPrefix.set(row.derivedPrefix, [row.workspacePath]);
+    } else {
+      existing.push(row.workspacePath);
+    }
+  }
+  const collisions = [];
+  for (const [tagPrefix, workspacePaths] of pathsByPrefix) {
+    if (workspacePaths.length > 1) {
+      collisions.push({ tagPrefix, workspacePaths });
+    }
+  }
+  return collisions;
+}
+function collectKnownPrefixes(rows, retiredPackages) {
+  const known = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.derivedPrefix !== null) known.add(row.derivedPrefix);
+    for (const entry of row.legacyEntries) {
+      known.add(entry.prefix);
+    }
+  }
+  for (const retired of retiredPackages) {
+    known.add(retired.tagPrefix);
+  }
+  return [...known];
+}
+function buildRetiredPreviewEntries(retiredPackages) {
+  return retiredPackages.map((retired) => ({
+    name: retired.name,
+    tagPrefix: retired.tagPrefix,
+    tagCount: countTagsMatching(retired.tagPrefix),
+    ...retired.successor !== void 0 ? { successor: retired.successor } : {}
+  }));
+}
+export {
+  previewTagPrefixes
+};

package/dist/esm/propagateBumps.d.ts

@@ -3,6 +3,7 @@ import type { PropagationSource, ReleaseType } from './types.ts';
 export interface ReleaseEntry {
     releaseType: ReleaseType;
     propagatedFrom?: PropagationSource[];
+    newVersionOverride?: string;
 }
 export type CurrentVersions = Map<string, string>;
 export declare function propagateBumps(directBumps: Map<string, ReleaseEntry>, graph: DependencyGraph, currentVersions: CurrentVersions): Map<string, ReleaseEntry>;

package/dist/esm/propagateBumps.js

@@ -24,7 +24,7 @@ function propagateBumps(directBumps, graph, currentVersions) {
     if (currentVersion === void 0 || entry === void 0) {
       continue;
     }
-    const newVersion = bumpVersion(currentVersion, entry.releaseType);
+    const newVersion = entry.newVersionOverride ?? bumpVersion(currentVersion, entry.releaseType);
     const dependents = graph.dependentsOf.get(packageName);
     if (dependents === void 0) {
       continue;

package/dist/esm/publishCommand.js

@@ -1,9 +1,9 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
-import { createGithubReleases } from "./createGithubRelease.js";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
+import { parseRequestedTags } from "./parseRequestedTags.js";
 import { publishPackage } from "./publish.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
@@ -11,7 +11,7 @@ const publishFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" },
   noGitChecks: { long: "--no-git-checks", type: "boolean" },
   provenance: { long: "--provenance", type: "boolean" },
-  only: { long: "--only", type: "string" }
+  tags: { long: "--tags", type: "string" }
 };
 async function publishCommand(argv) {
   let parsed;
@@ -22,13 +22,13 @@ async function publishCommand(argv) {
     process.exit(1);
   }
   const { dryRun, noGitChecks, provenance } = parsed.flags;
-  const only = parsed.flags.only?.split(",");
-  const resolvedTags = await resolveCommandTags(only);
+  const requestedTags = parseRequestedTags(parsed.flags.tags);
+  const resolvedTags = await resolveCommandTags(requestedTags);
   if (resolvedTags.length === 0) {
     return;
   }
   const packageManager = detectPackageManager();
-  const { releaseNotes, changelogJsonOutputPath } = await resolveReleaseNotesConfig();
+  const { releaseNotes, changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig();
   const shouldInject = releaseNotes.shouldInjectIntoReadme;
   console.info(dryRun ? "[dry-run] Would publish:" : "Publishing:");
   for (const { tag, workspacePath } of resolvedTags) {
@@ -45,7 +45,8 @@ async function publishCommand(argv) {
           originalReadme = injectReleaseNotesIntoReadme(
             readmePath,
             join(resolvedTag.workspacePath, changelogJsonOutputPath),
-            resolvedTag.tag
+            resolvedTag.tag,
+            sectionOrder
           );
         }
       }
@@ -68,12 +69,6 @@ async function publishCommand(argv) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
-  try {
-    createGithubReleases(resolvedTags, releaseNotes, changelogJsonOutputPath, dryRun);
-  } catch (error) {
-    console.error(`Error creating GitHub Releases: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
 }
 export {
   publishCommand

package/dist/esm/pushCommand.js

@@ -1,9 +1,10 @@
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
+import { parseRequestedTags } from "./parseRequestedTags.js";
 import { pushRelease } from "./pushRelease.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
 const pushFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" },
-  only: { long: "--only", type: "string" },
+  tags: { long: "--tags", type: "string" },
   tagsOnly: { long: "--tags-only", type: "boolean" }
 };
 async function pushCommand(argv) {
@@ -15,8 +16,8 @@ async function pushCommand(argv) {
     process.exit(1);
   }
   const { dryRun, tagsOnly } = parsed.flags;
-  const only = parsed.flags.only?.split(",");
-  const resolvedTags = await resolveCommandTags(only);
+  const requestedTags = parseRequestedTags(parsed.flags.tags);
+  const resolvedTags = await resolveCommandTags(requestedTags);
   if (resolvedTags.length === 0) {
     return;
   }

package/dist/esm/readCurrentVersion.d.ts

@@ -0,0 +1 @@
+export declare function readCurrentVersion(filePath: string): string | undefined;

package/dist/esm/readCurrentVersion.js

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+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 (error) {
+    console.warn(
+      `Failed to read current version from ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return void 0;
+}
+export {
+  readCurrentVersion
+};

package/dist/esm/releasePrepare.d.ts

@@ -3,5 +3,7 @@ export interface ReleasePrepareOptions {
     dryRun: boolean;
     force?: boolean;
     bumpOverride?: ReleaseType;
+    setVersion?: string;
+    withReleaseNotes?: boolean;
 }
 export declare function releasePrepare(config: ReleaseConfig, options: ReleasePrepareOptions): PrepareResult;

package/dist/esm/releasePrepare.js

@@ -1,46 +1,67 @@
 import { execSync } from "node:child_process";
-import { bumpAllVersions } from "./bumpAllVersions.js";
+import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.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";
+import { resolveWorkTypes } from "./loadConfig.js";
+import { readCurrentVersion } from "./readCurrentVersion.js";
+import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
+import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
 function releasePrepare(config, options) {
-  const { dryRun, bumpOverride } = options;
+  const { dryRun, bumpOverride, setVersion, withReleaseNotes } = options;
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-  const { tag, commits } = getCommitsSinceTarget(config.tagPrefix);
+  const { tag, commits } = getCommitsSinceTarget([config.tagPrefix]);
   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;
+  let bump;
+  if (setVersion !== void 0) {
+    const primaryPackageFile = config.packageFiles[0];
+    if (primaryPackageFile === void 0) {
+      throw new Error("No package files specified");
+    }
+    const currentVersion = readCurrentVersion(primaryPackageFile);
+    if (currentVersion === void 0) {
+      throw new Error(`Cannot validate --set-version: failed to read current version from ${primaryPackageFile}`);
+    }
+    if (!isForwardVersion(currentVersion, setVersion)) {
+      throw new Error(`--set-version ${setVersion} is not greater than current version ${currentVersion}`);
+    }
+    bump = setAllVersions(config.packageFiles, setVersion, dryRun);
   } else {
-    releaseType = bumpOverride;
-  }
-  if (releaseType === void 0) {
-    return {
-      components: [
-        {
-          status: "skipped",
-          previousTag: tag,
-          commitCount: commits.length,
-          parsedCommitCount,
-          unparseableCommits,
-          bumpedFiles: [],
-          changelogFiles: [],
-          skipReason: "No release-worthy changes found. Skipping."
-        }
-      ],
-      tags: [],
-      dryRun
-    };
+    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) {
+      return {
+        workspaces: [
+          {
+            status: "skipped",
+            previousTag: tag,
+            commitCount: commits.length,
+            parsedCommitCount,
+            unparseableCommits,
+            bumpedFiles: [],
+            changelogFiles: [],
+            skipReason: "No release-worthy changes found. Skipping."
+          }
+        ],
+        tags: [],
+        dryRun
+      };
+    }
+    bump = bumpAllVersions(config.packageFiles, releaseType, dryRun);
   }
-  const bump = bumpAllVersions(config.packageFiles, releaseType, dryRun);
   const newTag = `${config.tagPrefix}${bump.newVersion}`;
   const changelogFiles = generateChangelogs(config, newTag, dryRun);
   const changelogJsonFiles = [];
@@ -49,6 +70,7 @@ function releasePrepare(config, options) {
       changelogJsonFiles.push(...generateChangelogJson(config, changelogPath, newTag, dryRun));
     }
   }
+  maybeWriteSinglePackagePreviews(withReleaseNotes === true, config, newTag, changelogJsonFiles[0], dryRun);
   const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
   let formatCommand;
   if (formatCommandStr !== void 0) {
@@ -72,7 +94,7 @@ function releasePrepare(config, options) {
     }
   }
   return {
-    components: [
+    workspaces: [
       {
         status: "released",
         previousTag: tag,
@@ -85,7 +107,8 @@ function releasePrepare(config, options) {
         bumpedFiles: bump.files,
         changelogFiles,
         commits,
-        unparseableCommits
+        unparseableCommits,
+        ...setVersion === void 0 ? {} : { setVersion }
       }
     ],
     tags: [newTag],
@@ -93,6 +116,25 @@ function releasePrepare(config, options) {
     dryRun
   };
 }
+function maybeWriteSinglePackagePreviews(withReleaseNotes, config, newTag, changelogJsonPath, dryRun) {
+  if (!withReleaseNotes) {
+    return;
+  }
+  if (!config.changelogJson.enabled) {
+    console.warn("Warning: --with-release-notes requires changelogJson.enabled; skipping preview generation");
+    return;
+  }
+  if (changelogJsonPath === void 0) {
+    return;
+  }
+  writeReleaseNotesPreviews({
+    workspacePath: process.cwd(),
+    tag: newTag,
+    changelogJsonPath,
+    sectionOrder: deriveSectionOrder(resolveWorkTypes(config.workTypes)),
+    dryRun
+  });
+}
 export {
   releasePrepare
 };