@codluv/versionguard 0.7.0 → 0.9.0

package/dist/chunks/index-DWiw8Nps.js

@@ -1,2982 +0,0 @@
-import * as childProcess from "node:child_process";
-import { execFileSync, execSync } from "node:child_process";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { parse as parse$2 } from "smol-toml";
-import * as yaml from "js-yaml";
-import { globSync } from "glob";
-import { fileURLToPath } from "node:url";
-function validateModifier(modifier, schemeRules) {
-  if (!modifier || !schemeRules?.allowedModifiers) return null;
-  const baseModifier = modifier.replace(/[\d.]+$/, "") || modifier;
-  if (!schemeRules.allowedModifiers.includes(baseModifier)) {
-    return {
-      message: `Modifier "${modifier}" is not allowed. Allowed: ${schemeRules.allowedModifiers.join(", ")}`,
-      severity: "error"
-    };
-  }
-  return null;
-}
-const VALID_TOKENS = /* @__PURE__ */ new Set([
-  "YYYY",
-  "YY",
-  "0Y",
-  "MM",
-  "M",
-  "0M",
-  "WW",
-  "0W",
-  "DD",
-  "D",
-  "0D",
-  "MICRO",
-  "PATCH"
-]);
-const YEAR_TOKENS = /* @__PURE__ */ new Set(["YYYY", "YY", "0Y"]);
-const MONTH_TOKENS = /* @__PURE__ */ new Set(["MM", "M", "0M"]);
-const WEEK_TOKENS = /* @__PURE__ */ new Set(["WW", "0W"]);
-const DAY_TOKENS = /* @__PURE__ */ new Set(["DD", "D", "0D"]);
-const COUNTER_TOKENS = /* @__PURE__ */ new Set(["MICRO", "PATCH"]);
-function isValidCalVerFormat(formatStr) {
-  const tokens = formatStr.split(".");
-  if (tokens.length < 2) return false;
-  if (!tokens.every((t) => VALID_TOKENS.has(t))) return false;
-  if (!YEAR_TOKENS.has(tokens[0])) return false;
-  const hasWeek = tokens.some((t) => WEEK_TOKENS.has(t));
-  const hasMonthOrDay = tokens.some((t) => MONTH_TOKENS.has(t) || DAY_TOKENS.has(t));
-  if (hasWeek && hasMonthOrDay) return false;
-  const counterIndex = tokens.findIndex((t) => COUNTER_TOKENS.has(t));
-  if (counterIndex !== -1 && counterIndex !== tokens.length - 1) return false;
-  return true;
-}
-function parseFormat(calverFormat) {
-  const tokens = calverFormat.split(".");
-  const result = {
-    year: tokens[0]
-  };
-  for (let i = 1; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (MONTH_TOKENS.has(token)) {
-      result.month = token;
-    } else if (WEEK_TOKENS.has(token)) {
-      result.week = token;
-    } else if (DAY_TOKENS.has(token)) {
-      result.day = token;
-    } else if (COUNTER_TOKENS.has(token)) {
-      result.counter = token;
-    }
-  }
-  return result;
-}
-const MODIFIER_PATTERN = "(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?";
-function tokenPattern(token) {
-  switch (token) {
-    case "YYYY":
-      return "([1-9]\\d{3})";
-    case "YY":
-      return "(\\d{1,3})";
-    case "0Y":
-      return "(\\d{2,3})";
-    case "MM":
-    case "M":
-      return "([1-9]|1[0-2])";
-    case "0M":
-      return "(0[1-9]|1[0-2])";
-    case "WW":
-      return "([1-9]|[1-4]\\d|5[0-3])";
-    case "0W":
-      return "(0[1-9]|[1-4]\\d|5[0-3])";
-    case "DD":
-    case "D":
-      return "([1-9]|[12]\\d|3[01])";
-    case "0D":
-      return "(0[1-9]|[12]\\d|3[01])";
-    case "MICRO":
-    case "PATCH":
-      return "(0|[1-9]\\d*)";
-    default:
-      throw new Error(`Unsupported CalVer token: ${token}`);
-  }
-}
-function getRegexForFormat(calverFormat) {
-  const tokens = calverFormat.split(".");
-  const pattern = tokens.map(tokenPattern).join("\\.");
-  return new RegExp(`^${pattern}${MODIFIER_PATTERN}$`);
-}
-function parse$1(version, calverFormat) {
-  const match = version.match(getRegexForFormat(calverFormat));
-  if (!match) {
-    return null;
-  }
-  const definition = parseFormat(calverFormat);
-  const yearToken = definition.year;
-  let year = Number.parseInt(match[1], 10);
-  if (yearToken === "YY" || yearToken === "0Y") {
-    year = 2e3 + year;
-  }
-  let cursor = 2;
-  let month;
-  let day;
-  let patch;
-  if (definition.month) {
-    month = Number.parseInt(match[cursor], 10);
-    cursor += 1;
-  }
-  if (definition.week) {
-    month = Number.parseInt(match[cursor], 10);
-    cursor += 1;
-  }
-  if (definition.day) {
-    day = Number.parseInt(match[cursor], 10);
-    cursor += 1;
-  }
-  if (definition.counter) {
-    patch = Number.parseInt(match[cursor], 10);
-    cursor += 1;
-  }
-  const modifierGroup = match[cursor];
-  const modifier = modifierGroup || void 0;
-  return {
-    year,
-    month: month ?? 1,
-    day,
-    patch,
-    modifier,
-    format: calverFormat,
-    raw: version
-  };
-}
-function validate$2(version, calverFormat, preventFutureDates = true, schemeRules) {
-  const errors = [];
-  const parsed = parse$1(version, calverFormat);
-  if (!parsed) {
-    return {
-      valid: false,
-      errors: [
-        {
-          message: `Invalid CalVer format: "${version}". Expected format: ${calverFormat}`,
-          severity: "error"
-        }
-      ]
-    };
-  }
-  const definition = parseFormat(calverFormat);
-  if (definition.month && (parsed.month < 1 || parsed.month > 12)) {
-    errors.push({
-      message: `Invalid month: ${parsed.month}. Must be between 1 and 12.`,
-      severity: "error"
-    });
-  }
-  if (definition.week && (parsed.month < 1 || parsed.month > 53)) {
-    errors.push({
-      message: `Invalid week: ${parsed.month}. Must be between 1 and 53.`,
-      severity: "error"
-    });
-  }
-  if (parsed.day !== void 0) {
-    if (parsed.day < 1 || parsed.day > 31) {
-      errors.push({
-        message: `Invalid day: ${parsed.day}. Must be between 1 and 31.`,
-        severity: "error"
-      });
-    } else if (definition.month) {
-      const daysInMonth = new Date(parsed.year, parsed.month, 0).getDate();
-      if (parsed.day > daysInMonth) {
-        errors.push({
-          message: `Invalid day: ${parsed.day}. ${parsed.year}-${String(parsed.month).padStart(2, "0")} has only ${daysInMonth} days.`,
-          severity: "error"
-        });
-      }
-    }
-  }
-  if (preventFutureDates) {
-    const now = /* @__PURE__ */ new Date();
-    const currentYear = now.getFullYear();
-    const currentMonth = now.getMonth() + 1;
-    const currentDay = now.getDate();
-    if (parsed.year > currentYear) {
-      errors.push({
-        message: `Future year not allowed: ${parsed.year}. Current year is ${currentYear}.`,
-        severity: "error"
-      });
-    } else if (definition.month && parsed.year === currentYear && parsed.month > currentMonth) {
-      errors.push({
-        message: `Future month not allowed: ${parsed.year}.${parsed.month}. Current month is ${currentMonth}.`,
-        severity: "error"
-      });
-    } else if (definition.month && parsed.year === currentYear && parsed.month === currentMonth && parsed.day !== void 0 && parsed.day > currentDay) {
-      errors.push({
-        message: `Future day not allowed: ${parsed.year}.${parsed.month}.${parsed.day}. Current day is ${currentDay}.`,
-        severity: "error"
-      });
-    }
-  }
-  if (parsed.modifier) {
-    const modifierError = validateModifier(parsed.modifier, schemeRules);
-    if (modifierError) {
-      errors.push(modifierError);
-    }
-  }
-  if (schemeRules?.maxNumericSegments) {
-    const segmentCount = calverFormat.split(".").length;
-    if (segmentCount > schemeRules.maxNumericSegments) {
-      errors.push({
-        message: `Format has ${segmentCount} segments, convention recommends ${schemeRules.maxNumericSegments} or fewer`,
-        severity: "warning"
-      });
-    }
-  }
-  return {
-    valid: errors.filter((e) => e.severity === "error").length === 0,
-    errors,
-    version: { type: "calver", version: parsed }
-  };
-}
-function formatToken(token, value) {
-  switch (token) {
-    case "0M":
-    case "0D":
-    case "0W":
-    case "0Y":
-      return String(token === "0Y" ? value % 100 : value).padStart(2, "0");
-    case "YY":
-      return String(value % 100).padStart(2, "0");
-    default:
-      return String(value);
-  }
-}
-function format$1(version) {
-  const definition = parseFormat(version.format);
-  const parts = [formatToken(definition.year, version.year)];
-  if (definition.month) {
-    parts.push(formatToken(definition.month, version.month));
-  }
-  if (definition.week) {
-    parts.push(formatToken(definition.week, version.month));
-  }
-  if (definition.day) {
-    parts.push(formatToken(definition.day, version.day ?? 1));
-  }
-  if (definition.counter) {
-    parts.push(formatToken(definition.counter, version.patch ?? 0));
-  }
-  const base = parts.join(".");
-  return version.modifier ? `${base}-${version.modifier}` : base;
-}
-function getCurrentVersion(calverFormat, now = /* @__PURE__ */ new Date()) {
-  const definition = parseFormat(calverFormat);
-  const base = {
-    year: now.getFullYear(),
-    month: now.getMonth() + 1,
-    day: definition.day ? now.getDate() : void 0,
-    patch: definition.counter ? 0 : void 0,
-    format: calverFormat
-  };
-  return format$1(base);
-}
-function compare$1(a, b, calverFormat) {
-  const left = parse$1(a, calverFormat);
-  const right = parse$1(b, calverFormat);
-  if (!left || !right) {
-    throw new Error(`Invalid CalVer comparison between "${a}" and "${b}"`);
-  }
-  for (const key of ["year", "month", "day", "patch"]) {
-    const leftValue = left[key] ?? 0;
-    const rightValue = right[key] ?? 0;
-    if (leftValue !== rightValue) {
-      return leftValue > rightValue ? 1 : -1;
-    }
-  }
-  return 0;
-}
-function increment$1(version, calverFormat) {
-  const parsed = parse$1(version, calverFormat);
-  if (!parsed) {
-    throw new Error(`Invalid CalVer version: ${version}`);
-  }
-  const definition = parseFormat(calverFormat);
-  const next = {
-    ...parsed
-  };
-  if (definition.counter) {
-    next.patch = (parsed.patch ?? 0) + 1;
-  } else {
-    next.patch = 0;
-    next.format = `${calverFormat}.MICRO`;
-  }
-  return format$1(next);
-}
-function getNextVersions(currentVersion, calverFormat) {
-  return [getCurrentVersion(calverFormat), increment$1(currentVersion, calverFormat)];
-}
-const calver = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  compare: compare$1,
-  format: format$1,
-  getCurrentVersion,
-  getNextVersions,
-  getRegexForFormat,
-  increment: increment$1,
-  isValidCalVerFormat,
-  parse: parse$1,
-  parseFormat,
-  validate: validate$2
-}, Symbol.toStringTag, { value: "Module" }));
-const CHANGELOG_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
-const KEEP_A_CHANGELOG_SECTIONS = [
-  "Added",
-  "Changed",
-  "Deprecated",
-  "Removed",
-  "Fixed",
-  "Security"
-];
-function validateChangelog(changelogPath, version, strict = true, requireEntry = true, structure) {
-  if (!fs.existsSync(changelogPath)) {
-    return {
-      valid: !requireEntry,
-      errors: requireEntry ? [`Changelog not found: ${changelogPath}`] : [],
-      hasEntryForVersion: false
-    };
-  }
-  const errors = [];
-  const content = fs.readFileSync(changelogPath, "utf-8");
-  if (!content.startsWith("# Changelog")) {
-    errors.push('Changelog must start with "# Changelog"');
-  }
-  if (!content.includes("## [Unreleased]")) {
-    errors.push("Changelog must have an [Unreleased] section");
-  }
-  const versionHeader = `## [${version}]`;
-  const hasEntryForVersion = content.includes(versionHeader);
-  if (requireEntry && !hasEntryForVersion) {
-    errors.push(`Changelog must have an entry for version ${version}`);
-  }
-  if (strict) {
-    if (!content.includes("[Unreleased]:")) {
-      errors.push("Changelog should include compare links at the bottom");
-    }
-    const versionHeaderMatch = content.match(
-      new RegExp(`## \\[${escapeRegExp$1(version)}\\] - ([^\r
-]+)`)
-    );
-    if (requireEntry && hasEntryForVersion) {
-      if (!versionHeaderMatch) {
-        errors.push(`Version ${version} entry must use "## [${version}] - YYYY-MM-DD" format`);
-      } else if (!CHANGELOG_DATE_REGEX.test(versionHeaderMatch[1])) {
-        errors.push(`Version ${version} entry date must use YYYY-MM-DD format`);
-      }
-    }
-  }
-  if (structure?.enforceStructure) {
-    const allowed = structure.sections ?? KEEP_A_CHANGELOG_SECTIONS;
-    const sectionErrors = validateSections(content, allowed);
-    errors.push(...sectionErrors);
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    hasEntryForVersion
-  };
-}
-function validateSections(content, allowed) {
-  const errors = [];
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const sectionMatch = lines[i].match(/^### (.+)/);
-    if (!sectionMatch) continue;
-    const sectionName = sectionMatch[1].trim();
-    if (!allowed.includes(sectionName)) {
-      errors.push(
-        `Invalid changelog section "### ${sectionName}" (line ${i + 1}). Allowed: ${allowed.join(", ")}`
-      );
-    }
-    const nextContentLine = lines.slice(i + 1).find((l) => l.trim().length > 0);
-    if (!nextContentLine || nextContentLine.startsWith("#")) {
-      errors.push(`Empty changelog section "### ${sectionName}" (line ${i + 1})`);
-    }
-  }
-  return errors;
-}
-function addVersionEntry(changelogPath, version, date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) {
-  if (!fs.existsSync(changelogPath)) {
-    throw new Error(`Changelog not found: ${changelogPath}`);
-  }
-  const content = fs.readFileSync(changelogPath, "utf-8");
-  if (content.includes(`## [${version}]`)) {
-    return;
-  }
-  const block = `## [${version}] - ${date}
-
-### Added
-
-- Describe changes here.
-
-`;
-  const unreleasedMatch = content.match(/## \[Unreleased\]\r?\n(?:\r?\n)?/);
-  if (!unreleasedMatch || unreleasedMatch.index === void 0) {
-    throw new Error("Changelog must have an [Unreleased] section");
-  }
-  const insertIndex = unreleasedMatch.index + unreleasedMatch[0].length;
-  const updated = `${content.slice(0, insertIndex)}${block}${content.slice(insertIndex)}`;
-  fs.writeFileSync(changelogPath, updated, "utf-8");
-}
-function isChangesetMangled(changelogPath) {
-  if (!fs.existsSync(changelogPath)) return false;
-  const content = fs.readFileSync(changelogPath, "utf-8");
-  return /^## \d+\.\d+/m.test(content) && content.includes("## [Unreleased]");
-}
-const SECTION_MAP = {
-  "Major Changes": "Changed",
-  "Minor Changes": "Added",
-  "Patch Changes": "Fixed"
-};
-function fixChangesetMangling(changelogPath, date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) {
-  if (!fs.existsSync(changelogPath)) return false;
-  const content = fs.readFileSync(changelogPath, "utf-8");
-  const versionMatch = content.match(/^## (\d+\.\d+\.\d+[^\n]*)\n/m);
-  if (!versionMatch || versionMatch.index === void 0) return false;
-  const fullHeader = versionMatch[0];
-  if (fullHeader.includes("[")) return false;
-  const version = versionMatch[1].trim();
-  if (content.includes(`## [${version}]`)) return false;
-  const startIndex = versionMatch.index;
-  const preambleMatch = content.indexOf("All notable changes", startIndex);
-  const unreleasedMatch = content.indexOf("## [Unreleased]", startIndex);
-  let endIndex;
-  if (preambleMatch !== -1 && preambleMatch < unreleasedMatch) {
-    endIndex = preambleMatch;
-  } else if (unreleasedMatch !== -1) {
-    endIndex = unreleasedMatch;
-  } else {
-    return false;
-  }
-  const changesetsBlock = content.slice(startIndex + fullHeader.length, endIndex).trim();
-  const transformedSections = transformChangesetsContent(changesetsBlock);
-  const newEntry = `## [${version}] - ${date}
-
-${transformedSections}
-
-`;
-  const beforeChangesets = content.slice(0, startIndex);
-  const afterChangesets = content.slice(endIndex);
-  const unreleasedInAfter = afterChangesets.indexOf("## [Unreleased]");
-  if (unreleasedInAfter === -1) {
-    const rebuilt2 = `${beforeChangesets}${newEntry}${afterChangesets}`;
-    fs.writeFileSync(changelogPath, rebuilt2, "utf-8");
-    return true;
-  }
-  const unreleasedLineEnd = afterChangesets.indexOf("\n", unreleasedInAfter);
-  const afterUnreleased = unreleasedLineEnd !== -1 ? afterChangesets.slice(0, unreleasedLineEnd + 1) : afterChangesets;
-  const rest = unreleasedLineEnd !== -1 ? afterChangesets.slice(unreleasedLineEnd + 1) : "";
-  const rebuilt = `${beforeChangesets}${afterUnreleased}
-${newEntry}${rest}`;
-  const withLinks = updateCompareLinks(rebuilt, version);
-  fs.writeFileSync(changelogPath, withLinks, "utf-8");
-  return true;
-}
-function transformChangesetsContent(block) {
-  const lines = block.split("\n");
-  const result = [];
-  for (const line of lines) {
-    const sectionMatch = line.match(/^### (.+)/);
-    if (sectionMatch) {
-      const mapped = SECTION_MAP[sectionMatch[1]] ?? sectionMatch[1];
-      result.push(`### ${mapped}`);
-      continue;
-    }
-    const entryMatch = line.match(
-      /^(\s*-\s+)[a-f0-9]{7,}: (?:feat|fix|chore|docs|refactor|perf|test|ci|build|style)(?:\([^)]*\))?: (.+)/
-    );
-    if (entryMatch) {
-      result.push(`${entryMatch[1]}${entryMatch[2]}`);
-      continue;
-    }
-    const simpleHashMatch = line.match(/^(\s*-\s+)[a-f0-9]{7,}: (.+)/);
-    if (simpleHashMatch) {
-      result.push(`${simpleHashMatch[1]}${simpleHashMatch[2]}`);
-      continue;
-    }
-    result.push(line);
-  }
-  return result.join("\n");
-}
-function updateCompareLinks(content, version) {
-  const unreleasedLinkRegex = /\[Unreleased\]: (https:\/\/[^\s]+\/compare\/v)([\d.]+)(\.\.\.HEAD)/;
-  const match = content.match(unreleasedLinkRegex);
-  if (match) {
-    const baseUrl = match[1].replace(/v$/, "");
-    const previousVersion = match[2];
-    const newUnreleasedLink = `[Unreleased]: ${baseUrl}v${version}...HEAD`;
-    const newVersionLink = `[${version}]: ${baseUrl}v${previousVersion}...v${version}`;
-    let updated = content.replace(unreleasedLinkRegex, newUnreleasedLink);
-    if (!updated.includes(`[${version}]:`)) {
-      updated = updated.replace(newUnreleasedLink, `${newUnreleasedLink}
-${newVersionLink}`);
-    }
-    return updated;
-  }
-  return content;
-}
-function escapeRegExp$1(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-const HOOK_NAMES$1 = ["pre-commit", "pre-push", "post-tag"];
-const VG_BLOCK_START = "# >>> versionguard >>>";
-const VG_BLOCK_END = "# <<< versionguard <<<";
-function installHooks(config, cwd = process.cwd()) {
-  const gitDir = findGitDir(cwd);
-  if (!gitDir) {
-    throw new Error("Not a git repository. Run `git init` first.");
-  }
-  const hooksDir = path.join(gitDir, "hooks");
-  fs.mkdirSync(hooksDir, { recursive: true });
-  for (const hookName of HOOK_NAMES$1) {
-    if (config.hooks[hookName]) {
-      const hookPath = path.join(hooksDir, hookName);
-      const vgBlock = generateHookBlock(hookName);
-      if (fs.existsSync(hookPath)) {
-        const existing = fs.readFileSync(hookPath, "utf-8");
-        if (existing.includes(VG_BLOCK_START)) {
-          const updated = replaceVgBlock(existing, vgBlock);
-          fs.writeFileSync(hookPath, updated, { encoding: "utf-8", mode: 493 });
-        } else if (isLegacyVgHook(existing)) {
-          fs.writeFileSync(hookPath, `#!/bin/sh
-
-${vgBlock}
-`, {
-            encoding: "utf-8",
-            mode: 493
-          });
-        } else {
-          const appended = `${existing.trimEnd()}
-
-${vgBlock}
-`;
-          fs.writeFileSync(hookPath, appended, { encoding: "utf-8", mode: 493 });
-        }
-      } else {
-        fs.writeFileSync(hookPath, `#!/bin/sh
-
-${vgBlock}
-`, {
-          encoding: "utf-8",
-          mode: 493
-        });
-      }
-    }
-  }
-}
-function uninstallHooks(cwd = process.cwd()) {
-  const gitDir = findGitDir(cwd);
-  if (!gitDir) {
-    return;
-  }
-  const hooksDir = path.join(gitDir, "hooks");
-  for (const hookName of HOOK_NAMES$1) {
-    const hookPath = path.join(hooksDir, hookName);
-    if (!fs.existsSync(hookPath)) continue;
-    const content = fs.readFileSync(hookPath, "utf-8");
-    if (!content.includes("versionguard")) continue;
-    if (content.includes(VG_BLOCK_START)) {
-      const cleaned = removeVgBlock(content);
-      const trimmed = cleaned.trim();
-      if (!trimmed || trimmed === "#!/bin/sh") {
-        fs.unlinkSync(hookPath);
-      } else if (isLegacyVgHook(trimmed)) {
-        fs.unlinkSync(hookPath);
-      } else {
-        fs.writeFileSync(hookPath, `${trimmed}
-`, { encoding: "utf-8", mode: 493 });
-      }
-    } else if (isLegacyVgHook(content)) {
-      fs.unlinkSync(hookPath);
-    }
-  }
-}
-function findGitDir(cwd) {
-  let current = cwd;
-  while (true) {
-    const gitPath = path.join(current, ".git");
-    if (fs.existsSync(gitPath) && fs.statSync(gitPath).isDirectory()) {
-      return gitPath;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function areHooksInstalled(cwd = process.cwd()) {
-  const gitDir = findGitDir(cwd);
-  if (!gitDir) {
-    return false;
-  }
-  return HOOK_NAMES$1.every((hookName) => {
-    const hookPath = path.join(gitDir, "hooks", hookName);
-    return fs.existsSync(hookPath) && fs.readFileSync(hookPath, "utf-8").includes("versionguard");
-  });
-}
-function generateHookBlock(hookName) {
-  return `${VG_BLOCK_START}
-# VersionGuard ${hookName} hook
-# --no-install prevents accidentally downloading an unscoped package
-# if @codluv/versionguard is not installed locally
-npx --no-install versionguard validate --hook=${hookName}
-status=$?
-if [ $status -ne 0 ]; then
-  echo "VersionGuard validation failed."
-  exit $status
-fi
-${VG_BLOCK_END}`;
-}
-function generateHookScript(hookName) {
-  return `#!/bin/sh
-
-${generateHookBlock(hookName)}
-`;
-}
-function isLegacyVgHook(content) {
-  if (!content.includes("versionguard validate")) return false;
-  if (content.includes(VG_BLOCK_START)) return false;
-  if (content.includes("husky")) return false;
-  if (content.includes("lefthook")) return false;
-  if (content.includes("pre-commit run")) return false;
-  return true;
-}
-function replaceVgBlock(content, newBlock) {
-  const startIdx = content.indexOf(VG_BLOCK_START);
-  const endIdx = content.indexOf(VG_BLOCK_END);
-  if (startIdx === -1 || endIdx === -1) return content;
-  return content.slice(0, startIdx) + newBlock + content.slice(endIdx + VG_BLOCK_END.length);
-}
-function removeVgBlock(content) {
-  const startIdx = content.indexOf(VG_BLOCK_START);
-  const endIdx = content.indexOf(VG_BLOCK_END);
-  if (startIdx === -1 || endIdx === -1) return content;
-  const before = content.slice(0, startIdx).replace(/\n\n$/, "\n");
-  const after = content.slice(endIdx + VG_BLOCK_END.length).replace(/^\n\n/, "\n");
-  return before + after;
-}
-class GitTagSource {
-  /** Human-readable provider name. */
-  name = "git-tag";
-  /** Empty string since git-tag has no manifest file. */
-  manifestFile = "";
-  /**
-   * Returns `true` when `cwd` is inside a Git repository.
-   *
-   * @param cwd - Project directory to check.
-   * @returns Whether a Git repository is found.
-   */
-  exists(cwd) {
-    try {
-      execFileSync("git", ["rev-parse", "--git-dir"], {
-        cwd,
-        stdio: ["pipe", "pipe", "ignore"]
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Reads the version string from the latest Git tag.
-   *
-   * @param cwd - Project directory containing the Git repository.
-   * @returns The version string extracted from the latest version tag.
-   */
-  getVersion(cwd) {
-    try {
-      const tag = this.describeVersionTag(cwd);
-      return tag.replace(/^v/, "");
-    } catch {
-      throw new Error("No version tags found. Create a tag first (e.g., git tag v0.1.0)");
-    }
-  }
-  /**
-   * Creates a new annotated Git tag for the given version.
-   *
-   * @param version - Version string to tag.
-   * @param cwd - Project directory containing the Git repository.
-   */
-  setVersion(version, cwd) {
-    const prefix = this.detectPrefix(cwd);
-    const tagName = `${prefix}${version}`;
-    execFileSync("git", ["tag", "-a", tagName, "-m", `Release ${version}`], {
-      cwd,
-      stdio: ["pipe", "pipe", "ignore"]
-    });
-  }
-  /** Try version-like tag patterns, fall back to any tag. */
-  describeVersionTag(cwd) {
-    try {
-      return execFileSync("git", ["describe", "--tags", "--abbrev=0", "--match", "v[0-9]*"], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      return execFileSync("git", ["describe", "--tags", "--abbrev=0", "--match", "[0-9]*"], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "ignore"]
-      }).trim();
-    } catch {
-      throw new Error("No version tags found");
-    }
-  }
-  /** Detect whether existing tags use a `v` prefix or not. */
-  detectPrefix(cwd) {
-    try {
-      const tag = this.describeVersionTag(cwd);
-      return tag.startsWith("v") ? "v" : "";
-    } catch {
-      return "v";
-    }
-  }
-}
-function getNestedValue(obj, dotPath) {
-  let current = obj;
-  for (const key of dotPath.split(".")) {
-    if (current === null || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[key];
-  }
-  return current;
-}
-function setNestedValue(obj, dotPath, value) {
-  const keys = dotPath.split(".");
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const next = current[keys[i]];
-    if (typeof next !== "object" || next === null) {
-      throw new Error(`Missing intermediate key '${keys.slice(0, i + 1).join(".")}' in manifest`);
-    }
-    current = next;
-  }
-  current[keys[keys.length - 1]] = value;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-class JsonVersionSource {
-  /** Human-readable provider name. */
-  name;
-  /** Filename of the JSON manifest (e.g. `'package.json'`). */
-  manifestFile;
-  /** Dotted key path to the version field within the JSON document. */
-  versionPath;
-  /**
-   * Creates a new JSON version source.
-   *
-   * @param manifestFile - JSON manifest filename.
-   * @param versionPath - Dotted key path to the version field.
-   */
-  constructor(manifestFile = "package.json", versionPath = "version") {
-    this.name = manifestFile;
-    this.manifestFile = manifestFile;
-    this.versionPath = versionPath;
-  }
-  /**
-   * Returns `true` when the manifest file exists in `cwd`.
-   *
-   * @param cwd - Project directory to check.
-   * @returns Whether the manifest file exists.
-   */
-  exists(cwd) {
-    return fs.existsSync(path.join(cwd, this.manifestFile));
-  }
-  /**
-   * Reads the version string from the JSON manifest.
-   *
-   * @param cwd - Project directory containing the manifest.
-   * @returns The version string extracted from the manifest.
-   */
-  getVersion(cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    const version = getNestedValue(content, this.versionPath);
-    if (typeof version !== "string" || version.length === 0) {
-      throw new Error(`No version field in ${this.manifestFile}`);
-    }
-    return version;
-  }
-  /**
-   * Writes a version string to the JSON manifest, preserving indentation.
-   *
-   * @param version - Version string to write.
-   * @param cwd - Project directory containing the manifest.
-   */
-  setVersion(version, cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const indentMatch = raw.match(/^(\s+)"/m);
-    const indent = indentMatch?.[1]?.length ?? 2;
-    const content = JSON.parse(raw);
-    setNestedValue(content, this.versionPath, version);
-    fs.writeFileSync(filePath, `${JSON.stringify(content, null, indent)}
-`, "utf-8");
-  }
-}
-class RegexVersionSource {
-  /** Human-readable provider name. */
-  name;
-  /** Filename of the source manifest (e.g. `'setup.py'`). */
-  manifestFile;
-  /** Compiled regex used to locate the version string. */
-  versionRegex;
-  /**
-   * Creates a new regex version source.
-   *
-   * @param manifestFile - Source manifest filename.
-   * @param versionRegex - Regex string with at least one capture group for the version.
-   */
-  constructor(manifestFile, versionRegex) {
-    this.name = manifestFile;
-    this.manifestFile = manifestFile;
-    try {
-      this.versionRegex = new RegExp(versionRegex, "m");
-    } catch (err) {
-      throw new Error(`Invalid version regex for ${manifestFile}: ${err.message}`);
-    }
-    if (!/\((?!\?)/.test(versionRegex)) {
-      throw new Error(`Version regex for ${manifestFile} must contain at least one capture group`);
-    }
-  }
-  /**
-   * Returns `true` when the manifest file exists in `cwd`.
-   *
-   * @param cwd - Project directory to check.
-   * @returns Whether the manifest file exists.
-   */
-  exists(cwd) {
-    return fs.existsSync(path.join(cwd, this.manifestFile));
-  }
-  /**
-   * Reads the version string from the source manifest using regex extraction.
-   *
-   * @param cwd - Project directory containing the manifest.
-   * @returns The version string captured by group 1 of the regex.
-   */
-  getVersion(cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const match = content.match(this.versionRegex);
-    if (!match?.[1]) {
-      throw new Error(`No version match found in ${this.manifestFile}`);
-    }
-    return match[1];
-  }
-  /**
-   * Writes a version string to the source manifest using position-based replacement.
-   *
-   * @param version - Version string to write.
-   * @param cwd - Project directory containing the manifest.
-   */
-  setVersion(version, cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const match = this.versionRegex.exec(content);
-    if (!match || match.index === void 0) {
-      throw new Error(`No version match found in ${this.manifestFile}`);
-    }
-    const captureStart = match.index + match[0].indexOf(match[1]);
-    const captureEnd = captureStart + match[1].length;
-    const updated = content.slice(0, captureStart) + version + content.slice(captureEnd);
-    fs.writeFileSync(filePath, updated, "utf-8");
-  }
-}
-class TomlVersionSource {
-  /** Human-readable provider name. */
-  name;
-  /** Filename of the TOML manifest (e.g. `'Cargo.toml'`). */
-  manifestFile;
-  /** Dotted key path to the version field within the TOML document. */
-  versionPath;
-  /**
-   * Creates a new TOML version source.
-   *
-   * @param manifestFile - TOML manifest filename.
-   * @param versionPath - Dotted key path to the version field.
-   */
-  constructor(manifestFile = "Cargo.toml", versionPath = "package.version") {
-    this.name = manifestFile;
-    this.manifestFile = manifestFile;
-    this.versionPath = versionPath;
-  }
-  /**
-   * Returns `true` when the manifest file exists in `cwd`.
-   *
-   * @param cwd - Project directory to check.
-   * @returns Whether the manifest file exists.
-   */
-  exists(cwd) {
-    return fs.existsSync(path.join(cwd, this.manifestFile));
-  }
-  /**
-   * Reads the version string from the TOML manifest.
-   *
-   * @param cwd - Project directory containing the manifest.
-   * @returns The version string extracted from the manifest.
-   */
-  getVersion(cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const parsed = parse$2(content);
-    const version = getNestedValue(parsed, this.versionPath);
-    if (typeof version !== "string" || version.length === 0) {
-      throw new Error(`No version field at '${this.versionPath}' in ${this.manifestFile}`);
-    }
-    return version;
-  }
-  /**
-   * Writes a version string to the TOML manifest, preserving formatting.
-   *
-   * @param version - Version string to write.
-   * @param cwd - Project directory containing the manifest.
-   */
-  setVersion(version, cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const sectionKey = this.getSectionKey();
-    const updated = replaceTomlVersion(content, sectionKey, version);
-    if (updated === content) {
-      throw new Error(`Could not find version field to update in ${this.manifestFile}`);
-    }
-    fs.writeFileSync(filePath, updated, "utf-8");
-  }
-  /**
-   * Splits the dotted version path into a TOML section name and key name.
-   *
-   * @returns An object with `section` and `key` components.
-   */
-  getSectionKey() {
-    const parts = this.versionPath.split(".");
-    if (parts.length === 1) {
-      return { section: "", key: parts[0] };
-    }
-    return {
-      section: parts.slice(0, -1).join("."),
-      key: parts[parts.length - 1]
-    };
-  }
-}
-function replaceTomlVersion(content, target, newVersion) {
-  const result = replaceInSection(content, target, newVersion);
-  if (result !== content) return result;
-  if (target.section) {
-    const dottedRegex = new RegExp(
-      `^(\\s*${escapeRegExp(target.section)}\\.${escapeRegExp(target.key)}\\s*=\\s*)(["'])([^"']*)(\\2)`,
-      "m"
-    );
-    const dottedResult = content.replace(dottedRegex, `$1$2${newVersion}$4`);
-    if (dottedResult !== content) return dottedResult;
-  }
-  if (target.section) {
-    const inlineRegex = new RegExp(
-      `^(\\s*${escapeRegExp(target.section)}\\s*=\\s*\\{[^}]*${escapeRegExp(target.key)}\\s*=\\s*)(["'])([^"']*)(\\2)`,
-      "m"
-    );
-    const inlineResult = content.replace(inlineRegex, `$1$2${newVersion}$4`);
-    if (inlineResult !== content) return inlineResult;
-  }
-  return content;
-}
-function replaceInSection(content, target, newVersion) {
-  const lines = content.split("\n");
-  const sectionHeader = target.section ? `[${target.section}]` : null;
-  let inSection = sectionHeader === null;
-  const versionRegex = new RegExp(`^(\\s*${escapeRegExp(target.key)}\\s*=\\s*)(["'])([^"']*)(\\2)`);
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    if (sectionHeader !== null) {
-      if (trimmed === sectionHeader) {
-        inSection = true;
-        continue;
-      }
-      if (inSection && trimmed.startsWith("[") && trimmed !== sectionHeader) {
-        inSection = false;
-        continue;
-      }
-    }
-    if (inSection) {
-      const match = lines[i].match(versionRegex);
-      if (match) {
-        lines[i] = lines[i].replace(versionRegex, `$1$2${newVersion}$4`);
-        return lines.join("\n");
-      }
-    }
-  }
-  return content;
-}
-class VersionFileSource {
-  /** Human-readable provider name. */
-  name;
-  /** Filename of the version file (e.g. `'VERSION'`). */
-  manifestFile;
-  /**
-   * Creates a new plain text version file source.
-   *
-   * @param manifestFile - Version filename.
-   */
-  constructor(manifestFile = "VERSION") {
-    this.name = manifestFile;
-    this.manifestFile = manifestFile;
-  }
-  /**
-   * Returns `true` when the version file exists in `cwd`.
-   *
-   * @param cwd - Project directory to check.
-   * @returns Whether the version file exists.
-   */
-  exists(cwd) {
-    return fs.existsSync(path.join(cwd, this.manifestFile));
-  }
-  /**
-   * Reads the version string from the plain text version file.
-   *
-   * @param cwd - Project directory containing the version file.
-   * @returns The version string from the first line of the file.
-   */
-  getVersion(cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    if (raw.includes("\0")) {
-      throw new Error(`${this.manifestFile} appears to be a binary file`);
-    }
-    const version = raw.split("\n")[0].trim();
-    if (version.length === 0) {
-      throw new Error(`${this.manifestFile} is empty`);
-    }
-    return version;
-  }
-  /**
-   * Writes a version string to the plain text version file.
-   *
-   * @param version - Version string to write.
-   * @param cwd - Project directory containing the version file.
-   */
-  setVersion(version, cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    fs.writeFileSync(filePath, `${version}
-`, "utf-8");
-  }
-}
-class YamlVersionSource {
-  /** Human-readable provider name. */
-  name;
-  /** Filename of the YAML manifest (e.g. `'pubspec.yaml'`). */
-  manifestFile;
-  /** Dotted key path to the version field within the YAML document. */
-  versionKey;
-  /**
-   * Creates a new YAML version source.
-   *
-   * @param manifestFile - YAML manifest filename.
-   * @param versionKey - Dotted key path to the version field.
-   */
-  constructor(manifestFile = "pubspec.yaml", versionKey = "version") {
-    this.name = manifestFile;
-    this.manifestFile = manifestFile;
-    this.versionKey = versionKey;
-  }
-  /**
-   * Returns `true` when the manifest file exists in `cwd`.
-   *
-   * @param cwd - Project directory to check.
-   * @returns Whether the manifest file exists.
-   */
-  exists(cwd) {
-    return fs.existsSync(path.join(cwd, this.manifestFile));
-  }
-  /**
-   * Reads the version string from the YAML manifest.
-   *
-   * @param cwd - Project directory containing the manifest.
-   * @returns The version string extracted from the manifest.
-   */
-  getVersion(cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const parsed = yaml.load(content);
-    if (!parsed || typeof parsed !== "object") {
-      throw new Error(`Failed to parse ${this.manifestFile}`);
-    }
-    const version = getNestedValue(parsed, this.versionKey);
-    if (typeof version !== "string" || version.length === 0) {
-      if (typeof version === "number") {
-        return String(version);
-      }
-      throw new Error(`No version field in ${this.manifestFile}`);
-    }
-    return version;
-  }
-  /**
-   * Writes a version string to the YAML manifest, preserving formatting.
-   *
-   * @param version - Version string to write.
-   * @param cwd - Project directory containing the manifest.
-   */
-  setVersion(version, cwd) {
-    const filePath = path.join(cwd, this.manifestFile);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`${this.manifestFile} not found in ${cwd}`);
-    }
-    const keyParts = this.versionKey.split(".");
-    const leafKey = keyParts[keyParts.length - 1];
-    const content = fs.readFileSync(filePath, "utf-8");
-    const regex = new RegExp(`^(\\s*${escapeRegExp(leafKey)}:\\s*)(["']?)(.+?)\\2\\s*$`, "m");
-    const updated = content.replace(regex, `$1$2${version}$2`);
-    if (updated === content) {
-      throw new Error(`Could not find version field to update in ${this.manifestFile}`);
-    }
-    fs.writeFileSync(filePath, updated, "utf-8");
-  }
-}
-const VALID_SOURCES = /* @__PURE__ */ new Set([
-  "auto",
-  "package.json",
-  "composer.json",
-  "Cargo.toml",
-  "pyproject.toml",
-  "pubspec.yaml",
-  "pom.xml",
-  "VERSION",
-  "git-tag",
-  "custom"
-]);
-const DETECTION_TABLE = [
-  {
-    file: "package.json",
-    source: "package.json",
-    factory: () => new JsonVersionSource("package.json", "version")
-  },
-  {
-    file: "Cargo.toml",
-    source: "Cargo.toml",
-    factory: () => new TomlVersionSource("Cargo.toml", "package.version")
-  },
-  {
-    file: "pyproject.toml",
-    source: "pyproject.toml",
-    factory: () => new TomlVersionSource("pyproject.toml", "project.version")
-  },
-  {
-    file: "pubspec.yaml",
-    source: "pubspec.yaml",
-    factory: () => new YamlVersionSource("pubspec.yaml", "version")
-  },
-  {
-    file: "composer.json",
-    source: "composer.json",
-    factory: () => new JsonVersionSource("composer.json", "version")
-  },
-  {
-    // H-002: Use regex that skips <parent> blocks for pom.xml
-    file: "pom.xml",
-    source: "pom.xml",
-    factory: () => new RegexVersionSource("pom.xml", "<project[^>]*>[\\s\\S]*?<version>([^<]+)</version>")
-  },
-  { file: "VERSION", source: "VERSION", factory: () => new VersionFileSource("VERSION") }
-];
-function assertPathContained(manifestFile, cwd) {
-  const resolved = path.resolve(cwd, manifestFile);
-  const root = path.resolve(cwd);
-  if (!resolved.startsWith(`${root}${path.sep}`) && resolved !== root) {
-    throw new Error(`Manifest path "${manifestFile}" resolves outside the project directory`);
-  }
-}
-function createProvider(source, config, cwd) {
-  if (!VALID_SOURCES.has(source)) {
-    throw new Error(
-      `Invalid manifest source "${source}". Valid sources: ${[...VALID_SOURCES].join(", ")}`
-    );
-  }
-  switch (source) {
-    case "package.json":
-      return new JsonVersionSource("package.json", config.path ?? "version");
-    case "composer.json":
-      return new JsonVersionSource("composer.json", config.path ?? "version");
-    case "Cargo.toml":
-      return new TomlVersionSource("Cargo.toml", config.path ?? "package.version");
-    case "pyproject.toml":
-      return new TomlVersionSource("pyproject.toml", config.path ?? "project.version");
-    case "pubspec.yaml":
-      return new YamlVersionSource("pubspec.yaml", config.path ?? "version");
-    case "pom.xml":
-      return new RegexVersionSource(
-        "pom.xml",
-        config.regex ?? "<project[^>]*>[\\s\\S]*?<version>([^<]+)</version>"
-      );
-    case "VERSION":
-      return new VersionFileSource(config.path ?? "VERSION");
-    case "git-tag":
-      return new GitTagSource();
-    case "custom": {
-      if (!config.regex) {
-        throw new Error("Custom manifest source requires a 'regex' field in manifest config");
-      }
-      if (!config.path) {
-        throw new Error(
-          "Custom manifest source requires a 'path' field (manifest filename) in manifest config"
-        );
-      }
-      assertPathContained(config.path, cwd);
-      return new RegexVersionSource(config.path, config.regex);
-    }
-    default:
-      throw new Error(`Unknown manifest source: ${source}`);
-  }
-}
-function resolveVersionSource(config, cwd = process.cwd()) {
-  if (config.source !== "auto") {
-    return createProvider(config.source, config, cwd);
-  }
-  for (const entry of DETECTION_TABLE) {
-    const provider = entry.factory();
-    if (provider.exists(cwd)) {
-      return provider;
-    }
-  }
-  const supported = DETECTION_TABLE.map((e) => e.file).join(", ");
-  throw new Error(
-    `No supported manifest file found in ${cwd}. Looked for: ${supported}. Set manifest.source explicitly in .versionguard.yml or create a supported manifest file.`
-  );
-}
-function detectManifests(cwd = process.cwd()) {
-  const detected = [];
-  for (const entry of DETECTION_TABLE) {
-    const provider = entry.factory();
-    if (provider.exists(cwd)) {
-      detected.push(entry.source);
-    }
-  }
-  return detected;
-}
-function getPackageJsonPath(cwd = process.cwd()) {
-  return path.join(cwd, "package.json");
-}
-function readPackageJson(cwd = process.cwd()) {
-  const packagePath = getPackageJsonPath(cwd);
-  if (!fs.existsSync(packagePath)) {
-    throw new Error(`package.json not found in ${cwd}`);
-  }
-  return JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-}
-function writePackageJson(pkg, cwd = process.cwd()) {
-  fs.writeFileSync(getPackageJsonPath(cwd), `${JSON.stringify(pkg, null, 2)}
-`, "utf-8");
-}
-function getPackageVersion(cwd = process.cwd(), manifest) {
-  if (manifest) {
-    const provider = resolveVersionSource(manifest, cwd);
-    return provider.getVersion(cwd);
-  }
-  const pkg = readPackageJson(cwd);
-  if (typeof pkg.version !== "string" || pkg.version.length === 0) {
-    throw new Error("No version field in package.json");
-  }
-  return pkg.version;
-}
-function setPackageVersion(version, cwd = process.cwd(), manifest) {
-  if (manifest) {
-    const provider = resolveVersionSource(manifest, cwd);
-    provider.setVersion(version, cwd);
-    return;
-  }
-  const pkg = readPackageJson(cwd);
-  pkg.version = version;
-  writePackageJson(pkg, cwd);
-}
-function getVersionSource(manifest, cwd = process.cwd()) {
-  return resolveVersionSource(manifest, cwd);
-}
-const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-function parse(version) {
-  const match = version.match(SEMVER_REGEX);
-  if (!match) {
-    return null;
-  }
-  return {
-    major: Number.parseInt(match[1], 10),
-    minor: Number.parseInt(match[2], 10),
-    patch: Number.parseInt(match[3], 10),
-    prerelease: match[4] ? match[4].split(".") : [],
-    build: match[5] ? match[5].split(".") : [],
-    raw: version
-  };
-}
-function getStructuralErrors(version) {
-  const errors = [];
-  if (version.startsWith("v")) {
-    errors.push({
-      message: `Version should not start with 'v': ${version}`,
-      severity: "error"
-    });
-    return errors;
-  }
-  const mainPart = version.split(/[+-]/, 1)[0];
-  const segments = mainPart.split(".");
-  if (segments.length === 3) {
-    const leadingZeroSegment = segments.find((segment) => /^0\d+$/.test(segment));
-    if (leadingZeroSegment) {
-      errors.push({
-        message: `Invalid SemVer: numeric segment "${leadingZeroSegment}" has a leading zero`,
-        severity: "error"
-      });
-      return errors;
-    }
-  }
-  const prerelease = version.match(/-([^+]+)/)?.[1];
-  if (prerelease) {
-    const invalidPrerelease = prerelease.split(".").find((segment) => /^0\d+$/.test(segment));
-    if (invalidPrerelease) {
-      errors.push({
-        message: `Invalid SemVer: prerelease identifier "${invalidPrerelease}" has a leading zero`,
-        severity: "error"
-      });
-      return errors;
-    }
-  }
-  errors.push({
-    message: `Invalid SemVer format: "${version}". Expected MAJOR.MINOR.PATCH[-prerelease][+build].`,
-    severity: "error"
-  });
-  return errors;
-}
-function validate$1(version, semverConfig, schemeRules) {
-  let input = version;
-  if (input.startsWith("v") || input.startsWith("V")) {
-    if (semverConfig?.allowVPrefix) {
-      input = input.slice(1);
-    }
-  }
-  const parsed = parse(input);
-  if (!parsed) {
-    return {
-      valid: false,
-      errors: getStructuralErrors(version)
-    };
-  }
-  const errors = [];
-  if (semverConfig && !semverConfig.allowBuildMetadata && parsed.build.length > 0) {
-    errors.push({
-      message: `Build metadata is not allowed: "${parsed.build.join(".")}"`,
-      severity: "error"
-    });
-  }
-  if (semverConfig?.requirePrerelease && parsed.prerelease.length === 0) {
-    errors.push({
-      message: "A prerelease label is required (e.g., 1.2.3-alpha.1)",
-      severity: "error"
-    });
-  }
-  if (parsed.prerelease.length > 0) {
-    const modifierError = validateModifier(parsed.prerelease[0], schemeRules);
-    if (modifierError) {
-      errors.push(modifierError);
-    }
-  }
-  return {
-    valid: errors.filter((e) => e.severity === "error").length === 0,
-    errors,
-    version: { type: "semver", version: parsed }
-  };
-}
-function compare(a, b) {
-  const left = parse(a);
-  const right = parse(b);
-  if (!left || !right) {
-    throw new Error(`Invalid SemVer comparison between "${a}" and "${b}"`);
-  }
-  for (const key of ["major", "minor", "patch"]) {
-    if (left[key] !== right[key]) {
-      return left[key] > right[key] ? 1 : -1;
-    }
-  }
-  const leftHasPrerelease = left.prerelease.length > 0;
-  const rightHasPrerelease = right.prerelease.length > 0;
-  if (leftHasPrerelease && !rightHasPrerelease) {
-    return -1;
-  }
-  if (!leftHasPrerelease && rightHasPrerelease) {
-    return 1;
-  }
-  const length = Math.max(left.prerelease.length, right.prerelease.length);
-  for (let index = 0; index < length; index += 1) {
-    const leftValue = left.prerelease[index];
-    const rightValue = right.prerelease[index];
-    if (leftValue === void 0) {
-      return -1;
-    }
-    if (rightValue === void 0) {
-      return 1;
-    }
-    const leftNumeric = /^\d+$/.test(leftValue) ? Number.parseInt(leftValue, 10) : null;
-    const rightNumeric = /^\d+$/.test(rightValue) ? Number.parseInt(rightValue, 10) : null;
-    if (leftNumeric !== null && rightNumeric !== null) {
-      if (leftNumeric !== rightNumeric) {
-        return leftNumeric > rightNumeric ? 1 : -1;
-      }
-      continue;
-    }
-    if (leftNumeric !== null) {
-      return -1;
-    }
-    if (rightNumeric !== null) {
-      return 1;
-    }
-    if (leftValue !== rightValue) {
-      return leftValue > rightValue ? 1 : -1;
-    }
-  }
-  return 0;
-}
-function gt(a, b) {
-  return compare(a, b) > 0;
-}
-function lt(a, b) {
-  return compare(a, b) < 0;
-}
-function eq(a, b) {
-  return compare(a, b) === 0;
-}
-function increment(version, release, prerelease) {
-  const parsed = parse(version);
-  if (!parsed) {
-    throw new Error(`Invalid SemVer version: ${version}`);
-  }
-  if (release === "major") {
-    return `${parsed.major + 1}.0.0${prerelease ? `-${prerelease}` : ""}`;
-  }
-  if (release === "minor") {
-    return `${parsed.major}.${parsed.minor + 1}.0${prerelease ? `-${prerelease}` : ""}`;
-  }
-  return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}${prerelease ? `-${prerelease}` : ""}`;
-}
-function format(version) {
-  let output = `${version.major}.${version.minor}.${version.patch}`;
-  if (version.prerelease.length > 0) {
-    output += `-${version.prerelease.join(".")}`;
-  }
-  if (version.build.length > 0) {
-    output += `+${version.build.join(".")}`;
-  }
-  return output;
-}
-const semver = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  compare,
-  eq,
-  format,
-  gt,
-  increment,
-  lt,
-  parse,
-  validate: validate$1
-}, Symbol.toStringTag, { value: "Module" }));
-function resolveFiles(patterns, cwd, ignore = []) {
-  return [
-    ...new Set(patterns.flatMap((pattern) => globSync(pattern, { cwd, absolute: true, ignore })))
-  ].sort();
-}
-function getLineNumber(content, offset) {
-  return content.slice(0, offset).split("\n").length;
-}
-function extractVersion(groups) {
-  return groups[1] ?? groups[0] ?? "";
-}
-function applyTemplate(template, groups, version) {
-  return template.replace(/\$(\d+)|\{\{version\}\}/g, (match, groupIndex) => {
-    if (match === "{{version}}") {
-      return version;
-    }
-    return groups[Number.parseInt(groupIndex ?? "0", 10) - 1] ?? "";
-  });
-}
-function stringifyCapture(value) {
-  return typeof value === "string" ? value : "";
-}
-function syncVersion(version, config, cwd = process.cwd()) {
-  return resolveFiles(config.files, cwd).map(
-    (filePath) => syncFile(filePath, version, config.patterns)
-  );
-}
-function syncFile(filePath, version, patterns) {
-  const original = fs.readFileSync(filePath, "utf-8");
-  let updatedContent = original;
-  const changes = [];
-  for (const pattern of patterns) {
-    const regex = new RegExp(pattern.regex, "gm");
-    updatedContent = updatedContent.replace(regex, (match, ...args) => {
-      const hasNamedGroups = typeof args.at(-1) === "object" && args.at(-1) !== null;
-      const offsetIndex = hasNamedGroups ? -3 : -2;
-      const offset = args.at(offsetIndex);
-      const groups = args.slice(0, offsetIndex).map((value) => stringifyCapture(value));
-      const found = extractVersion(groups);
-      if (found === "Unreleased") {
-        return match;
-      }
-      if (found !== version) {
-        changes.push({
-          line: getLineNumber(updatedContent, offset),
-          oldValue: found,
-          newValue: version
-        });
-      }
-      return applyTemplate(pattern.template, groups, version) || match;
-    });
-  }
-  const result = {
-    file: filePath,
-    updated: updatedContent !== original,
-    changes
-  };
-  if (result.updated) {
-    fs.writeFileSync(filePath, updatedContent, "utf-8");
-  }
-  return result;
-}
-function checkHardcodedVersions(expectedVersion, config, ignorePatterns, cwd = process.cwd()) {
-  const mismatches = [];
-  const files = resolveFiles(config.files, cwd, ignorePatterns);
-  for (const filePath of files) {
-    const content = fs.readFileSync(filePath, "utf-8");
-    for (const pattern of config.patterns) {
-      const regex = new RegExp(pattern.regex, "gm");
-      let match = regex.exec(content);
-      while (match) {
-        const found = extractVersion(match.slice(1));
-        if (found !== "Unreleased" && found !== expectedVersion) {
-          mismatches.push({
-            file: path.relative(cwd, filePath),
-            line: getLineNumber(content, match.index),
-            found
-          });
-        }
-        match = regex.exec(content);
-      }
-    }
-  }
-  return mismatches;
-}
-const DEFAULT_SEMVER_CONFIG = {
-  allowVPrefix: false,
-  allowBuildMetadata: true,
-  requirePrerelease: false
-};
-function getSemVerConfig(config) {
-  return { ...DEFAULT_SEMVER_CONFIG, ...config.versioning.semver };
-}
-function getCalVerConfig(config) {
-  if (!config.versioning.calver) {
-    throw new Error('CalVer configuration is required when versioning.type is "calver"');
-  }
-  return config.versioning.calver;
-}
-function deriveTopicSlug(conceptName) {
-  return conceptName.replace(/Config$/, "").replace(/Result$/, "").replace(/Options$/, "").toLowerCase();
-}
-function isTopicConcept(name) {
-  return name.endsWith("Config") && name !== "VersionGuardConfig";
-}
-function operationMatchesTopic(op, topicSlug, conceptNames) {
-  const haystack = `${op.name} ${op.what}`.toLowerCase();
-  if (haystack.includes(topicSlug)) return true;
-  return conceptNames.some((n) => haystack.includes(n.toLowerCase()));
-}
-function createCkmEngine(manifest) {
-  const topics = deriveTopics(manifest);
-  return {
-    topics,
-    getTopicIndex: (toolName = "tool") => formatTopicIndex(topics, toolName),
-    getTopicContent: (name) => formatTopicContent(topics, name),
-    getTopicJson: (name) => buildTopicJson(topics, manifest, name),
-    getManifest: () => manifest
-  };
-}
-function deriveTopics(manifest) {
-  const topics = [];
-  for (const concept of manifest.concepts) {
-    if (!isTopicConcept(concept.name)) continue;
-    const slug = deriveTopicSlug(concept.name);
-    const conceptNames = [concept.name];
-    const relatedConcepts = manifest.concepts.filter(
-      (c) => c.name !== concept.name && (c.name.toLowerCase().includes(slug) || slug.includes(deriveTopicSlug(c.name)))
-    );
-    conceptNames.push(...relatedConcepts.map((c) => c.name));
-    const operations = manifest.operations.filter(
-      (op) => operationMatchesTopic(op, slug, conceptNames)
-    );
-    const configSchema = manifest.configSchema.filter(
-      (c) => conceptNames.some((n) => c.key?.startsWith(n))
-    );
-    const constraints = manifest.constraints.filter(
-      (c) => conceptNames.some((n) => c.enforcedBy?.includes(n)) || operations.some((o) => c.enforcedBy?.includes(o.name))
-    );
-    topics.push({
-      name: slug,
-      summary: concept.what,
-      concepts: [concept, ...relatedConcepts],
-      operations,
-      configSchema,
-      constraints
-    });
-  }
-  return topics;
-}
-function formatTopicIndex(topics, toolName) {
-  const lines = [
-    `${toolName} CKM — Codebase Knowledge Manifest`,
-    "",
-    `Usage: ${toolName} ckm [topic] [--json] [--llm]`,
-    "",
-    "Topics:"
-  ];
-  const maxName = Math.max(...topics.map((t) => t.name.length));
-  for (const topic of topics) {
-    lines.push(`  ${topic.name.padEnd(maxName + 2)}${topic.summary}`);
-  }
-  lines.push("");
-  lines.push("Flags:");
-  lines.push("  --json    Machine-readable CKM output (concepts, operations, config schema)");
-  lines.push("  --llm     Full API context for LLM agents (forge-ts llms.txt)");
-  return lines.join("\n");
-}
-function formatTopicContent(topics, topicName) {
-  const topic = topics.find((t) => t.name === topicName);
-  if (!topic) return null;
-  const lines = [`# ${topic.summary}`, ""];
-  if (topic.concepts.length > 0) {
-    lines.push("## Concepts", "");
-    for (const c of topic.concepts) {
-      lines.push(`  ${c.name} — ${c.what}`);
-      if (c.properties) {
-        for (const p of c.properties) {
-          const def = findDefault(topic.configSchema, c.name, p.name);
-          lines.push(`    ${p.name}: ${p.type}${def ? ` = ${def}` : ""}`);
-          if (p.description) {
-            lines.push(`      ${p.description}`);
-          }
-        }
-      }
-      lines.push("");
-    }
-  }
-  if (topic.operations.length > 0) {
-    lines.push("## Operations", "");
-    for (const o of topic.operations) {
-      lines.push(`  ${o.name}() — ${o.what}`);
-      if (o.inputs) {
-        for (const i of o.inputs) {
-          lines.push(`    @param ${i.name}: ${i.description}`);
-        }
-      }
-      lines.push("");
-    }
-  }
-  if (topic.configSchema.length > 0) {
-    lines.push("## Config Fields", "");
-    for (const c of topic.configSchema) {
-      lines.push(`  ${c.key}: ${c.type}${c.default ? ` = ${c.default}` : ""}`);
-      if (c.description) {
-        lines.push(`    ${c.description}`);
-      }
-    }
-    lines.push("");
-  }
-  if (topic.constraints.length > 0) {
-    lines.push("## Constraints", "");
-    for (const c of topic.constraints) {
-      lines.push(`  [${c.id}] ${c.rule}`);
-      lines.push(`    Enforced by: ${c.enforcedBy}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function findDefault(schema, conceptName, propName) {
-  return schema.find((c) => c.key === `${conceptName}.${propName}`)?.default;
-}
-function buildTopicJson(topics, manifest, topicName) {
-  if (!topicName) {
-    return {
-      topics: topics.map((t) => ({
-        name: t.name,
-        summary: t.summary,
-        concepts: t.concepts.length,
-        operations: t.operations.length,
-        configFields: t.configSchema.length,
-        constraints: t.constraints.length
-      })),
-      ckm: {
-        concepts: manifest.concepts.length,
-        operations: manifest.operations.length,
-        constraints: manifest.constraints.length,
-        workflows: manifest.workflows.length,
-        configSchema: manifest.configSchema.length
-      }
-    };
-  }
-  const topic = topics.find((t) => t.name === topicName);
-  if (!topic) {
-    return { error: `Unknown topic: ${topicName}`, topics: topics.map((t) => t.name) };
-  }
-  return {
-    topic: topic.name,
-    summary: topic.summary,
-    concepts: topic.concepts,
-    operations: topic.operations,
-    configSchema: topic.configSchema,
-    constraints: topic.constraints
-  };
-}
-const CONFIG_FILE_NAMES = [
-  ".versionguard.yml",
-  ".versionguard.yaml",
-  "versionguard.yml",
-  "versionguard.yaml"
-];
-const DEFAULT_CONFIG = {
-  versioning: {
-    type: "semver",
-    schemeRules: {
-      maxNumericSegments: 3,
-      allowedModifiers: ["dev", "alpha", "beta", "rc"]
-    },
-    semver: {
-      allowVPrefix: false,
-      allowBuildMetadata: true,
-      requirePrerelease: false
-    },
-    calver: {
-      format: "YYYY.MM.PATCH",
-      preventFutureDates: true,
-      strictMutualExclusion: true
-    }
-  },
-  manifest: {
-    source: "auto"
-  },
-  sync: {
-    files: ["README.md", "CHANGELOG.md"],
-    patterns: [
-      {
-        regex: `(version\\s*[=:]\\s*["'])(.+?)(["'])`,
-        template: "$1{{version}}$3"
-      },
-      {
-        regex: "(##\\s*\\[)(.+?)(\\])",
-        template: "$1{{version}}$3"
-      }
-    ]
-  },
-  changelog: {
-    enabled: true,
-    file: "CHANGELOG.md",
-    strict: true,
-    requireEntry: true,
-    enforceStructure: false,
-    sections: ["Added", "Changed", "Deprecated", "Removed", "Fixed", "Security"]
-  },
-  git: {
-    hooks: {
-      "pre-commit": true,
-      "pre-push": true,
-      "post-tag": true
-    },
-    enforceHooks: true
-  },
-  ignore: ["node_modules/**", "dist/**", ".git/**", "*.lock", "package-lock.json"]
-};
-const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-function getDefaultConfig() {
-  return structuredClone(DEFAULT_CONFIG);
-}
-function findConfig(cwd = process.cwd()) {
-  for (const fileName of CONFIG_FILE_NAMES) {
-    const fullPath = path.join(cwd, fileName);
-    if (fs.existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
-}
-function loadConfig(configPath) {
-  const content = fs.readFileSync(configPath, "utf-8");
-  const parsed = yaml.load(content);
-  if (parsed === void 0) {
-    return getDefaultConfig();
-  }
-  if (!isPlainObject(parsed)) {
-    throw new Error(`Config file must contain a YAML object: ${configPath}`);
-  }
-  return mergeDeep(getDefaultConfig(), parsed);
-}
-function getConfig(cwd = process.cwd()) {
-  const configPath = findConfig(cwd);
-  return configPath ? loadConfig(configPath) : getDefaultConfig();
-}
-function initConfig(cwd = process.cwd()) {
-  const configPath = path.join(cwd, ".versionguard.yml");
-  const existingConfigPath = findConfig(cwd);
-  if (existingConfigPath) {
-    throw new Error(`Config file already exists: ${existingConfigPath}`);
-  }
-  const examplePath = path.join(MODULE_DIR, "..", ".versionguard.yml.example");
-  const content = fs.existsSync(examplePath) ? fs.readFileSync(examplePath, "utf-8") : generateDefaultConfig();
-  fs.writeFileSync(configPath, content, "utf-8");
-  return configPath;
-}
-function generateDefaultConfig() {
-  return `# VersionGuard Configuration
-# Change "type" to switch between semver and calver — both blocks are always present.
-versioning:
-  type: semver
-  semver:
-    allowVPrefix: false
-    allowBuildMetadata: true
-    requirePrerelease: false
-  calver:
-    format: "YYYY.MM.PATCH"
-    preventFutureDates: true
-
-sync:
-  files:
-    - "README.md"
-    - "CHANGELOG.md"
-  patterns:
-    - regex: '(version\\s*[=:]\\s*["''])(.+?)(["''])'
-      template: '$1{{version}}$3'
-    - regex: '(##\\s*\\[)(.+?)(\\])'
-      template: '$1{{version}}$3'
-
-changelog:
-  enabled: true
-  file: "CHANGELOG.md"
-  strict: true
-  requireEntry: true
-
-git:
-  hooks:
-    pre-commit: true
-    pre-push: true
-    post-tag: true
-  enforceHooks: true
-
-ignore:
-  - "node_modules/**"
-  - "dist/**"
-  - ".git/**"
-`;
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function mergeDeep(target, source) {
-  if (!isPlainObject(target) || !isPlainObject(source)) {
-    return source ?? target;
-  }
-  const output = { ...target };
-  for (const [key, value] of Object.entries(source)) {
-    const current = output[key];
-    output[key] = isPlainObject(current) && isPlainObject(value) ? mergeDeep(current, value) : value;
-  }
-  return output;
-}
-function getVersionFeedback(version, config, previousVersion) {
-  if (config.versioning.type === "semver") {
-    return getSemVerFeedback(version, previousVersion);
-  }
-  return getCalVerFeedback(version, getCalVerConfig(config), previousVersion);
-}
-function getSemVerFeedback(version, previousVersion) {
-  const errors = [];
-  const suggestions = [];
-  const parsed = parse(version);
-  if (!parsed) {
-    const validation = validate$1(version);
-    if (version.startsWith("v")) {
-      const cleanVersion = version.slice(1);
-      errors.push({
-        message: `Version should not start with 'v': ${version}`,
-        severity: "error"
-      });
-      suggestions.push({
-        message: `Remove the 'v' prefix`,
-        fix: `npx versionguard fix --version ${cleanVersion}`,
-        autoFixable: true
-      });
-    } else if (version.split(".").length === 2) {
-      errors.push({
-        message: `Version missing patch number: ${version}`,
-        severity: "error"
-      });
-      suggestions.push({
-        message: `Add patch number (e.g., ${version}.0)`,
-        fix: `npx versionguard fix --version ${version}.0`,
-        autoFixable: true
-      });
-    } else if (/^\d+\.\d+\.\d+\.\d+$/.test(version)) {
-      errors.push({
-        message: `Version has too many segments: ${version}`,
-        severity: "error"
-      });
-      suggestions.push({
-        message: `Use only 3 segments (MAJOR.MINOR.PATCH)`,
-        autoFixable: false
-      });
-    } else if (validation.errors.some((error) => error.message.includes("leading zero"))) {
-      errors.push(...validation.errors);
-      suggestions.push({
-        message: `Remove leading zeros (e.g., 1.2.3 instead of 01.02.03)`,
-        autoFixable: false
-      });
-    } else {
-      errors.push(
-        ...validation.errors.length > 0 ? validation.errors : [
-          {
-            message: `Invalid SemVer format: ${version}`,
-            severity: "error"
-          }
-        ]
-      );
-      suggestions.push({
-        message: `Use format: MAJOR.MINOR.PATCH (e.g., 1.0.0)`,
-        autoFixable: false
-      });
-    }
-    return {
-      valid: false,
-      errors,
-      suggestions,
-      canAutoFix: suggestions.some((s) => s.autoFixable)
-    };
-  }
-  if (previousVersion) {
-    const prevParsed = parse(previousVersion);
-    if (prevParsed) {
-      const comparison = compare(version, previousVersion);
-      if (comparison < 0) {
-        errors.push({
-          message: `Version ${version} is older than previous ${previousVersion}`,
-          severity: "error"
-        });
-        suggestions.push({
-          message: `Version must be greater than ${previousVersion}`,
-          fix: `npx versionguard fix --version ${increment(previousVersion, "patch")}`,
-          autoFixable: true
-        });
-      } else if (comparison === 0) {
-        errors.push({
-          message: `Version ${version} is the same as previous`,
-          severity: "error"
-        });
-        suggestions.push({
-          message: `Bump the version`,
-          fix: `npx versionguard fix --version ${increment(previousVersion, "patch")}`,
-          autoFixable: true
-        });
-      } else {
-        const majorJump = parsed.major - prevParsed.major;
-        const minorJump = parsed.minor - prevParsed.minor;
-        const patchJump = parsed.patch - prevParsed.patch;
-        if (majorJump > 1) {
-          suggestions.push({
-            message: `⚠️  Major version jumped by ${majorJump} (from ${previousVersion} to ${version})`,
-            autoFixable: false
-          });
-        }
-        if (minorJump > 10) {
-          suggestions.push({
-            message: `⚠️  Minor version jumped by ${minorJump} - did you mean to do a major bump?`,
-            autoFixable: false
-          });
-        }
-        if (patchJump > 20) {
-          suggestions.push({
-            message: `⚠️  Patch version jumped by ${patchJump} - consider a minor bump instead`,
-            autoFixable: false
-          });
-        }
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    suggestions,
-    canAutoFix: suggestions.some((s) => s.autoFixable)
-  };
-}
-function getCalVerFeedback(version, calverConfig, previousVersion) {
-  const errors = [];
-  const suggestions = [];
-  const { format: format2, preventFutureDates } = calverConfig;
-  const parsed = parse$1(version, format2);
-  if (!parsed) {
-    errors.push({
-      message: `Invalid CalVer format: ${version}`,
-      severity: "error"
-    });
-    suggestions.push({
-      message: `Expected format: ${format2}`,
-      fix: `Update version to current date: "${getCurrentVersion(format2)}"`,
-      autoFixable: true
-    });
-    return { valid: false, errors, suggestions, canAutoFix: true };
-  }
-  const validation = validate$2(version, format2, preventFutureDates);
-  errors.push(...validation.errors);
-  const now = /* @__PURE__ */ new Date();
-  if (validation.errors.some((error) => error.message.startsWith("Invalid month:"))) {
-    suggestions.push({
-      message: `Month must be between 1-12`,
-      autoFixable: false
-    });
-  }
-  if (validation.errors.some((error) => error.message.startsWith("Invalid day:"))) {
-    suggestions.push({
-      message: `Day must be valid for the selected month`,
-      autoFixable: false
-    });
-  }
-  if (preventFutureDates && parsed.year > now.getFullYear()) {
-    suggestions.push({
-      message: `Use current year (${now.getFullYear()}) or a past year`,
-      fix: `npx versionguard fix --version ${formatCalVerVersion({ ...parsed, year: now.getFullYear() })}`,
-      autoFixable: true
-    });
-  }
-  if (preventFutureDates && parsed.year === now.getFullYear() && parsed.month > now.getMonth() + 1) {
-    suggestions.push({
-      message: `Current month is ${now.getMonth() + 1}`,
-      fix: `npx versionguard fix --version ${formatCalVerVersion({ ...parsed, month: now.getMonth() + 1 })}`,
-      autoFixable: true
-    });
-  }
-  if (preventFutureDates && parsed.year === now.getFullYear() && parsed.month === now.getMonth() + 1 && parsed.day !== void 0 && parsed.day > now.getDate()) {
-    suggestions.push({
-      message: `Current day is ${now.getDate()}`,
-      fix: `npx versionguard fix --version ${formatCalVerVersion({ ...parsed, day: now.getDate() })}`,
-      autoFixable: true
-    });
-  }
-  if (previousVersion) {
-    const prevParsed = parse$1(previousVersion, format2);
-    if (prevParsed) {
-      if (compare$1(version, previousVersion, format2) <= 0) {
-        errors.push({
-          message: `Version ${version} is not newer than previous ${previousVersion}`,
-          severity: "error"
-        });
-        suggestions.push({
-          message: `CalVer must increase over time`,
-          fix: `npx versionguard fix --version ${increment$1(previousVersion, format2)}`,
-          autoFixable: true
-        });
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    suggestions,
-    canAutoFix: suggestions.some((s) => s.autoFixable)
-  };
-}
-function formatCalVerVersion(version) {
-  return format$1({
-    ...version,
-    raw: version.raw || ""
-  });
-}
-function getSyncFeedback(file, foundVersion, expectedVersion) {
-  const suggestions = [
-    {
-      message: `${file} has version "${foundVersion}" but should be "${expectedVersion}"`,
-      fix: `npx versionguard sync`,
-      autoFixable: true
-    }
-  ];
-  if (file.endsWith(".md")) {
-    suggestions.push({
-      message: `For markdown files, check headers like "## [${expectedVersion}]"`,
-      autoFixable: false
-    });
-  }
-  if (file.endsWith(".ts") || file.endsWith(".js")) {
-    suggestions.push({
-      message: `For code files, check constants like "export const VERSION = '${expectedVersion}'"`,
-      autoFixable: false
-    });
-  }
-  return suggestions;
-}
-function getChangelogFeedback(hasEntry, version, latestChangelogVersion) {
-  const suggestions = [];
-  if (!hasEntry) {
-    suggestions.push({
-      message: `CHANGELOG.md is missing entry for version ${version}`,
-      fix: `npx versionguard fix`,
-      autoFixable: true
-    });
-    suggestions.push({
-      message: `Or manually add: "## [${version}] - YYYY-MM-DD" under [Unreleased]`,
-      autoFixable: false
-    });
-  }
-  if (latestChangelogVersion && latestChangelogVersion !== version) {
-    suggestions.push({
-      message: `CHANGELOG.md latest entry is ${latestChangelogVersion}, but manifest version is ${version}`,
-      fix: `Make sure versions are in sync`,
-      autoFixable: false
-    });
-  }
-  return suggestions;
-}
-function getTagFeedback(tagVersion, packageVersion, hasUnsyncedFiles) {
-  const suggestions = [];
-  if (tagVersion !== packageVersion) {
-    suggestions.push({
-      message: `Git tag "${tagVersion}" doesn't match manifest version "${packageVersion}"`,
-      fix: `Delete tag and recreate: git tag -d ${tagVersion} && git tag ${packageVersion}`,
-      autoFixable: false
-    });
-  }
-  if (hasUnsyncedFiles) {
-    suggestions.push({
-      message: `Files are out of sync with version ${packageVersion}`,
-      fix: `npx versionguard sync`,
-      autoFixable: true
-    });
-  }
-  return suggestions;
-}
-function fixPackageVersion(targetVersion, cwd = process.cwd(), manifest) {
-  if (!manifest) {
-    const packagePath = path.join(cwd, "package.json");
-    if (!fs.existsSync(packagePath)) {
-      return { fixed: false, message: "package.json not found" };
-    }
-    const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    const oldVersion2 = typeof pkg.version === "string" ? pkg.version : void 0;
-    if (oldVersion2 === targetVersion) {
-      return { fixed: false, message: `Already at version ${targetVersion}` };
-    }
-    setPackageVersion(targetVersion, cwd);
-    return {
-      fixed: true,
-      message: `Updated package.json from ${oldVersion2} to ${targetVersion}`,
-      file: packagePath
-    };
-  }
-  const provider = getVersionSource(manifest, cwd);
-  let oldVersion;
-  try {
-    oldVersion = provider.getVersion(cwd);
-  } catch {
-    return { fixed: false, message: "Version source not found" };
-  }
-  if (oldVersion === targetVersion) {
-    return { fixed: false, message: `Already at version ${targetVersion}` };
-  }
-  provider.setVersion(targetVersion, cwd);
-  return {
-    fixed: true,
-    message: `Updated version from ${oldVersion} to ${targetVersion}`,
-    file: provider.manifestFile ? path.join(cwd, provider.manifestFile) : void 0
-  };
-}
-function fixSyncIssues(config, cwd = process.cwd()) {
-  const version = getPackageVersion(cwd, config.manifest);
-  const results = syncVersion(version, config.sync, cwd).filter((result) => result.updated).map((result) => ({
-    fixed: true,
-    message: `Updated ${path.relative(cwd, result.file)} (${result.changes.length} changes)`,
-    file: result.file
-  }));
-  if (results.length === 0) {
-    results.push({ fixed: false, message: "All files already in sync" });
-  }
-  return results;
-}
-function fixChangelog(version, config, cwd = process.cwd()) {
-  const changelogPath = path.join(cwd, config.changelog.file);
-  if (!fs.existsSync(changelogPath)) {
-    createInitialChangelog(changelogPath, version);
-    return {
-      fixed: true,
-      message: `Created ${config.changelog.file} with entry for ${version}`,
-      file: changelogPath
-    };
-  }
-  const content = fs.readFileSync(changelogPath, "utf-8");
-  if (content.includes(`## [${version}]`)) {
-    return { fixed: false, message: `Changelog already has entry for ${version}` };
-  }
-  addVersionEntry(changelogPath, version);
-  return {
-    fixed: true,
-    message: `Added entry for ${version} to ${config.changelog.file}`,
-    file: changelogPath
-  };
-}
-function createInitialChangelog(changelogPath, version) {
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const content = `# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-## [${version}] - ${today}
-
-### Added
-
-- Initial release
-
-[Unreleased]: https://github.com/yourorg/project/compare/v${version}...HEAD
-[${version}]: https://github.com/yourorg/project/releases/tag/v${version}
-`;
-  fs.writeFileSync(changelogPath, content, "utf-8");
-}
-function fixAll(config, targetVersion, cwd = process.cwd()) {
-  const results = [];
-  const version = targetVersion || getPackageVersion(cwd, config.manifest);
-  if (targetVersion && targetVersion !== getPackageVersion(cwd, config.manifest)) {
-    results.push(fixPackageVersion(targetVersion, cwd, config.manifest));
-  }
-  const syncResults = fixSyncIssues(config, cwd);
-  results.push(...syncResults);
-  if (config.changelog.enabled) {
-    const changelogPath = path.join(cwd, config.changelog.file);
-    if (isChangesetMangled(changelogPath)) {
-      const fixed = fixChangesetMangling(changelogPath);
-      if (fixed) {
-        results.push({
-          fixed: true,
-          message: `Restructured ${config.changelog.file} from Changesets format to Keep a Changelog`,
-          file: changelogPath
-        });
-      }
-    }
-    const changelogResult = fixChangelog(version, config, cwd);
-    if (changelogResult.fixed) {
-      results.push(changelogResult);
-    }
-  }
-  return results;
-}
-function suggestNextVersion(currentVersion, config, changeType) {
-  const suggestions = [];
-  if (config.versioning.type === "semver") {
-    if (!changeType || changeType === "auto" || changeType === "patch") {
-      suggestions.push({
-        version: increment(currentVersion, "patch"),
-        reason: "Patch - bug fixes, small changes"
-      });
-    }
-    if (!changeType || changeType === "auto" || changeType === "minor") {
-      suggestions.push({
-        version: increment(currentVersion, "minor"),
-        reason: "Minor - new features, backwards compatible"
-      });
-    }
-    if (!changeType || changeType === "auto" || changeType === "major") {
-      suggestions.push({
-        version: increment(currentVersion, "major"),
-        reason: "Major - breaking changes"
-      });
-    }
-  } else {
-    const format2 = getCalVerConfig(config).format;
-    const currentCal = getCurrentVersion(format2);
-    suggestions.push({
-      version: currentCal,
-      reason: "Current date - new release today"
-    });
-    suggestions.push({
-      version: increment$1(currentVersion, format2),
-      reason: "Increment patch - additional release today"
-    });
-  }
-  return suggestions;
-}
-const HOOK_NAMES = ["pre-commit", "pre-push", "post-tag"];
-function checkHooksPathOverride(cwd) {
-  try {
-    const hooksPath = execSync("git config core.hooksPath", {
-      cwd,
-      encoding: "utf-8"
-    }).trim();
-    if (hooksPath) {
-      const resolved = path.resolve(cwd, hooksPath);
-      const huskyDir = path.resolve(cwd, ".husky");
-      if (resolved === huskyDir || resolved.startsWith(`${huskyDir}${path.sep}`)) {
-        return {
-          code: "HOOKS_PATH_HUSKY",
-          severity: "warning",
-          message: `Husky detected — core.hooksPath is set to "${hooksPath}". Hooks in .git/hooks/ are bypassed. Add versionguard validate to your .husky/pre-commit manually or use a tool like forge-ts that manages .husky/ hooks cooperatively.`
-        };
-      }
-      return {
-        code: "HOOKS_PATH_OVERRIDE",
-        severity: "error",
-        message: `git core.hooksPath is set to "${hooksPath}" — hooks in .git/hooks/ are bypassed`,
-        fix: "git config --unset core.hooksPath"
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-function checkHuskyBypass() {
-  if (process.env.HUSKY === "0") {
-    return {
-      code: "HUSKY_BYPASS",
-      severity: "error",
-      message: "HUSKY=0 is set — git hooks are disabled via environment variable",
-      fix: "unset HUSKY"
-    };
-  }
-  return null;
-}
-function checkHookIntegrity(config, cwd) {
-  const warnings = [];
-  const gitDir = findGitDir(cwd);
-  if (!gitDir) {
-    return warnings;
-  }
-  const hooksDir = path.join(gitDir, "hooks");
-  for (const hookName of HOOK_NAMES) {
-    if (!config.git.hooks[hookName]) {
-      continue;
-    }
-    const hookPath = path.join(hooksDir, hookName);
-    if (!fs.existsSync(hookPath)) {
-      warnings.push({
-        code: "HOOK_MISSING",
-        severity: "error",
-        message: `Required hook "${hookName}" is not installed`,
-        fix: "npx versionguard hooks install"
-      });
-      continue;
-    }
-    const actual = fs.readFileSync(hookPath, "utf-8");
-    const expected = generateHookScript(hookName);
-    if (actual !== expected) {
-      if (!actual.includes("versionguard")) {
-        warnings.push({
-          code: "HOOK_REPLACED",
-          severity: "error",
-          message: `Hook "${hookName}" has been replaced — versionguard invocation is missing`,
-          fix: "npx versionguard hooks install"
-        });
-      } else {
-        warnings.push({
-          code: "HOOK_TAMPERED",
-          severity: "warning",
-          message: `Hook "${hookName}" has been modified from the expected template`,
-          fix: "npx versionguard hooks install"
-        });
-      }
-    }
-  }
-  return warnings;
-}
-function checkEnforceHooksPolicy(config) {
-  const anyHookEnabled = HOOK_NAMES.some((name) => config.git.hooks[name]);
-  if (anyHookEnabled && !config.git.enforceHooks) {
-    return {
-      code: "HOOKS_NOT_ENFORCED",
-      severity: "warning",
-      message: "Hooks are enabled but enforceHooks is false — missing hooks will not fail validation",
-      fix: "Set git.enforceHooks: true in .versionguard.yml"
-    };
-  }
-  return null;
-}
-function runGuardChecks(config, cwd) {
-  const warnings = [];
-  const hooksPathWarning = checkHooksPathOverride(cwd);
-  if (hooksPathWarning) {
-    warnings.push(hooksPathWarning);
-  }
-  const huskyWarning = checkHuskyBypass();
-  if (huskyWarning) {
-    warnings.push(huskyWarning);
-  }
-  const integrityWarnings = checkHookIntegrity(config, cwd);
-  warnings.push(...integrityWarnings);
-  const enforceWarning = checkEnforceHooksPolicy(config);
-  if (enforceWarning) {
-    warnings.push(enforceWarning);
-  }
-  const hasErrors = warnings.some((w) => w.severity === "error");
-  return {
-    safe: !hasErrors,
-    warnings
-  };
-}
-const PROJECT_MARKERS = [
-  ".versionguard.yml",
-  ".versionguard.yaml",
-  "versionguard.yml",
-  "versionguard.yaml",
-  ".git",
-  "package.json",
-  "Cargo.toml",
-  "pyproject.toml",
-  "pubspec.yaml",
-  "composer.json",
-  "pom.xml",
-  "go.mod",
-  "mix.exs",
-  "Gemfile",
-  ".csproj"
-];
-function findProjectRoot(startDir) {
-  let current = path.resolve(startDir);
-  while (true) {
-    for (const marker of PROJECT_MARKERS) {
-      if (marker.startsWith(".") && marker !== ".git" && !marker.startsWith(".version")) {
-        try {
-          const files = fs.readdirSync(current);
-          if (files.some((f) => f.endsWith(marker))) {
-            return buildResult(current, marker);
-          }
-        } catch {
-        }
-      } else if (fs.existsSync(path.join(current, marker))) {
-        return buildResult(current, marker);
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return {
-        found: false,
-        root: path.resolve(startDir),
-        hasConfig: false,
-        hasGit: false,
-        hasManifest: false
-      };
-    }
-    current = parent;
-  }
-}
-function buildResult(root, marker) {
-  const configNames = [
-    ".versionguard.yml",
-    ".versionguard.yaml",
-    "versionguard.yml",
-    "versionguard.yaml"
-  ];
-  return {
-    found: true,
-    root,
-    marker,
-    hasConfig: configNames.some((c) => fs.existsSync(path.join(root, c))),
-    hasGit: fs.existsSync(path.join(root, ".git")),
-    hasManifest: [
-      "package.json",
-      "Cargo.toml",
-      "pyproject.toml",
-      "pubspec.yaml",
-      "composer.json",
-      "pom.xml",
-      "VERSION"
-    ].some((m) => fs.existsSync(path.join(root, m)))
-  };
-}
-function formatNotProjectError(cwd, command) {
-  const dir = path.basename(cwd) || cwd;
-  const lines = [
-    `Not a VersionGuard project: ${dir}`,
-    "",
-    "No .versionguard.yml, .git directory, or manifest file found.",
-    "",
-    "To get started:",
-    "  versionguard init          Set up a new project interactively",
-    "  versionguard init --yes    Set up with defaults",
-    "",
-    "Or run from a project root directory:",
-    `  cd /path/to/project && versionguard ${command}`
-  ];
-  return lines.join("\n");
-}
-function runGit(cwd, args, encoding) {
-  return childProcess.execFileSync("git", args, {
-    cwd,
-    encoding,
-    stdio: ["pipe", "pipe", "ignore"]
-  });
-}
-function runGitText(cwd, args) {
-  return runGit(cwd, args, "utf-8");
-}
-function getLatestTag(cwd = process.cwd()) {
-  try {
-    const result = runGitText(cwd, ["describe", "--tags", "--abbrev=0"]);
-    const tagName = result.trim();
-    const version = tagName.replace(/^v/, "");
-    const dateResult = runGitText(cwd, ["log", "-1", "--format=%ai", tagName]);
-    const messageResult = runGitText(cwd, ["tag", "-l", tagName, "--format=%(contents)"]);
-    const message = messageResult.trim();
-    return {
-      name: tagName,
-      version,
-      message: message.length > 0 ? message : void 0,
-      date: new Date(dateResult.trim())
-    };
-  } catch {
-    return null;
-  }
-}
-function getAllTags(cwd = process.cwd()) {
-  try {
-    const result = runGitText(cwd, ["tag", "--list"]);
-    return result.trim().split("\n").filter(Boolean).map((name) => ({
-      name,
-      version: name.replace(/^v/, ""),
-      date: /* @__PURE__ */ new Date()
-      // Would need individual lookup for accurate dates
-    }));
-  } catch {
-    return [];
-  }
-}
-function createTag(version, message, autoFix = true, config, cwd = process.cwd()) {
-  const actions = [];
-  try {
-    if (!config) {
-      return {
-        success: false,
-        message: "VersionGuard config is required to create tags safely",
-        actions
-      };
-    }
-    const packageVersion = getPackageVersion(cwd, config.manifest);
-    const shouldAutoFix = autoFix;
-    const preflightError = getTagPreflightError(config, cwd, version, shouldAutoFix);
-    if (preflightError) {
-      return {
-        success: false,
-        message: preflightError,
-        actions
-      };
-    }
-    if (version !== packageVersion && !autoFix) {
-      return {
-        success: false,
-        message: `Version mismatch: manifest version is ${packageVersion}, tag is ${version}`,
-        actions: []
-      };
-    }
-    if (autoFix) {
-      const fixResults = version !== packageVersion ? fixAll(config, version, cwd) : fixAll(config, void 0, cwd);
-      for (const result of fixResults) {
-        if (result.fixed) {
-          actions.push(result.message);
-        }
-      }
-      if (fixResults.some((result) => result.fixed)) {
-        runGit(cwd, ["add", "-A"]);
-        runGit(cwd, ["commit", "--no-verify", "-m", `chore(release): ${version}`]);
-        actions.push("Committed version changes");
-      }
-    }
-    const tagName = `v${version}`;
-    const tagMessage = message || `Release ${version}`;
-    if (getAllTags(cwd).some((tag) => tag.name === tagName)) {
-      return {
-        success: false,
-        message: `Tag ${tagName} already exists`,
-        actions
-      };
-    }
-    runGit(cwd, ["tag", "-a", tagName, "-m", tagMessage]);
-    actions.push(`Created tag ${tagName}`);
-    return {
-      success: true,
-      message: `Successfully created tag ${tagName}`,
-      actions
-    };
-  } catch (err) {
-    return {
-      success: false,
-      message: `Failed to create tag: ${err.message}`,
-      actions
-    };
-  }
-}
-function handlePostTag(config, cwd = process.cwd()) {
-  const actions = [];
-  try {
-    const preflightError = getTagPreflightError(config, cwd);
-    if (preflightError) {
-      return {
-        success: false,
-        message: preflightError,
-        actions
-      };
-    }
-    const tag = getLatestTag(cwd);
-    if (!tag) {
-      return {
-        success: false,
-        message: "No tag found",
-        actions
-      };
-    }
-    const packageVersion = getPackageVersion(cwd, config.manifest);
-    if (tag.version !== packageVersion) {
-      return {
-        success: false,
-        message: `Tag version ${tag.version} doesn't match manifest version ${packageVersion}`,
-        actions: [
-          "To fix: delete tag and recreate with correct version",
-          `  git tag -d ${tag.name}`,
-          `  Update manifest to ${tag.version}`,
-          `  git tag ${tag.name}`
-        ]
-      };
-    }
-    const syncResults = fixAll(config, packageVersion, cwd);
-    for (const result of syncResults) {
-      if (result.fixed) {
-        actions.push(result.message);
-      }
-    }
-    return {
-      success: true,
-      message: `Post-tag workflow completed for ${tag.name}`,
-      actions
-    };
-  } catch (err) {
-    return {
-      success: false,
-      message: `Post-tag workflow failed: ${err.message}`,
-      actions
-    };
-  }
-}
-function getTagPreflightError(config, cwd, expectedVersion, allowAutoFix = false) {
-  if (config.git.enforceHooks && !areHooksInstalled(cwd)) {
-    return "Git hooks must be installed before creating or validating release tags";
-  }
-  if (hasDirtyWorktree(cwd)) {
-    return "Working tree must be clean before creating or validating release tags";
-  }
-  const version = expectedVersion ?? getPackageVersion(cwd, config.manifest);
-  const versionResult = config.versioning.type === "semver" ? validate$1(version, getSemVerConfig(config), config.versioning.schemeRules) : validate$2(
-    version,
-    config.versioning.calver?.format ?? "YYYY.MM.PATCH",
-    config.versioning.calver?.preventFutureDates ?? true,
-    config.versioning.schemeRules
-  );
-  if (!versionResult.valid) {
-    return versionResult.errors[0]?.message ?? `Invalid version: ${version}`;
-  }
-  if (allowAutoFix) {
-    return null;
-  }
-  const mismatches = checkHardcodedVersions(version, config.sync, config.ignore, cwd);
-  if (mismatches.length > 0) {
-    const mismatch = mismatches[0];
-    return `Version mismatch in ${mismatch.file}:${mismatch.line} - found "${mismatch.found}" but expected "${version}"`;
-  }
-  const changelogResult = validateChangelog(
-    path.join(cwd, config.changelog.file),
-    version,
-    config.changelog.strict,
-    config.changelog.requireEntry,
-    {
-      enforceStructure: config.changelog.enforceStructure,
-      sections: config.changelog.sections
-    }
-  );
-  if (!changelogResult.valid) {
-    return changelogResult.errors[0] ?? "Changelog validation failed";
-  }
-  return null;
-}
-function hasDirtyWorktree(cwd) {
-  try {
-    return runGitText(cwd, ["status", "--porcelain"]).trim().length > 0;
-  } catch {
-    return true;
-  }
-}
-function validateTagForPush(tagName, cwd = process.cwd()) {
-  try {
-    runGit(cwd, ["rev-parse", tagName]);
-    try {
-      runGit(cwd, ["ls-remote", "--tags", "origin", tagName]);
-      const localHash = runGitText(cwd, ["rev-parse", tagName]).trim();
-      const remoteOutput = runGitText(cwd, ["ls-remote", "--tags", "origin", tagName]).trim();
-      if (remoteOutput && !remoteOutput.includes(localHash)) {
-        return {
-          valid: false,
-          message: `Tag ${tagName} exists on remote with different commit`,
-          fix: `Delete remote tag first: git push origin :refs/tags/${tagName}`
-        };
-      }
-    } catch {
-      return { valid: true, message: `Tag ${tagName} is valid for push` };
-    }
-    return { valid: true, message: `Tag ${tagName} is valid for push` };
-  } catch {
-    return {
-      valid: false,
-      message: `Tag ${tagName} not found locally`,
-      fix: `Create tag: git tag ${tagName}`
-    };
-  }
-}
-function suggestTagMessage(version, cwd = process.cwd()) {
-  try {
-    const changelogPath = path.join(cwd, "CHANGELOG.md");
-    if (fs.existsSync(changelogPath)) {
-      const content = fs.readFileSync(changelogPath, "utf-8");
-      const versionRegex = new RegExp(
-        `## \\[${version}\\].*?\\n(.*?)(?=\\n## \\[|\\n\\n## |$)`,
-        "s"
-      );
-      const match = content.match(versionRegex);
-      if (match) {
-        const bulletMatch = match[1].match(/- (.+)/);
-        if (bulletMatch) {
-          return `Release ${version}: ${bulletMatch[1].trim()}`;
-        }
-      }
-    }
-  } catch {
-    return `Release ${version}`;
-  }
-  return `Release ${version}`;
-}
-function validateVersion(version, config) {
-  if (config.versioning.type === "semver") {
-    return validate$1(version, getSemVerConfig(config), config.versioning.schemeRules);
-  }
-  const calverConfig = getCalVerConfig(config);
-  return validate$2(
-    version,
-    calverConfig.format,
-    calverConfig.preventFutureDates,
-    config.versioning.schemeRules
-  );
-}
-function validate(config, cwd = process.cwd()) {
-  const errors = [];
-  let version;
-  try {
-    version = getPackageVersion(cwd, config.manifest);
-  } catch (err) {
-    return {
-      valid: false,
-      version: "",
-      versionValid: false,
-      syncValid: false,
-      changelogValid: false,
-      errors: [err.message]
-    };
-  }
-  const versionResult = validateVersion(version, config);
-  if (!versionResult.valid) {
-    errors.push(...versionResult.errors.map((error) => error.message));
-  }
-  const hardcoded = checkHardcodedVersions(version, config.sync, config.ignore, cwd);
-  if (hardcoded.length > 0) {
-    for (const mismatch of hardcoded) {
-      errors.push(
-        `Version mismatch in ${mismatch.file}:${mismatch.line} - found "${mismatch.found}" but expected "${version}"`
-      );
-    }
-  }
-  let changelogValid = true;
-  if (config.changelog.enabled) {
-    const changelogPath = path.join(cwd, config.changelog.file);
-    const changelogResult = validateChangelog(
-      changelogPath,
-      version,
-      config.changelog.strict,
-      config.changelog.requireEntry,
-      {
-        enforceStructure: config.changelog.enforceStructure,
-        sections: config.changelog.sections
-      }
-    );
-    if (!changelogResult.valid) {
-      changelogValid = false;
-      errors.push(...changelogResult.errors);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    version,
-    versionValid: versionResult.valid,
-    syncValid: hardcoded.length === 0,
-    changelogValid,
-    errors
-  };
-}
-function doctor(config, cwd = process.cwd()) {
-  const validation = validate(config, cwd);
-  const gitRepository = findGitDir(cwd) !== null;
-  const hooksInstalled = gitRepository ? areHooksInstalled(cwd) : false;
-  const worktreeClean = gitRepository ? isWorktreeClean(cwd) : true;
-  const errors = [...validation.errors];
-  if (gitRepository && config.git.enforceHooks && !hooksInstalled) {
-    errors.push("Git hooks are not installed");
-  }
-  if (gitRepository && !worktreeClean) {
-    errors.push("Working tree is not clean");
-  }
-  return {
-    ready: errors.length === 0,
-    version: validation.version,
-    versionValid: validation.versionValid,
-    syncValid: validation.syncValid,
-    changelogValid: validation.changelogValid,
-    gitRepository,
-    hooksInstalled,
-    worktreeClean,
-    errors
-  };
-}
-function sync(config, cwd = process.cwd()) {
-  const version = getPackageVersion(cwd, config.manifest);
-  syncVersion(version, config.sync, cwd);
-}
-function canBump(currentVersion, newVersion, config) {
-  const currentValid = validateVersion(currentVersion, config);
-  const newValid = validateVersion(newVersion, config);
-  if (!currentValid.valid) {
-    return { canBump: false, error: `Current version is invalid: ${currentVersion}` };
-  }
-  if (!newValid.valid) {
-    return { canBump: false, error: `New version is invalid: ${newVersion}` };
-  }
-  if (config.versioning.type === "semver") {
-    if (!gt(newVersion, currentVersion)) {
-      return {
-        canBump: false,
-        error: `New version ${newVersion} must be greater than current ${currentVersion}`
-      };
-    }
-  } else {
-    const calverConfig = getCalVerConfig(config);
-    const currentParsed = parse$1(currentVersion, calverConfig.format);
-    const newParsed = parse$1(newVersion, calverConfig.format);
-    if (!currentParsed || !newParsed) {
-      return { canBump: false, error: "Failed to parse CalVer versions" };
-    }
-    if (compare$1(newVersion, currentVersion, calverConfig.format) <= 0) {
-      return {
-        canBump: false,
-        error: `New CalVer ${newVersion} must be newer than current ${currentVersion}`
-      };
-    }
-  }
-  return { canBump: true };
-}
-function isWorktreeClean(cwd) {
-  try {
-    return execSync("git status --porcelain", { cwd, encoding: "utf-8" }).trim().length === 0;
-  } catch {
-    return false;
-  }
-}
-export {
-  validateVersion as $,
-  checkHardcodedVersions as A,
-  checkHookIntegrity as B,
-  checkHooksPathOverride as C,
-  checkHuskyBypass as D,
-  detectManifests as E,
-  fixChangelog as F,
-  GitTagSource as G,
-  fixPackageVersion as H,
-  getAllTags as I,
-  JsonVersionSource as J,
-  getCalVerConfig as K,
-  getLatestTag as L,
-  getSemVerConfig as M,
-  getTagFeedback as N,
-  getVersionSource as O,
-  initConfig as P,
-  resolveVersionSource as Q,
-  RegexVersionSource as R,
-  semver as S,
-  TomlVersionSource as T,
-  suggestTagMessage as U,
-  VersionFileSource as V,
-  sync as W,
-  syncVersion as X,
-  YamlVersionSource as Y,
-  validateChangelog as Z,
-  validateTagForPush as _,
-  installHooks as a,
-  getPackageVersion as b,
-  createCkmEngine as c,
-  getVersionFeedback as d,
-  getSyncFeedback as e,
-  getChangelogFeedback as f,
-  getConfig as g,
-  handlePostTag as h,
-  isValidCalVerFormat as i,
-  doctor as j,
-  fixAll as k,
-  isChangesetMangled as l,
-  fixChangesetMangling as m,
-  fixSyncIssues as n,
-  setPackageVersion as o,
-  createTag as p,
-  areHooksInstalled as q,
-  runGuardChecks as r,
-  suggestNextVersion as s,
-  findProjectRoot as t,
-  uninstallHooks as u,
-  validate as v,
-  formatNotProjectError as w,
-  calver as x,
-  canBump as y,
-  checkEnforceHooksPolicy as z
-};
-//# sourceMappingURL=index-DWiw8Nps.js.map