@codluv/versionguard 0.1.0

package/dist/chunks/index-DPBYoIRi.js

@@ -0,0 +1,1568 @@
+import * as childProcess from "node:child_process";
+import { execSync } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { globSync } from "glob";
+import { fileURLToPath } from "node:url";
+import * as yaml from "js-yaml";
+function parseFormat(calverFormat) {
+  const parts = calverFormat.split(".");
+  const result = {
+    year: parts[0],
+    month: parts[1]
+  };
+  if (parts[2] === "PATCH") {
+    result.patch = "PATCH";
+  } else if (parts[2]) {
+    result.day = parts[2];
+  }
+  if (parts[3] === "PATCH") {
+    result.patch = "PATCH";
+  }
+  return result;
+}
+function tokenPattern(token) {
+  switch (token) {
+    case "YYYY":
+      return "(\\d{4})";
+    case "YY":
+      return "(\\d{2})";
+    case "0M":
+    case "0D":
+      return "(\\d{2})";
+    case "MM":
+    case "DD":
+    case "M":
+    case "D":
+      return "(\\d{1,2})";
+    case "PATCH":
+      return "(\\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}$`);
+}
+function parse$1(version, calverFormat) {
+  const match = version.match(getRegexForFormat(calverFormat));
+  if (!match) {
+    return null;
+  }
+  const definition = parseFormat(calverFormat);
+  const year = definition.year === "YYYY" ? Number.parseInt(match[1], 10) : 2e3 + Number.parseInt(match[1], 10);
+  const month = Number.parseInt(match[2], 10);
+  let cursor = 3;
+  let day;
+  let patch;
+  if (definition.day) {
+    day = Number.parseInt(match[cursor], 10);
+    cursor += 1;
+  }
+  if (definition.patch) {
+    patch = Number.parseInt(match[cursor], 10);
+  }
+  return {
+    year,
+    month,
+    day,
+    patch,
+    format: calverFormat,
+    raw: version
+  };
+}
+function validate$2(version, calverFormat, preventFutureDates = true) {
+  const errors = [];
+  const parsed = parse$1(version, calverFormat);
+  if (!parsed) {
+    return {
+      valid: false,
+      errors: [
+        {
+          message: `Invalid CalVer format: "${version}". Expected format: ${calverFormat}`,
+          severity: "error"
+        }
+      ]
+    };
+  }
+  if (parsed.month < 1 || parsed.month > 12) {
+    errors.push({
+      message: `Invalid month: ${parsed.month}. Must be between 1 and 12.`,
+      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 {
+      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 (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 (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"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    version: { type: "calver", version: parsed }
+  };
+}
+function formatToken(token, value) {
+  if (token === "0M" || token === "0D") {
+    return String(value).padStart(2, "0");
+  }
+  if (token === "YY") {
+    return String(value % 100).padStart(2, "0");
+  }
+  return String(value);
+}
+function format$1(version) {
+  const tokens = version.format.split(".");
+  const values = [version.year, version.month];
+  if (tokens.includes("DD") || tokens.includes("D") || tokens.includes("0D")) {
+    values.push(version.day ?? 1);
+  }
+  if (tokens.includes("PATCH")) {
+    values.push(version.patch ?? 0);
+  }
+  return tokens.map((token, index) => formatToken(token, values[index])).join(".");
+}
+function getCurrentVersion(calverFormat, now = /* @__PURE__ */ new Date()) {
+  const definition = parseFormat(calverFormat);
+  const currentDay = now.getDate();
+  const base = {
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    day: definition.day ? currentDay : void 0,
+    patch: definition.patch ? 0 : void 0
+  };
+  const day = base.day ?? currentDay;
+  const patch = base.patch ?? 0;
+  return formatToken(definition.year, base.year).concat(`.${formatToken(definition.month, base.month)}`).concat(definition.day ? `.${formatToken(definition.day, day)}` : "").concat(definition.patch ? `.${patch}` : "");
+}
+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.patch) {
+    const patch = parsed.patch ?? 0;
+    next.patch = patch + 1;
+  } else {
+    next.patch = 0;
+    next.format = `${calverFormat}.PATCH`;
+  }
+  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,
+  parse: parse$1,
+  parseFormat,
+  validate: validate$2
+}, Symbol.toStringTag, { value: "Module" }));
+const CHANGELOG_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+function validateChangelog(changelogPath, version, strict = true, requireEntry = true) {
+  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(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`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    hasEntryForVersion
+  };
+}
+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 escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const HOOK_NAMES = ["pre-commit", "pre-push", "post-tag"];
+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) {
+    if (config.hooks[hookName]) {
+      const hookPath = path.join(hooksDir, hookName);
+      fs.writeFileSync(hookPath, generateHookScript(hookName), { 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) {
+    const hookPath = path.join(hooksDir, hookName);
+    if (fs.existsSync(hookPath) && fs.readFileSync(hookPath, "utf-8").includes("versionguard")) {
+      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.every((hookName) => {
+    const hookPath = path.join(gitDir, "hooks", hookName);
+    return fs.existsSync(hookPath) && fs.readFileSync(hookPath, "utf-8").includes("versionguard");
+  });
+}
+function generateHookScript(hookName) {
+  return `#!/bin/sh
+# VersionGuard ${hookName} hook
+npx versionguard validate --hook=${hookName}
+status=$?
+if [ $status -ne 0 ]; then
+  echo "VersionGuard validation failed."
+  exit $status
+fi
+`;
+}
+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()) {
+  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()) {
+  const pkg = readPackageJson(cwd);
+  pkg.version = version;
+  writePackageJson(pkg, 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) {
+  const parsed = parse(version);
+  if (!parsed) {
+    return {
+      valid: false,
+      errors: getStructuralErrors(version)
+    };
+  }
+  return {
+    valid: true,
+    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 CONFIG_FILE_NAMES = [
+  ".versionguard.yml",
+  ".versionguard.yaml",
+  "versionguard.yml",
+  "versionguard.yaml"
+];
+const DEFAULT_CONFIG = {
+  versioning: {
+    type: "semver",
+    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/**", "*.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
+versioning:
+  type: semver
+
+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$2(config), previousVersion);
+}
+function getCalVerConfig$2(config) {
+  if (!config.versioning.calver) {
+    throw new Error('CalVer configuration is required when versioning.type is "calver"');
+  }
+  return config.versioning.calver;
+}
+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: `npm 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: `npm 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: `npm 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: `npm 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 package.json to use 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: `npm 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: `npm 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: `npm 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: `npm 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 package.json 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 package.json "${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()) {
+  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 oldVersion = typeof pkg.version === "string" ? pkg.version : void 0;
+  if (oldVersion === targetVersion) {
+    return { fixed: false, message: `Already at version ${targetVersion}` };
+  }
+  setPackageVersion(targetVersion, cwd);
+  return {
+    fixed: true,
+    message: `Updated package.json from ${oldVersion} to ${targetVersion}`,
+    file: packagePath
+  };
+}
+function fixSyncIssues(config, cwd = process.cwd()) {
+  const version = getPackageVersion(cwd);
+  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);
+  if (targetVersion && targetVersion !== getPackageVersion(cwd)) {
+    results.push(fixPackageVersion(targetVersion, cwd));
+  }
+  const syncResults = fixSyncIssues(config, cwd);
+  results.push(...syncResults);
+  if (config.changelog.enabled) {
+    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$1(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;
+}
+function getCalVerConfig$1(config) {
+  if (!config.versioning.calver) {
+    throw new Error('CalVer configuration is required when versioning.type is "calver"');
+  }
+  return config.versioning.calver;
+}
+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);
+    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: package.json 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);
+    if (tag.version !== packageVersion) {
+      return {
+        success: false,
+        message: `Tag version ${tag.version} doesn't match package.json ${packageVersion}`,
+        actions: [
+          "To fix: delete tag and recreate with correct version",
+          `  git tag -d ${tag.name}`,
+          `  npm version ${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);
+  const versionResult = config.versioning.type === "semver" ? validate$1(version) : validate$2(
+    version,
+    config.versioning.calver?.format ?? "YYYY.MM.PATCH",
+    config.versioning.calver?.preventFutureDates ?? true
+  );
+  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
+  );
+  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);
+  }
+  const calverConfig = getCalVerConfig(config);
+  return validate$2(version, calverConfig.format, calverConfig.preventFutureDates);
+}
+function validate(config, cwd = process.cwd()) {
+  const errors = [];
+  let version;
+  try {
+    version = getPackageVersion(cwd);
+  } 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
+    );
+    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);
+  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 getCalVerConfig(config) {
+  if (!config.versioning.calver) {
+    throw new Error('CalVer configuration is required when versioning.type is "calver"');
+  }
+  return config.versioning.calver;
+}
+function isWorktreeClean(cwd) {
+  try {
+    return execSync("git status --porcelain", { cwd, encoding: "utf-8" }).trim().length === 0;
+  } catch {
+    return false;
+  }
+}
+export {
+  suggestTagMessage as A,
+  sync as B,
+  syncVersion as C,
+  validateChangelog as D,
+  validateTagForPush as E,
+  validateVersion as F,
+  getPackageVersion as a,
+  getVersionFeedback as b,
+  getSyncFeedback as c,
+  getChangelogFeedback as d,
+  doctor as e,
+  fixAll as f,
+  getConfig as g,
+  handlePostTag as h,
+  initConfig as i,
+  fixSyncIssues as j,
+  setPackageVersion as k,
+  createTag as l,
+  installHooks as m,
+  areHooksInstalled as n,
+  calver as o,
+  canBump as p,
+  checkHardcodedVersions as q,
+  fixChangelog as r,
+  suggestNextVersion as s,
+  fixPackageVersion as t,
+  uninstallHooks as u,
+  validate as v,
+  getAllTags as w,
+  getLatestTag as x,
+  getTagFeedback as y,
+  semver as z
+};
+//# sourceMappingURL=index-DPBYoIRi.js.map