@williamthorsen/release-kit 0.2.3 → 1.0.0

package/dist/esm/releasePrepareMono.js

@@ -1,33 +1,38 @@
 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 { generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { parseCommitMessage } from "./parseCommitMessage.js";
 function releasePrepareMono(config, options) {
   const { dryRun, bumpOverride } = options;
+  const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
+  const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
   const tags = [];
   for (const component of config.components) {
+    const name = component.dir;
     console.info(`
-Processing component: ${component.tagPrefix}`);
+Processing component: ${name}`);
     console.info("  Finding commits since last release...");
     const { tag, commits } = getCommitsSinceTarget(component.tagPrefix, component.paths);
-    console.info(`  Found ${commits.length} commits since ${tag ?? "the beginning"}`);
+    const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+    console.info(`  Found ${commits.length} commits ${since}`);
     if (commits.length === 0) {
-      console.info(`  No changes for ${component.tagPrefix}. Skipping.`);
+      console.info(`  No changes for ${name} ${since}. Skipping.`);
       continue;
     }
     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}`);
     }
     if (releaseType === void 0) {
-      console.info(`  No release-worthy changes for ${component.tagPrefix}. Skipping.`);
+      console.info(`  No release-worthy changes for ${name} ${since}. Skipping.`);
       continue;
     }
     console.info(`  Bumping versions (${releaseType})...`);

package/dist/esm/runReleasePrepare.d.ts

@@ -1,3 +1,9 @@
-import type { MonorepoReleaseConfig, ReleaseConfig } from './types.ts';
-export declare const RELEASE_TAGS_FILE = ".release-tags";
+import type { MonorepoReleaseConfig, ReleaseConfig, ReleaseType } from './types.ts';
+export declare const RELEASE_TAGS_FILE = "/tmp/release-kit/.release-tags";
+export declare function parseArgs(argv: string[]): {
+    dryRun: boolean;
+    bumpOverride: ReleaseType | undefined;
+    only: string[] | undefined;
+};
 export declare function runReleasePrepare(config: MonorepoReleaseConfig | ReleaseConfig): void;
+export declare function writeReleaseTags(tags: string[], dryRun: boolean): void;

package/dist/esm/runReleasePrepare.js

@@ -1,7 +1,8 @@
-import { writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
-const RELEASE_TAGS_FILE = ".release-tags";
+const RELEASE_TAGS_FILE = "/tmp/release-kit/.release-tags";
 const VALID_BUMP_TYPES = ["major", "minor", "patch"];
 function isReleaseType(value) {
   return VALID_BUMP_TYPES.includes(value);
@@ -13,18 +14,14 @@ function showHelp() {
   console.info(`
 Usage: runReleasePrepare [options]
 
-This script is designed for CI use via: gh workflow run release.yaml
+Legacy entry point for release preparation. Prefer the CLI:
+  npx @williamthorsen/release-kit prepare
 
 Options:
   --dry-run             Run without modifying any files
   --bump=major|minor|patch  Override the bump type for all components
   --only=name1,name2    Only process the named components (comma-separated, monorepo only)
   --help                Show this help message
-
-Examples:
-  tsx .github/scripts/release-prepare.ts --dry-run
-  tsx .github/scripts/release-prepare.ts --bump=minor
-  tsx .github/scripts/release-prepare.ts --only=arrays,strings --dry-run
 `);
 }
 function parseArgs(argv) {
@@ -77,19 +74,14 @@ function runReleasePrepare(config) {
   }
   let effectiveConfig = config;
   if (only !== void 0) {
-    const knownPrefixes = config.components.map((c) => c.tagPrefix);
-    const filtered = config.components.filter((c) => {
-      const name = c.tagPrefix.replace(/-v$/, "");
-      return only.includes(name);
-    });
+    const knownNames = config.components.map((c) => c.dir);
     for (const name of only) {
-      const matchesKnown = knownPrefixes.includes(`${name}-v`);
-      if (!matchesKnown) {
-        const knownNames = knownPrefixes.map((p) => p.replace(/-v$/, "")).join(", ");
-        console.error(`Error: Unknown component "${name}". Known components: ${knownNames}`);
+      if (!knownNames.includes(name)) {
+        console.error(`Error: Unknown component "${name}". Known components: ${knownNames.join(", ")}`);
         process.exit(1);
       }
     }
+    const filtered = config.components.filter((c) => only.includes(c.dir));
     effectiveConfig = { ...config, components: filtered };
   }
   try {
@@ -108,10 +100,13 @@ function writeReleaseTags(tags, dryRun) {
     console.info(`  [dry-run] Would write ${RELEASE_TAGS_FILE}: ${tags.join(" ")}`);
     return;
   }
+  mkdirSync(dirname(RELEASE_TAGS_FILE), { recursive: true });
   writeFileSync(RELEASE_TAGS_FILE, tags.join("\n"), "utf8");
   console.info(`  Wrote ${RELEASE_TAGS_FILE}: ${tags.join(" ")}`);
 }
 export {
   RELEASE_TAGS_FILE,
-  runReleasePrepare
+  parseArgs,
+  runReleasePrepare,
+  writeReleaseTags
 };

package/dist/esm/types.d.ts

@@ -1,10 +1,25 @@
 export type ReleaseType = 'major' | 'minor' | 'patch';
 export interface WorkTypeConfig {
-    type: string;
     header: string;
-    bump: ReleaseType;
     aliases?: string[];
 }
+export interface VersionPatterns {
+    major: string[];
+    minor: string[];
+}
+export interface ReleaseKitConfig {
+    components?: ComponentOverride[];
+    versionPatterns?: VersionPatterns;
+    workTypes?: Record<string, WorkTypeConfig>;
+    formatCommand?: string;
+    cliffConfigPath?: string;
+    workspaceAliases?: Record<string, string>;
+}
+export interface ComponentOverride {
+    dir: string;
+    tagPrefix?: string;
+    shouldExclude?: boolean;
+}
 export interface Commit {
     message: string;
     hash: string;
@@ -18,6 +33,7 @@ export interface ParsedCommit {
     breaking: boolean;
 }
 export interface ComponentConfig {
+    dir: string;
     tagPrefix: string;
     packageFiles: string[];
     changelogPaths: string[];
@@ -25,7 +41,8 @@ export interface ComponentConfig {
 }
 export interface MonorepoReleaseConfig {
     components: ComponentConfig[];
-    workTypes: WorkTypeConfig[];
+    workTypes?: Record<string, WorkTypeConfig>;
+    versionPatterns?: VersionPatterns;
     formatCommand?: string;
     cliffConfigPath?: string;
     workspaceAliases?: Record<string, string>;
@@ -34,7 +51,8 @@ export interface ReleaseConfig {
     tagPrefix: string;
     packageFiles: string[];
     changelogPaths: string[];
-    workTypes: WorkTypeConfig[];
+    workTypes?: Record<string, WorkTypeConfig>;
+    versionPatterns?: VersionPatterns;
     formatCommand?: string;
     cliffConfigPath?: string;
     workspaceAliases?: Record<string, string>;

package/dist/esm/validateConfig.d.ts

@@ -0,0 +1,5 @@
+import type { ReleaseKitConfig } from './types.ts';
+export declare function validateConfig(raw: unknown): {
+    config: ReleaseKitConfig;
+    errors: string[];
+};

package/dist/esm/validateConfig.js

@@ -0,0 +1,143 @@
+function validateConfig(raw) {
+  const errors = [];
+  if (!isRecord(raw)) {
+    return { config: {}, errors: ["Config must be an object"] };
+  }
+  const config = {};
+  const knownFields = /* @__PURE__ */ new Set([
+    "components",
+    "versionPatterns",
+    "workTypes",
+    "formatCommand",
+    "cliffConfigPath",
+    "workspaceAliases"
+  ]);
+  for (const key of Object.keys(raw)) {
+    if (!knownFields.has(key)) {
+      errors.push(`Unknown field: '${key}'`);
+    }
+  }
+  validateComponents(raw.components, config, errors);
+  validateVersionPatterns(raw.versionPatterns, config, errors);
+  validateWorkTypes(raw.workTypes, config, errors);
+  validateStringField("formatCommand", raw.formatCommand, config, errors);
+  validateStringField("cliffConfigPath", raw.cliffConfigPath, config, errors);
+  validateWorkspaceAliases(raw.workspaceAliases, config, errors);
+  return { config, errors };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function validateComponents(value, config, errors) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    errors.push("'components' must be an array");
+    return;
+  }
+  const components = [];
+  for (const [i, entry] of value.entries()) {
+    if (!isRecord(entry)) {
+      errors.push(`components[${i}]: must be an object`);
+      continue;
+    }
+    if (typeof entry.dir !== "string" || entry.dir === "") {
+      errors.push(`components[${i}]: 'dir' is required`);
+      continue;
+    }
+    const component = { dir: entry.dir };
+    if (entry.tagPrefix !== void 0) {
+      if (typeof entry.tagPrefix === "string") {
+        component.tagPrefix = entry.tagPrefix;
+      } else {
+        errors.push(`components[${i}]: 'tagPrefix' must be a string`);
+      }
+    }
+    if (entry.shouldExclude !== void 0) {
+      if (typeof entry.shouldExclude === "boolean") {
+        component.shouldExclude = entry.shouldExclude;
+      } else {
+        errors.push(`components[${i}]: 'shouldExclude' must be a boolean`);
+      }
+    }
+    components.push(component);
+  }
+  config.components = components;
+}
+function validateVersionPatterns(value, config, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push("'versionPatterns' must be an object");
+    return;
+  }
+  if (!isStringArray(value.major)) {
+    errors.push("versionPatterns.major: expected string array");
+  }
+  if (!isStringArray(value.minor)) {
+    errors.push("versionPatterns.minor: expected string array");
+  }
+  if (isStringArray(value.major) && isStringArray(value.minor)) {
+    config.versionPatterns = { major: value.major, minor: value.minor };
+  }
+}
+function validateWorkTypes(value, config, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value) || Array.isArray(value)) {
+    errors.push("'workTypes' must be a record (object)");
+    return;
+  }
+  const workTypes = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!isRecord(entry)) {
+      errors.push(`workTypes.${key}: must be an object`);
+      continue;
+    }
+    if (typeof entry.header !== "string") {
+      errors.push(`workTypes.${key}: 'header' is required and must be a string`);
+      continue;
+    }
+    const wtEntry = { header: entry.header };
+    if (entry.aliases !== void 0) {
+      if (isStringArray(entry.aliases)) {
+        wtEntry.aliases = entry.aliases;
+      } else {
+        errors.push(`workTypes.${key}: 'aliases' must be a string array`);
+      }
+    }
+    workTypes[key] = wtEntry;
+  }
+  config.workTypes = workTypes;
+}
+function validateStringField(fieldName, value, config, errors) {
+  if (value === void 0) return;
+  if (typeof value !== "string") {
+    errors.push(`'${fieldName}' must be a string`);
+    return;
+  }
+  config[fieldName] = value;
+}
+function validateWorkspaceAliases(value, config, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push("'workspaceAliases' must be a record (object)");
+    return;
+  }
+  const aliases = {};
+  let valid = true;
+  for (const [key, v] of Object.entries(value)) {
+    if (typeof v === "string") {
+      aliases[key] = v;
+    } else {
+      errors.push(`workspaceAliases.${key}: value must be a string`);
+      valid = false;
+    }
+  }
+  if (valid) {
+    config.workspaceAliases = aliases;
+  }
+}
+export {
+  validateConfig
+};