@williamthorsen/release-kit 2.0.0 → 2.3.0

package/dist/esm/init/scaffold.js

@@ -1,63 +1,35 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { printError, printSkip, printSuccess } from "./prompt.js";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
+import { findPackageRoot } from "../findPackageRoot.js";
 import { releaseConfigScript, releaseWorkflow } from "./templates.js";
-function tryWriteFile(filePath, content) {
-  try {
-    writeFileSync(filePath, content, "utf8");
-    return true;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    printError(`Failed to write ${filePath}: ${message}`);
-    return false;
-  }
-}
-function writeIfAbsent(filePath, content, dryRun, overwrite) {
-  if (existsSync(filePath) && !overwrite) {
-    printSkip(`${filePath} (already exists)`);
-    return;
-  }
-  if (dryRun) {
-    printSuccess(`[dry-run] Would create ${filePath}`);
-    return;
-  }
-  try {
-    mkdirSync(dirname(filePath), { recursive: true });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    printError(`Failed to create directory for ${filePath}: ${message}`);
-    return;
-  }
-  if (tryWriteFile(filePath, content)) {
-    printSuccess(`Created ${filePath}`);
-  }
-}
-function copyCliffTemplate(dryRun) {
-  const thisDir = dirname(fileURLToPath(import.meta.url));
-  const templatePath = resolve(thisDir, "..", "..", "..", "cliff.toml.template");
+function copyCliffTemplate(dryRun, overwrite) {
+  const destPath = ".config/git-cliff.toml";
+  const root = findPackageRoot(import.meta.url);
+  const templatePath = resolve(root, "cliff.toml.template");
   if (!existsSync(templatePath)) {
-    printError(`Could not find cliff.toml.template at ${templatePath}`);
-    return;
+    return { filePath: destPath, outcome: "failed", error: `Could not find bundled template at ${templatePath}` };
   }
   let content;
   try {
     content = readFileSync(templatePath, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    printError(`Failed to read cliff.toml.template: ${message}`);
-    return;
+    return { filePath: destPath, outcome: "failed", error: `Failed to read template ${templatePath}: ${message}` };
   }
-  writeIfAbsent("cliff.toml", content, dryRun, false);
+  return writeFileWithCheck(destPath, content, { dryRun, overwrite });
 }
-function scaffoldFiles({ repoType, dryRun, overwrite }) {
-  const files = [
-    { path: ".config/release-kit.config.ts", content: releaseConfigScript(repoType) },
-    { path: ".github/workflows/release.yaml", content: releaseWorkflow(repoType) }
+function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
+  const results = [
+    writeFileWithCheck(".github/workflows/release.yaml", releaseWorkflow(repoType), { dryRun, overwrite })
   ];
-  for (const file of files) {
-    writeIfAbsent(file.path, file.content, dryRun, overwrite);
+  if (withConfig) {
+    results.push(
+      writeFileWithCheck(".config/release-kit.config.ts", releaseConfigScript(repoType), { dryRun, overwrite }),
+      copyCliffTemplate(dryRun, overwrite)
+    );
   }
+  return results;
 }
 export {
   copyCliffTemplate,

package/dist/esm/init/templates.js

@@ -8,8 +8,7 @@ const config: ReleaseKitConfig = {
   //   { dir: 'my-package', shouldExclude: true },
   // ],
 
-  // TODO: Uncomment and adjust if you have a format command
-  // formatCommand: 'npx prettier --write',
+  // Formatting: prettier is auto-detected. Set formatCommand to override.
 
   // Uncomment to override the default version patterns:
   // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
@@ -24,8 +23,7 @@ export default config;
   return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
 
 const config: ReleaseKitConfig = {
-  // TODO: Uncomment and adjust if you have a format command
-  // formatCommand: 'npx prettier --write',
+  // Formatting: prettier is auto-detected. Set formatCommand to override.
 
   // Uncomment to override the default version patterns:
   // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
@@ -58,6 +56,11 @@ on:
           - patch
           - minor
           - major
+      force:
+        description: 'Force a version bump even when there are no release-worthy changes'
+        required: false
+        type: boolean
+        default: false
 
 permissions:
   contents: write
@@ -69,6 +72,7 @@ jobs:
     with:
       only: \${{ inputs.only }}
       bump: \${{ inputs.bump }}
+      force: \${{ inputs.force }}
 `;
   }
   return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
@@ -86,6 +90,11 @@ on:
           - patch
           - minor
           - major
+      force:
+        description: 'Force a version bump even when there are no release-worthy changes'
+        required: false
+        type: boolean
+        default: false
 
 permissions:
   contents: write
@@ -96,6 +105,7 @@ jobs:
     uses: williamthorsen/node-monorepo-tools/.github/workflows/release-workflow.yaml@release-workflow-v1
     with:
       bump: \${{ inputs.bump }}
+      force: \${{ inputs.force }}
 `;
 }
 export {

package/dist/esm/loadConfig.js

@@ -30,12 +30,6 @@ function mergeMonorepoConfig(discoveredPaths, userConfig) {
     components = components.filter((c) => {
       const override = overrides.get(c.dir);
       return override?.shouldExclude !== true;
-    }).map((c) => {
-      const override = overrides.get(c.dir);
-      if (override?.tagPrefix !== void 0) {
-        return { ...c, tagPrefix: override.tagPrefix };
-      }
-      return c;
     });
   }
   const workTypes = userConfig?.workTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userConfig.workTypes };

package/dist/esm/prepareCommand.d.ts

@@ -1 +1,11 @@
+import type { WriteResult } from '@williamthorsen/node-monorepo-core';
+import type { ReleaseType } from './types.ts';
+export declare const RELEASE_TAGS_FILE = "tmp/.release-tags";
+export declare function parseArgs(argv: string[]): {
+    dryRun: boolean;
+    force: boolean;
+    bumpOverride: ReleaseType | undefined;
+    only: string[] | undefined;
+};
+export declare function writeReleaseTags(tags: string[], dryRun: boolean): WriteResult | undefined;
 export declare function prepareCommand(argv: string[]): Promise<void>;

package/dist/esm/prepareCommand.js

@@ -1,9 +1,72 @@
+import { writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { dim } from "./format.js";
 import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig } from "./loadConfig.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
-import { parseArgs, RELEASE_TAGS_FILE, writeReleaseTags } from "./runReleasePrepare.js";
+import { reportPrepare } from "./reportPrepare.js";
 import { validateConfig } from "./validateConfig.js";
+const RELEASE_TAGS_FILE = "tmp/.release-tags";
+const VALID_BUMP_TYPES = ["major", "minor", "patch"];
+function isReleaseType(value) {
+  return VALID_BUMP_TYPES.includes(value);
+}
+function showHelp() {
+  console.info(`
+Usage: npx @williamthorsen/release-kit prepare [options]
+
+Options:
+  --dry-run             Run without modifying any files
+  --bump=major|minor|patch  Override the bump type for all components
+  --force               Bypass the "no commits since last tag" check (monorepo only, requires --bump)
+  --only=name1,name2    Only process the named components (comma-separated, monorepo only)
+  --help                Show this help message
+`);
+}
+function parseArgs(argv) {
+  let dryRun = false;
+  let force = false;
+  let bumpOverride;
+  let only;
+  for (const arg of argv) {
+    if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg.startsWith("--bump=")) {
+      const value = arg.slice("--bump=".length);
+      if (!isReleaseType(value)) {
+        console.error(`Error: Invalid bump type "${value}". Must be one of: ${VALID_BUMP_TYPES.join(", ")}`);
+        process.exit(1);
+      }
+      bumpOverride = value;
+    } else if (arg.startsWith("--only=")) {
+      const value = arg.slice("--only=".length);
+      if (!value) {
+        console.error("Error: --only requires a comma-separated list of component names");
+        process.exit(1);
+      }
+      only = value.split(",");
+    } else if (arg === "--help" || arg === "-h") {
+      showHelp();
+      process.exit(0);
+    } else {
+      console.error(`Error: Unknown argument: ${arg}`);
+      process.exit(1);
+    }
+  }
+  if (force && bumpOverride === void 0) {
+    console.error("Error: --force requires --bump to specify the version bump type");
+    process.exit(1);
+  }
+  return { dryRun, force, bumpOverride, only };
+}
+function writeReleaseTags(tags, dryRun) {
+  if (tags.length === 0) {
+    return void 0;
+  }
+  return writeFileWithCheck(RELEASE_TAGS_FILE, tags.join("\n"), { dryRun, overwrite: true });
+}
 async function prepareCommand(argv) {
   const { dryRun, force, bumpOverride, only } = parseArgs(argv);
   const options = {
@@ -11,6 +74,9 @@ async function prepareCommand(argv) {
     force,
     ...bumpOverride === void 0 ? {} : { bumpOverride }
   };
+  if (dryRun) {
+    console.info("\n\u{1F50D} DRY RUN \u2014 no files will be modified\n");
+  }
   let rawConfig;
   try {
     rawConfig = await loadConfig();
@@ -24,7 +90,7 @@ async function prepareCommand(argv) {
     if (errors.length > 0) {
       console.error("Invalid config:");
       for (const err of errors) {
-        console.error(`  - ${err}`);
+        console.error(`  \u274C ${err}`);
       }
       process.exit(1);
     }
@@ -37,20 +103,13 @@ async function prepareCommand(argv) {
     console.error(`Error discovering workspaces: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
-  let tags = [];
   if (discoveredPaths === void 0) {
     if (only !== void 0) {
       console.error("Error: --only is only supported for monorepo configurations");
       process.exit(1);
     }
     const config = mergeSinglePackageConfig(userConfig);
-    try {
-      tags = releasePrepare(config, options);
-      writeReleaseTags(tags, dryRun);
-    } catch (error) {
-      console.error("Error preparing release:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
+    runAndReport(() => releasePrepare(config, options), dryRun);
   } else {
     const config = mergeMonorepoConfig(discoveredPaths, userConfig);
     if (only !== void 0) {
@@ -63,19 +122,36 @@ async function prepareCommand(argv) {
       }
       config.components = config.components.filter((c) => only.includes(c.dir));
     }
-    try {
-      tags = releasePrepareMono(config, options);
-      writeReleaseTags(tags, dryRun);
-    } catch (error) {
-      console.error("Error preparing release:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
+    runAndReport(() => releasePrepareMono(config, options), dryRun);
+  }
+}
+function runAndReport(execute, dryRun) {
+  let result;
+  try {
+    result = execute();
+  } catch (error) {
+    console.error("Error preparing release:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
   }
-  if (tags.length > 0) {
-    console.info(`
-Release tags file: ${RELEASE_TAGS_FILE}`);
+  process.stdout.write(reportPrepare(result) + "\n");
+  const writeResult = writeReleaseTags(result.tags, dryRun);
+  if (writeResult?.outcome === "failed") {
+    console.error(`Error writing release tags: ${writeResult.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  if (writeResult) {
+    if (dryRun) {
+      console.info(dim(`  [dry-run] Would write ${RELEASE_TAGS_FILE}: ${result.tags.join(" ")}`));
+    } else {
+      console.info(dim(`  Wrote ${RELEASE_TAGS_FILE}: ${result.tags.join(" ")}`));
+      console.info(dim(`
+   Release tags file: ${RELEASE_TAGS_FILE}`));
+    }
   }
 }
 export {
-  prepareCommand
+  RELEASE_TAGS_FILE,
+  parseArgs,
+  prepareCommand,
+  writeReleaseTags
 };

package/dist/esm/publish.d.ts

@@ -0,0 +1,7 @@
+import type { PackageManager } from './detectPackageManager.ts';
+import type { ResolvedTag } from './resolveReleaseTags.ts';
+export interface PublishOptions {
+    dryRun: boolean;
+    noGitChecks: boolean;
+}
+export declare function publish(resolvedTags: ResolvedTag[], packageManager: PackageManager, options: PublishOptions): void;

package/dist/esm/publish.js

@@ -0,0 +1,49 @@
+import { execFileSync } from "node:child_process";
+function publish(resolvedTags, packageManager, options) {
+  const { dryRun, noGitChecks } = options;
+  if (resolvedTags.length === 0) {
+    return;
+  }
+  console.info(dryRun ? "[dry-run] Would publish:" : "Publishing:");
+  for (const { tag, workspacePath } of resolvedTags) {
+    console.info(`  ${tag} (${workspacePath})`);
+  }
+  const published = [];
+  for (const { tag, workspacePath } of resolvedTags) {
+    const executable = resolveExecutable(packageManager);
+    const args = buildPublishArgs(packageManager, { dryRun, noGitChecks });
+    try {
+      console.info(`
+${dryRun ? "[dry-run] " : ""}Running: ${executable} ${args.join(" ")} (cwd: ${workspacePath})`);
+      execFileSync(executable, args, { cwd: workspacePath, stdio: "inherit" });
+      published.push(tag);
+    } catch (error) {
+      if (published.length > 0) {
+        console.warn("Packages published before failure:");
+        for (const t of published) {
+          console.warn(`  ${t}`);
+        }
+      }
+      throw error;
+    }
+  }
+}
+function resolveExecutable(packageManager) {
+  if (packageManager === "yarn-berry") {
+    return "yarn";
+  }
+  return packageManager;
+}
+function buildPublishArgs(packageManager, options) {
+  const args = packageManager === "yarn-berry" ? ["npm", "publish"] : ["publish"];
+  if (options.dryRun) {
+    args.push("--dry-run");
+  }
+  if (options.noGitChecks && packageManager === "pnpm") {
+    args.push("--no-git-checks");
+  }
+  return args;
+}
+export {
+  publish
+};

package/dist/esm/publishCommand.d.ts

@@ -0,0 +1 @@
+export declare function publishCommand(argv: string[]): Promise<void>;

package/dist/esm/publishCommand.js

@@ -0,0 +1,54 @@
+import { basename } from "node:path";
+import { detectPackageManager } from "./detectPackageManager.js";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { publish } from "./publish.js";
+import { resolveReleaseTags } from "./resolveReleaseTags.js";
+async function publishCommand(argv) {
+  const knownFlags = /* @__PURE__ */ new Set(["--dry-run", "--no-git-checks"]);
+  const unknownFlags = argv.filter((f) => !f.startsWith("--only=") && !knownFlags.has(f));
+  if (unknownFlags.length > 0) {
+    console.error(`Error: Unknown option: ${unknownFlags[0]}`);
+    process.exit(1);
+  }
+  const dryRun = argv.includes("--dry-run");
+  const noGitChecks = argv.includes("--no-git-checks");
+  const onlyArg = argv.find((f) => f.startsWith("--only="));
+  const only = onlyArg?.slice("--only=".length).split(",");
+  let discoveredPaths;
+  try {
+    discoveredPaths = await discoverWorkspaces();
+  } catch (error) {
+    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);
+  }
+  const workspaceMap = discoveredPaths === void 0 ? void 0 : new Map(discoveredPaths.map((p) => [basename(p), p]));
+  let resolvedTags = resolveReleaseTags(workspaceMap);
+  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(", ")}`);
+        process.exit(1);
+      }
+    }
+    resolvedTags = resolvedTags.filter((t) => only.includes(t.dir));
+  }
+  const packageManager = detectPackageManager();
+  try {
+    publish(resolvedTags, packageManager, { dryRun, noGitChecks });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+export {
+  publishCommand
+};

package/dist/esm/releasePrepare.d.ts

@@ -1,7 +1,7 @@
-import type { ReleaseConfig, ReleaseType } from './types.ts';
+import type { PrepareResult, ReleaseConfig, ReleaseType } from './types.ts';
 export interface ReleasePrepareOptions {
     dryRun: boolean;
     force?: boolean;
     bumpOverride?: ReleaseType;
 }
-export declare function releasePrepare(config: ReleaseConfig, options: ReleasePrepareOptions): string[];
+export declare function releasePrepare(config: ReleaseConfig, options: ReleasePrepareOptions): PrepareResult;

package/dist/esm/releasePrepare.js

@@ -4,39 +4,50 @@ import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpType } from "./determineBumpType.js";
 import { generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { hasPrettierConfig } from "./hasPrettierConfig.js";
 import { parseCommitMessage } from "./parseCommitMessage.js";
 function releasePrepare(config, options) {
   const { dryRun, bumpOverride } = options;
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
-  console.info("Finding commits since last release...");
   const { tag, commits } = getCommitsSinceTarget(config.tagPrefix);
-  console.info(`  Found ${commits.length} commits since ${tag ?? "the beginning"}`);
   let releaseType;
+  let parsedCommitCount;
   if (bumpOverride === void 0) {
     const parsedCommits = commits.map((c) => parseCommitMessage(c.message, c.hash, workTypes, config.workspaceAliases)).filter((c) => c !== void 0);
-    console.info(`  Parsed ${parsedCommits.length} typed commits`);
+    parsedCommitCount = parsedCommits.length;
     releaseType = determineBumpType(parsedCommits, workTypes, versionPatterns);
   } else {
     releaseType = bumpOverride;
-    console.info(`  Using bump override: ${releaseType}`);
   }
   if (releaseType === void 0) {
-    console.info("No release-worthy changes found. Skipping.");
-    return [];
+    return {
+      components: [
+        {
+          status: "skipped",
+          previousTag: tag,
+          commitCount: commits.length,
+          parsedCommitCount,
+          bumpedFiles: [],
+          changelogFiles: [],
+          skipReason: "No release-worthy changes found. Skipping."
+        }
+      ],
+      tags: [],
+      dryRun
+    };
   }
-  console.info(`Bumping versions (${releaseType})...`);
-  const newVersion = bumpAllVersions(config.packageFiles, releaseType, dryRun);
-  const newTag = `${config.tagPrefix}${newVersion}`;
-  console.info("Generating changelogs...");
-  generateChangelogs(config, newTag, dryRun);
-  if (config.formatCommand !== void 0) {
+  const bump = bumpAllVersions(config.packageFiles, releaseType, dryRun);
+  const newTag = `${config.tagPrefix}${bump.newVersion}`;
+  const changelogFiles = generateChangelogs(config, newTag, dryRun);
+  const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
+  let formatCommand;
+  if (formatCommandStr !== void 0) {
     const modifiedFiles = [...config.packageFiles, ...config.changelogPaths.map((p) => `${p}/CHANGELOG.md`)];
-    const fullCommand = `${config.formatCommand} ${modifiedFiles.join(" ")}`;
+    const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
     if (dryRun) {
-      console.info(`  [dry-run] Would run format command: ${fullCommand}`);
+      formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };
     } else {
-      console.info(`  Running format command: ${fullCommand}`);
       try {
         execSync(fullCommand, { stdio: "inherit" });
       } catch (error) {
@@ -44,10 +55,28 @@ function releasePrepare(config, options) {
           `Format command failed ('${fullCommand}'): ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      formatCommand = { command: fullCommand, executed: true, files: modifiedFiles };
     }
   }
-  console.info(`Release preparation complete: ${newTag}`);
-  return [newTag];
+  return {
+    components: [
+      {
+        status: "released",
+        previousTag: tag,
+        commitCount: commits.length,
+        parsedCommitCount,
+        releaseType,
+        currentVersion: bump.currentVersion,
+        newVersion: bump.newVersion,
+        tag: newTag,
+        bumpedFiles: bump.files,
+        changelogFiles
+      }
+    ],
+    tags: [newTag],
+    formatCommand,
+    dryRun
+  };
 }
 export {
   releasePrepare

package/dist/esm/releasePrepareMono.d.ts

@@ -1,3 +1,3 @@
 import type { ReleasePrepareOptions } from './releasePrepare.ts';
-import type { MonorepoReleaseConfig } from './types.ts';
-export declare function releasePrepareMono(config: MonorepoReleaseConfig, options: ReleasePrepareOptions): string[];
+import type { MonorepoReleaseConfig, PrepareResult } from './types.ts';
+export declare function releasePrepareMono(config: MonorepoReleaseConfig, options: ReleasePrepareOptions): PrepareResult;