@williamthorsen/release-kit 4.8.0 → 5.1.0

package/dist/esm/publish.js

@@ -1,8 +1,8 @@
 import { execFileSync } from "node:child_process";
 function publishPackage(resolvedTag, packageManager, options) {
-  const { dryRun, noGitChecks, provenance } = options;
+  const { dryRun, provenance } = options;
   const executable = resolveExecutable(packageManager);
-  const args = buildPublishArgs(packageManager, { dryRun, noGitChecks, provenance });
+  const args = buildPublishArgs(packageManager, { dryRun, provenance });
   console.info(
     `
 ${dryRun ? "[dry-run] " : ""}Running: ${executable} ${args.join(" ")} (cwd: ${resolvedTag.workspacePath})`
@@ -20,7 +20,7 @@ function buildPublishArgs(packageManager, options) {
   if (options.dryRun) {
     args.push("--dry-run");
   }
-  if (options.noGitChecks && packageManager === "pnpm") {
+  if (packageManager === "pnpm") {
     args.push("--no-git-checks");
   }
   if (options.provenance && packageManager !== "yarn") {

package/dist/esm/publishCommand.js

@@ -1,9 +1,10 @@
 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 { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 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 +12,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 +23,21 @@ async function publishCommand(argv) {
     process.exit(1);
   }
   const { dryRun, noGitChecks, provenance } = parsed.flags;
-  const only = parsed.flags.only?.split(",");
-  const resolvedTags = await resolveCommandTags(only);
+  if (!dryRun && !noGitChecks) {
+    try {
+      assertCleanWorkingTree();
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
+  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,12 +54,13 @@ async function publishCommand(argv) {
           originalReadme = injectReleaseNotesIntoReadme(
             readmePath,
             join(resolvedTag.workspacePath, changelogJsonOutputPath),
-            resolvedTag.tag
+            resolvedTag.tag,
+            sectionOrder
           );
         }
       }
       try {
-        publishPackage(resolvedTag, packageManager, { dryRun, noGitChecks, provenance });
+        publishPackage(resolvedTag, packageManager, { dryRun, provenance });
         published.push(resolvedTag.tag);
       } finally {
         if (readmePath !== void 0 && originalReadme !== void 0) {
@@ -68,12 +78,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,54 +1,75 @@
 import { execSync } from "node:child_process";
-import { bumpAllVersions } from "./bumpAllVersions.js";
+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";
+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) {
+      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: [skipped],
+        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 = [];
-  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;
   if (formatCommandStr !== void 0) {
@@ -64,35 +85,100 @@ 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 {
-    components: [
-      {
-        status: "released",
-        previousTag: tag,
-        commitCount: commits.length,
-        parsedCommitCount,
-        releaseType,
-        currentVersion: bump.currentVersion,
-        newVersion: bump.newVersion,
-        tag: newTag,
-        bumpedFiles: bump.files,
-        changelogFiles,
-        commits,
-        unparseableCommits
-      }
-    ],
+    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;
+  }
+  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
 };