@williamthorsen/release-kit 0.2.3 → 1.0.0

package/dist/esm/defaults.js

@@ -1,15 +1,20 @@
-const DEFAULT_WORK_TYPES = [
-  { type: "fix", header: "Bug fixes", bump: "patch", aliases: ["bugfix"] },
-  { type: "feat", header: "Features", bump: "minor", aliases: ["feature"] },
-  { type: "internal", header: "Internal", bump: "patch" },
-  { type: "refactor", header: "Refactoring", bump: "patch" },
-  { type: "tests", header: "Tests", bump: "patch", aliases: ["test"] },
-  { type: "tooling", header: "Tooling", bump: "patch" },
-  { type: "ci", header: "CI", bump: "patch" },
-  { type: "deps", header: "Dependencies", bump: "patch", aliases: ["dep"] },
-  { type: "docs", header: "Documentation", bump: "patch", aliases: ["doc"] },
-  { type: "fmt", header: "Formatting", bump: "patch" }
-];
+const DEFAULT_WORK_TYPES = {
+  fix: { header: "Bug fixes", aliases: ["bugfix"] },
+  feat: { header: "Features", aliases: ["feature"] },
+  internal: { header: "Internal" },
+  refactor: { header: "Refactoring" },
+  tests: { header: "Tests", aliases: ["test"] },
+  tooling: { header: "Tooling" },
+  ci: { header: "CI" },
+  deps: { header: "Dependencies", aliases: ["dep"] },
+  docs: { header: "Documentation", aliases: ["doc"] },
+  fmt: { header: "Formatting" }
+};
+const DEFAULT_VERSION_PATTERNS = {
+  major: ["!"],
+  minor: ["feat", "feature"]
+};
 export {
+  DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES
 };

package/dist/esm/determineBumpType.d.ts

