@williamthorsen/release-kit 0.2.2 → 1.0.0

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.d.ts

@@ -3,4 +3,4 @@ export interface ReleasePrepareOptions {
     dryRun: boolean;
     bumpOverride?: ReleaseType;
 }
-export declare function releasePrepare(config: ReleaseConfig, options: ReleasePrepareOptions): void;
+export declare function releasePrepare(config: ReleaseConfig, options: ReleasePrepareOptions): string[];

package/dist/esm/releasePrepare.js

@@ -1,26 +1,29 @@
 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}`);
   }
   if (releaseType === void 0) {
     console.info("No release-worthy changes found. Skipping.");
-    return;
+    return [];
   }
   console.info(`Bumping versions (${releaseType})...`);
   const newVersion = bumpAllVersions(config.packageFiles, releaseType, dryRun);
@@ -42,6 +45,7 @@ function releasePrepare(config, options) {
     }
   }
   console.info(`Release preparation complete: ${newTag}`);
+  return [newTag];
 }
 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): void;
+export declare function releasePrepareMono(config: MonorepoReleaseConfig, options: ReleasePrepareOptions): string[];

package/dist/esm/releasePrepareMono.js

@@ -1,46 +1,51 @@
 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;
-  let anyComponentProcessed = false;
+  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})...`);
     const newVersion = bumpAllVersions(component.packageFiles, releaseType, dryRun);
     const newTag = `${component.tagPrefix}${newVersion}`;
-    anyComponentProcessed = true;
+    tags.push(newTag);
     console.info("  Generating changelogs...");
     for (const changelogPath of component.changelogPaths) {
       generateChangelog(config, changelogPath, newTag, dryRun, { includePaths: component.paths });
     }
     console.info(`  Component release prepared: ${newTag}`);
   }
-  if (anyComponentProcessed && config.formatCommand !== void 0) {
+  if (tags.length > 0 && config.formatCommand !== void 0) {
     if (dryRun) {
       console.info(`
   [dry-run] Would run format command: ${config.formatCommand}`);
@@ -56,9 +61,10 @@ Processing component: ${component.tagPrefix}`);
       }
     }
   }
-  const summary = anyComponentProcessed ? "Monorepo release preparation complete." : "No components had release-worthy changes.";
+  const summary = tags.length > 0 ? "Monorepo release preparation complete." : "No components had release-worthy changes.";
   console.info(`
 ${summary}`);
+  return tags;
 }
 export {
   releasePrepareMono

package/dist/esm/runReleasePrepare.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,112 @@
+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 = "/tmp/release-kit/.release-tags";
+const VALID_BUMP_TYPES = ["major", "minor", "patch"];
+function isReleaseType(value) {
+  return VALID_BUMP_TYPES.includes(value);
+}
+function isMonorepoConfig(config) {
+  return "components" in config;
+}
+function showHelp() {
+  console.info(`
+Usage: runReleasePrepare [options]
+
+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
+`);
+}
+function parseArgs(argv) {
+  let dryRun = false;
+  let bumpOverride;
+  let only;
+  for (const arg of argv) {
+    if (arg === "--dry-run") {
+      dryRun = 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);
+    }
+  }
+  return { dryRun, bumpOverride, only };
+}
+function runReleasePrepare(config) {
+  const { dryRun, bumpOverride, only } = parseArgs(process.argv.slice(2));
+  const options = { dryRun, ...bumpOverride === void 0 ? {} : { bumpOverride } };
+  if (!isMonorepoConfig(config)) {
+    if (only !== void 0) {
+      console.error("Error: --only is only supported for monorepo configurations");
+      process.exit(1);
+    }
+    try {
+      const tags = releasePrepare(config, options);
+      writeReleaseTags(tags, dryRun);
+    } catch (error) {
+      console.error("Error preparing release:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+    return;
+  }
+  let effectiveConfig = config;
+  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);
+      }
+    }
+    const filtered = config.components.filter((c) => only.includes(c.dir));
+    effectiveConfig = { ...config, components: filtered };
+  }
+  try {
+    const tags = releasePrepareMono(effectiveConfig, options);
+    writeReleaseTags(tags, dryRun);
+  } catch (error) {
+    console.error("Error preparing release:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function writeReleaseTags(tags, dryRun) {
+  if (tags.length === 0) {
+    return;
+  }
+  if (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,
+  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
+};