@@ -1,2 +1,2 @@
-import type { ParsedCommit, ReleaseType, WorkTypeConfig } from './types.ts';
-export declare function determineBumpType(commits: readonly ParsedCommit[], workTypes: readonly WorkTypeConfig[]): ReleaseType | undefined;
+import type { ParsedCommit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.ts';
+export declare function determineBumpType(commits: readonly ParsedCommit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns): ReleaseType | undefined;

package/dist/esm/determineBumpType.js

@@ -3,24 +3,25 @@ const RELEASE_PRIORITY = {
   minor: 2,
   patch: 1
 };
-function determineBumpType(commits, workTypes) {
-  const typeToBump = {};
-  for (const config of workTypes) {
-    typeToBump[config.type] = config.bump;
-  }
+function determineBumpType(commits, workTypes, versionPatterns) {
+  const knownTypes = new Set(Object.keys(workTypes));
   let highestPriority = 0;
   let result;
   for (const commit of commits) {
-    if (commit.breaking) {
+    if (commit.breaking && versionPatterns.major.includes("!")) {
       return "major";
     }
     const commitType = commit.type;
-    if (!isKeyOf(commitType, typeToBump)) {
+    if (!knownTypes.has(commitType)) {
       continue;
     }
-    const bump = typeToBump[commitType];
-    if (bump === void 0) {
-      continue;
+    let bump;
+    if (versionPatterns.major.includes(commitType)) {
+      bump = "major";
+    } else if (versionPatterns.minor.includes(commitType)) {
+      bump = "minor";
+    } else {
+      bump = "patch";
     }
     const priority = RELEASE_PRIORITY[bump];
     if (priority > highestPriority) {
@@ -30,9 +31,6 @@ function determineBumpType(commits, workTypes) {
   }
   return result;
 }
-function isKeyOf(key, obj) {
-  return Object.hasOwn(obj, key);
-}
 export {
   determineBumpType
 };

package/dist/esm/discoverWorkspaces.d.ts

@@ -0,0 +1 @@
+export declare function discoverWorkspaces(): Promise<string[] | undefined>;

package/dist/esm/discoverWorkspaces.js

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { glob } from "glob";
+import { load } from "js-yaml";
+async function discoverWorkspaces() {
+  const workspaceFile = "pnpm-workspace.yaml";
+  if (!existsSync(workspaceFile)) {
+    return void 0;
+  }
+  let content;
+  try {
+    content = readFileSync(workspaceFile, "utf8");
+  } catch (error) {
+    console.warn(`Warning: Failed to read ${workspaceFile}: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+  const parsed = load(content);
+  if (!isRecord(parsed)) {
+    return void 0;
+  }
+  const packagesField = parsed.packages;
+  if (!Array.isArray(packagesField)) {
+    return void 0;
+  }
+  const patterns = packagesField.filter((p) => typeof p === "string");
+  if (patterns.length === 0) {
+    return void 0;
+  }
+  const directories = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, { posix: true });
+    for (const match of matches) {
+      if (existsSync(join(match, "package.json"))) {
+        directories.push(match);
+      }
+    }
+  }
+  return directories.length > 0 ? [...directories].sort() : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  discoverWorkspaces
+};

package/dist/esm/getCommitsSinceTarget.js

@@ -20,6 +20,7 @@ function findLatestTag(tagPrefix) {
     throw new Error(`Failed to run 'git describe': ${errorMessage(error)}`);
   }
 }
+const RELEASE_COMMIT_PREFIX = "release:";
 function parseLogOutput(logOutput) {
   const commits = [];
   for (const line of logOutput.split("\n")) {
@@ -28,7 +29,7 @@ function parseLogOutput(logOutput) {
       continue;
     }
     const [message, hash] = trimmedLine.split(FIELD_SEPARATOR);
-    if (message !== void 0 && hash !== void 0) {
+    if (message !== void 0 && hash !== void 0 && !message.startsWith(RELEASE_COMMIT_PREFIX)) {
       commits.push({ message, hash });
     }
   }

package/dist/esm/index.d.ts

@@ -1,13 +1,15 @@
 export type { GenerateChangelogOptions } from './generateChangelogs.ts';
 export type { ReleasePrepareOptions } from './releasePrepare.ts';
-export type { Commit, ComponentConfig, MonorepoReleaseConfig, ParsedCommit, ReleaseConfig, ReleaseType, WorkTypeConfig, } from './types.ts';
-export { DEFAULT_WORK_TYPES } from './defaults.ts';
+export type { Commit, ComponentConfig, ComponentOverride, MonorepoReleaseConfig, ParsedCommit, ReleaseConfig, ReleaseKitConfig, ReleaseType, VersionPatterns, WorkTypeConfig, } from './types.ts';
+export { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from './defaults.ts';
 export { bumpAllVersions } from './bumpAllVersions.ts';
 export { bumpVersion } from './bumpVersion.ts';
+export { component } from './component.ts';
 export { determineBumpType } from './determineBumpType.ts';
+export { discoverWorkspaces } from './discoverWorkspaces.ts';
 export { generateChangelog, generateChangelogs } from './generateChangelogs.ts';
 export { getCommitsSinceTarget } from './getCommitsSinceTarget.ts';
 export { parseCommitMessage } from './parseCommitMessage.ts';
 export { releasePrepare } from './releasePrepare.ts';
 export { releasePrepareMono } from './releasePrepareMono.ts';
-export { runReleasePrepare } from './runReleasePrepare.ts';
+export { RELEASE_TAGS_FILE, runReleasePrepare, writeReleaseTags } from './runReleasePrepare.ts';

package/dist/esm/index.js

@@ -1,23 +1,30 @@
-import { DEFAULT_WORK_TYPES } from "./defaults.js";
+import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { bumpVersion } from "./bumpVersion.js";
+import { component } from "./component.js";
 import { determineBumpType } from "./determineBumpType.js";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { generateChangelog, generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { parseCommitMessage } from "./parseCommitMessage.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
-import { runReleasePrepare } from "./runReleasePrepare.js";
+import { RELEASE_TAGS_FILE, runReleasePrepare, writeReleaseTags } from "./runReleasePrepare.js";
 export {
+  DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES,
+  RELEASE_TAGS_FILE,
   bumpAllVersions,
   bumpVersion,
+  component,
   determineBumpType,
+  discoverWorkspaces,
   generateChangelog,
   generateChangelogs,
   getCommitsSinceTarget,
   parseCommitMessage,
   releasePrepare,
   releasePrepareMono,
-  runReleasePrepare
+  runReleasePrepare,
+  writeReleaseTags
 };

package/dist/esm/init/checks.js

@@ -39,12 +39,12 @@ function hasCliffToml() {
   return { ok: false, message: "No cliff.toml found. This file is required for changelog generation." };
 }
 function notAlreadyInitialized() {
-  if (!existsSync(".github/scripts/release.config.ts")) {
+  if (!existsSync(".config/release-kit.config.ts") && !existsSync(".github/scripts/release.config.ts")) {
     return { ok: true };
   }
   return {
     ok: false,
-    message: "release-kit appears to be already initialized (.github/scripts/release.config.ts exists)."
+    message: "release-kit appears to be already initialized."
   };
 }
 export {

package/dist/esm/init/initCommand.js

@@ -54,12 +54,9 @@ async function initCommand({ dryRun }) {
   scaffoldFiles({ repoType, dryRun, overwrite: eligibility.overwrite });
   printStep("Next steps");
   console.info(`
-  1. Customize .github/scripts/release.config.ts for your project
-  2. Set the correct node-version and pnpm-version in .github/workflows/release.yaml
-  3. Install required dev dependencies: pnpm add --save-dev tsx @williamthorsen/release-kit
-  4. Install git-cliff if not already installed: https://git-cliff.org/docs/installation
-  5. Create an initial version tag (e.g., git tag v0.0.0)
-  6. Test with a dry run: pnpm run release:prepare:dry
+  1. (Optional) Customize .config/release-kit.config.ts to exclude components, override version patterns, add custom work types, etc.
+  2. Test by running: npx @williamthorsen/release-kit prepare --dry-run
+  3. Commit the generated workflow file (and config file if created).
 `);
   return 0;
 }

package/dist/esm/init/scaffold.js

@@ -1,9 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseJsonRecord } from "./parseJsonRecord.js";
 import { printError, printSkip, printSuccess } from "./prompt.js";
-import { releaseConfigScript, releasePrepareScript, releaseWorkflow } from "./templates.js";
+import { releaseConfigScript, releaseWorkflow } from "./templates.js";
 function tryWriteFile(filePath, content) {
   try {
     writeFileSync(filePath, content, "utf8");
@@ -53,60 +52,12 @@ function copyCliffTemplate(dryRun) {
 }
 function scaffoldFiles({ repoType, dryRun, overwrite }) {
   const files = [
-    { path: ".github/scripts/release-prepare.ts", content: releasePrepareScript() },
-    { path: ".github/scripts/release.config.ts", content: releaseConfigScript(repoType) },
+    { path: ".config/release-kit.config.ts", content: releaseConfigScript(repoType) },
     { path: ".github/workflows/release.yaml", content: releaseWorkflow(repoType) }
   ];
   for (const file of files) {
     writeIfAbsent(file.path, file.content, dryRun, overwrite);
   }
-  updatePackageJsonScripts(dryRun);
-}
-function readPackageJson(pkgPath) {
-  let raw;
-  try {
-    raw = readFileSync(pkgPath, "utf8");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    printError(`Failed to read ${pkgPath}: ${message}`);
-    return void 0;
-  }
-  const pkg = parseJsonRecord(raw);
-  if (pkg === void 0) {
-    printError("Failed to parse package.json");
-  }
-  return pkg;
-}
-function updatePackageJsonScripts(dryRun) {
-  const pkgPath = "package.json";
-  const pkg = readPackageJson(pkgPath);
-  if (pkg === void 0) {
-    return;
-  }
-  const existingScripts = pkg.scripts;
-  const scripts = typeof existingScripts === "object" && existingScripts !== null && !Array.isArray(existingScripts) ? { ...existingScripts } : {};
-  let changed = false;
-  if (!("release:prepare" in scripts)) {
-    scripts["release:prepare"] = "tsx .github/scripts/release-prepare.ts";
-    changed = true;
-  }
-  if (!("release:prepare:dry" in scripts)) {
-    scripts["release:prepare:dry"] = "tsx .github/scripts/release-prepare.ts --dry-run";
-    changed = true;
-  }
-  if (!changed) {
-    printSuccess("package.json scripts already configured");
-    return;
-  }
-  if (dryRun) {
-    printSuccess("[dry-run] Would add release:prepare scripts to package.json");
-    return;
-  }
-  pkg.scripts = scripts;
-  if (tryWriteFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
-`)) {
-    printSuccess("Added release:prepare scripts to package.json");
-  }
 }
 export {
   copyCliffTemplate,

package/dist/esm/init/templates.d.ts

@@ -1,4 +1,3 @@
 import type { RepoType } from './detectRepoType.ts';
-export declare function releasePrepareScript(): string;
 export declare function releaseConfigScript(repoType: RepoType): string;
 export declare function releaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/templates.js

@@ -1,49 +1,35 @@
-function releasePrepareScript() {
-  return `import { runReleasePrepare } from '@williamthorsen/release-kit';
-
-import { config } from './release.config.js';
-
-runReleasePrepare(config);
-`;
-}
 function releaseConfigScript(repoType) {
   if (repoType === "monorepo") {
-    return `import type { MonorepoReleaseConfig } from '@williamthorsen/release-kit';
-import { DEFAULT_WORK_TYPES } from '@williamthorsen/release-kit';
+    return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
 
-// TODO: Replace with your actual component directories
-function component(dir: string) {
-  return {
-    tagPrefix: \`\${dir}-v\`,
-    packageFiles: [\`packages/\${dir}/package.json\`],
-    changelogPaths: [\`packages/\${dir}\`],
-    paths: [\`packages/\${dir}/**\`],
-  };
-}
-
-export const config: MonorepoReleaseConfig = {
-  components: [
-    // TODO: Add your components here
-    // component('my-package'),
-  ],
-  workTypes: [...DEFAULT_WORK_TYPES],
+const config: ReleaseKitConfig = {
+  // Uncomment to exclude components from release processing:
+  // components: [
+  //   { dir: 'my-package', shouldExclude: true },
+  // ],
+  // Uncomment to override the default version patterns:
+  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+  // Uncomment to add custom work types (merged with defaults):
+  // workTypes: { perf: { header: 'Performance' } },
   // TODO: Uncomment and adjust if you have a format command
   // formatCommand: 'pnpm run fmt',
 };
+
+export default config;
 `;
   }
-  return `import type { ReleaseConfig } from '@williamthorsen/release-kit';
-import { DEFAULT_WORK_TYPES } from '@williamthorsen/release-kit';
+  return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
 
-export const config: ReleaseConfig = {
-  // TODO: Adjust the tag prefix if needed (e.g., 'v' for tags like v1.2.3)
-  tagPrefix: 'v',
-  packageFiles: ['package.json'],
-  changelogPaths: ['.'],
-  workTypes: [...DEFAULT_WORK_TYPES],
+const config: ReleaseKitConfig = {
+  // Uncomment to override the default version patterns:
+  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+  // Uncomment to add custom work types (merged with defaults):
+  // workTypes: { perf: { header: 'Performance' } },
   // TODO: Uncomment and adjust if you have a format command
   // formatCommand: 'pnpm run fmt',
 };
+
+export default config;
 `;
 }
 function releaseWorkflow(repoType) {
@@ -74,12 +60,11 @@ permissions:
 
 jobs:
   release:
-    uses: williamthorsen/.github/.github/workflows/release-pnpm.yaml@v1
+    uses: williamthorsen/.github/.github/workflows/release-pnpm.yaml@v2
     with:
       # TODO: Set the Node.js and pnpm versions for your project
-      node-version: '22.0.0'
-      pnpm-version: '10.0.0'
-      monorepo: true
+      node-version: '24'
+      pnpm-version: '10.32.1'
       only: \${{ inputs.only }}
       bump: \${{ inputs.bump }}
 `;
@@ -106,16 +91,15 @@ permissions:
 
 jobs:
   release:
-    uses: williamthorsen/.github/.github/workflows/release-pnpm.yaml@v1
+    uses: williamthorsen/.github/.github/workflows/release-pnpm.yaml@v2
     with:
       # TODO: Set the Node.js and pnpm versions for your project
-      node-version: '22.0.0'
-      pnpm-version: '10.0.0'
+      node-version: '24'
+      pnpm-version: '10.32.1'
       bump: \${{ inputs.bump }}
 `;
 }
 export {
   releaseConfigScript,
-  releasePrepareScript,
   releaseWorkflow
 };

package/dist/esm/loadConfig.d.ts

@@ -0,0 +1,5 @@
+import type { MonorepoReleaseConfig, ReleaseConfig, ReleaseKitConfig } from './types.ts';
+export declare const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
+export declare function loadConfig(): Promise<unknown>;
+export declare function mergeMonorepoConfig(discoveredPaths: string[], userConfig: ReleaseKitConfig | undefined): MonorepoReleaseConfig;
+export declare function mergeSinglePackageConfig(userConfig: ReleaseKitConfig | undefined): ReleaseConfig;

package/dist/esm/loadConfig.js

@@ -0,0 +1,91 @@
+import { existsSync } from "node:fs";
+import { component } from "./component.js";
+import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
+async function loadConfig() {
+  if (!existsSync(CONFIG_FILE_PATH)) {
+    return void 0;
+  }
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(import.meta.url);
+  const imported = await jiti.import(CONFIG_FILE_PATH);
+  if (!isRecord(imported)) {
+    throw new Error(`Config file must export an object, got ${Array.isArray(imported) ? "array" : typeof imported}`);
+  }
+  const resolved = imported.default ?? imported.config;
+  if (resolved === void 0) {
+    throw new Error(
+      "Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)"
+    );
+  }
+  return resolved;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMonorepoConfig(discoveredPaths, userConfig) {
+  let components = discoveredPaths.map((workspacePath) => component(workspacePath));
+  if (userConfig?.components !== void 0) {
+    const overrides = new Map(userConfig.components.map((c) => [c.dir, c]));
+    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 };
+  const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+  const result = {
+    components,
+    workTypes,
+    versionPatterns
+  };
+  const formatCommand = userConfig?.formatCommand;
+  if (formatCommand !== void 0) {
+    result.formatCommand = formatCommand;
+  }
+  const cliffConfigPath = userConfig?.cliffConfigPath;
+  if (cliffConfigPath !== void 0) {
+    result.cliffConfigPath = cliffConfigPath;
+  }
+  const workspaceAliases = userConfig?.workspaceAliases;
+  if (workspaceAliases !== void 0) {
+    result.workspaceAliases = workspaceAliases;
+  }
+  return result;
+}
+function mergeSinglePackageConfig(userConfig) {
+  const workTypes = userConfig?.workTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userConfig.workTypes };
+  const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+  const result = {
+    tagPrefix: "v",
+    packageFiles: ["package.json"],
+    changelogPaths: ["."],
+    workTypes,
+    versionPatterns
+  };
+  const formatCommand = userConfig?.formatCommand;
+  if (formatCommand !== void 0) {
+    result.formatCommand = formatCommand;
+  }
+  const cliffConfigPath = userConfig?.cliffConfigPath;
+  if (cliffConfigPath !== void 0) {
+    result.cliffConfigPath = cliffConfigPath;
+  }
+  const workspaceAliases = userConfig?.workspaceAliases;
+  if (workspaceAliases !== void 0) {
+    result.workspaceAliases = workspaceAliases;
+  }
+  return result;
+}
+export {
+  CONFIG_FILE_PATH,
+  loadConfig,
+  mergeMonorepoConfig,
+  mergeSinglePackageConfig
+};

package/dist/esm/parseCommitMessage.d.ts

@@ -1,2 +1,2 @@
 import type { ParsedCommit, WorkTypeConfig } from './types.ts';
-export declare function parseCommitMessage(message: string, hash: string, workTypes: readonly WorkTypeConfig[], workspaceAliases?: Record<string, string>): ParsedCommit | undefined;
+export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, workspaceAliases?: Record<string, string>): ParsedCommit | undefined;

package/dist/esm/parseCommitMessage.js

@@ -27,14 +27,14 @@ function parseCommitMessage(message, hash, workTypes, workspaceAliases) {
 }
 function resolveType(rawType, workTypes) {
   const lowered = rawType.toLowerCase();
-  for (const config of workTypes) {
-    if (config.type === lowered) {
-      return config.type;
+  for (const [key, config] of Object.entries(workTypes)) {
+    if (key === lowered) {
+      return key;
     }
     if (config.aliases !== void 0) {
       for (const alias of config.aliases) {
         if (alias === lowered) {
-          return config.type;
+          return key;
         }
       }
     }

package/dist/esm/prepareCommand.d.ts

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

package/dist/esm/prepareCommand.js

@@ -0,0 +1,77 @@
+import { discoverWorkspaces } from "./discoverWorkspaces.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 { validateConfig } from "./validateConfig.js";
+async function prepareCommand(argv) {
+  const { dryRun, bumpOverride, only } = parseArgs(argv);
+  const options = { dryRun, ...bumpOverride === void 0 ? {} : { bumpOverride } };
+  let rawConfig;
+  try {
+    rawConfig = await loadConfig();
+  } catch (error) {
+    console.error(`Error loading config: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  let userConfig;
+  if (rawConfig !== void 0) {
+    const { config, errors } = validateConfig(rawConfig);
+    if (errors.length > 0) {
+      console.error("Invalid config:");
+      for (const err of errors) {
+        console.error(`  - ${err}`);
+      }
+      process.exit(1);
+    }
+    userConfig = config;
+  }
+  let discoveredPaths;
+  try {
+    discoveredPaths = await discoverWorkspaces();
+  } catch (error) {
+    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);
+    }
+  } else {
+    const config = mergeMonorepoConfig(discoveredPaths, userConfig);
+    if (only !== void 0) {
+      const knownNames = config.components.map((c) => c.dir);
+      for (const name of only) {
+        if (!knownNames.includes(name)) {
+          console.error(`Error: Unknown component "${name}". Known components: ${knownNames.join(", ")}`);
+          process.exit(1);
+        }
+      }
+      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);
+    }
+  }
+  if (tags.length > 0) {
+    console.info(`
+Release tags file: ${RELEASE_TAGS_FILE}`);
+  }
+}
+export {
+  prepareCommand
+};

package/dist/esm/releasePrepare.js

@@ -1,19 +1,22 @@
 import { execSync } from "node:child_process";
 import { bumpAllVersions } from "./bumpAllVersions.js";
+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 { 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;
   if (bumpOverride === void 0) {
-    const parsedCommits = commits.map((c) => parseCommitMessage(c.message, c.hash, config.workTypes, config.workspaceAliases)).filter((c) => c !== 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`);
-    releaseType = determineBumpType(parsedCommits, config.workTypes);
+    releaseType = determineBumpType(parsedCommits, workTypes, versionPatterns);
   } else {
     releaseType = bumpOverride;
     console.info(`  Using bump override: ${releaseType}`);