@codluv/versionguard 0.2.0 → 0.4.0

package/dist/chunks/{index-BwE_OaV3.js → index-B3R60bYJ.js}

@@ -1,42 +1,88 @@
 import * as childProcess from "node:child_process";
-import { execSync } 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";
-import * as yaml from "js-yaml";
+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 parts = calverFormat.split(".");
+  const tokens = calverFormat.split(".");
   const result = {
-    year: parts[0],
-    month: parts[1]
+    year: tokens[0]
   };
-  if (parts[2] === "PATCH") {
-    result.patch = "PATCH";
-  } else if (parts[2]) {
-    result.day = parts[2];
-  }
-  if (parts[3] === "PATCH") {
-    result.patch = "PATCH";
+  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 "(\\d{4})";
+      return "([1-9]\\d{3})";
     case "YY":
-      return "(\\d{2})";
-    case "0M":
-    case "0D":
-      return "(\\d{2})";
+      return "(\\d{1,3})";
+    case "0Y":
+      return "(\\d{2,3})";
     case "MM":
-    case "DD":
     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 "(\\d{1,2})";
+      return "([1-9]|[12]\\d|3[01])";
+    case "0D":
+      return "(0[1-9]|[12]\\d|3[01])";
+    case "MICRO":
     case "PATCH":
-      return "(\\d+)";
+      return "(0|[1-9]\\d*)";
     default:
       throw new Error(`Unsupported CalVer token: ${token}`);
   }
@@ -44,7 +90,7 @@ function tokenPattern(token) {
 function getRegexForFormat(calverFormat) {
   const tokens = calverFormat.split(".");
   const pattern = tokens.map(tokenPattern).join("\\.");
-  return new RegExp(`^${pattern}$`);
+  return new RegExp(`^${pattern}${MODIFIER_PATTERN}$`);
 }
 function parse$1(version, calverFormat) {
   const match = version.match(getRegexForFormat(calverFormat));
@@ -52,28 +98,44 @@ function parse$1(version, calverFormat) {
     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;
+  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.patch) {
+  if (definition.counter) {
     patch = Number.parseInt(match[cursor], 10);
+    cursor += 1;
   }
+  const modifierGroup = match[cursor];
+  const modifier = modifierGroup || void 0;
   return {
     year,
-    month,
+    month: month ?? 1,
     day,
     patch,
+    modifier,
     format: calverFormat,
     raw: version
   };
 }
-function validate$2(version, calverFormat, preventFutureDates = true) {
+function validate$2(version, calverFormat, preventFutureDates = true, schemeRules) {
   const errors = [];
   const parsed = parse$1(version, calverFormat);
   if (!parsed) {
@@ -87,19 +149,26 @@ function validate$2(version, calverFormat, preventFutureDates = true) {
       ]
     };
   }
-  if (parsed.month < 1 || parsed.month > 12) {
+  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 {
+    } else if (definition.month) {
       const daysInMonth = new Date(parsed.year, parsed.month, 0).getDate();
       if (parsed.day > daysInMonth) {
         errors.push({
@@ -119,56 +188,83 @@ function validate$2(version, calverFormat, preventFutureDates = true) {
         message: `Future year not allowed: ${parsed.year}. Current year is ${currentYear}.`,
         severity: "error"
       });
-    } else if (parsed.year === currentYear && parsed.month > currentMonth) {
+    } 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 (parsed.year === currentYear && parsed.month === currentMonth && parsed.day !== void 0 && parsed.day > currentDay) {
+    } 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 && schemeRules?.allowedModifiers) {
+    const baseModifier = parsed.modifier.replace(/[\d.]+$/, "") || parsed.modifier;
+    if (!schemeRules.allowedModifiers.includes(baseModifier)) {
+      errors.push({
+        message: `Modifier "${parsed.modifier}" is not allowed. Allowed: ${schemeRules.allowedModifiers.join(", ")}`,
+        severity: "error"
+      });
+    }
+  }
+  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.length === 0,
+    valid: errors.filter((e) => e.severity === "error").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");
+  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);
   }
-  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);
+  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 (tokens.includes("PATCH")) {
-    values.push(version.patch ?? 0);
+  if (definition.day) {
+    parts.push(formatToken(definition.day, version.day ?? 1));
+  }
+  if (definition.counter) {
+    parts.push(formatToken(definition.counter, version.patch ?? 0));
   }
-  return tokens.map((token, index) => formatToken(token, values[index])).join(".");
+  const base = parts.join(".");
+  return version.modifier ? `${base}-${version.modifier}` : base;
 }
 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
+    day: definition.day ? now.getDate() : void 0,
+    patch: definition.counter ? 0 : void 0,
+    format: calverFormat
   };
-  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}` : "");
+  return format$1(base);
 }
 function compare$1(a, b, calverFormat) {
   const left = parse$1(a, calverFormat);
@@ -194,12 +290,11 @@ function increment$1(version, calverFormat) {
   const next = {
     ...parsed
   };
-  if (definition.patch) {
-    const patch = parsed.patch ?? 0;
-    next.patch = patch + 1;
+  if (definition.counter) {
+    next.patch = (parsed.patch ?? 0) + 1;
   } else {
     next.patch = 0;
-    next.format = `${calverFormat}.PATCH`;
+    next.format = `${calverFormat}.MICRO`;
   }
   return format$1(next);
 }
@@ -214,6 +309,7 @@ const calver = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   getNextVersions,
   getRegexForFormat,
   increment: increment$1,
+  isValidCalVerFormat,
   parse: parse$1,
   parseFormat,
   validate: validate$2
@@ -245,7 +341,7 @@ function validateChangelog(changelogPath, version, strict = true, requireEntry =
       errors.push("Changelog should include compare links at the bottom");
     }
     const versionHeaderMatch = content.match(
-      new RegExp(`## \\[${escapeRegExp(version)}\\] - ([^\r
+      new RegExp(`## \\[${escapeRegExp$1(version)}\\] - ([^\r
 ]+)`)
     );
     if (requireEntry && hasEntryForVersion) {
@@ -285,7 +381,7 @@ function addVersionEntry(changelogPath, version, date = (/* @__PURE__ */ new Dat
   const updated = `${content.slice(0, insertIndex)}${block}${content.slice(insertIndex)}`;
   fs.writeFileSync(changelogPath, updated, "utf-8");
 }
-function escapeRegExp(value) {
+function escapeRegExp$1(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 const HOOK_NAMES$1 = ["pre-commit", "pre-push", "post-tag"];
@@ -342,6 +438,7 @@ function areHooksInstalled(cwd = process.cwd()) {
 }
 function generateHookScript(hookName) {
   return `#!/bin/sh
+# versionguard
 # VersionGuard ${hookName} hook
 # --no-install prevents accidentally downloading an unscoped package
 # if @codluv/versionguard is not installed locally
@@ -353,6 +450,632 @@ if [ $status -ne 0 ]; then
 fi
 `;
 }
+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");
 }
@@ -367,18 +1090,30 @@ function writePackageJson(pkg, cwd = process.cwd()) {
   fs.writeFileSync(getPackageJsonPath(cwd), `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
 }
-function getPackageVersion(cwd = process.cwd()) {
+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()) {
+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);
@@ -623,6 +1358,12 @@ function checkHardcodedVersions(expectedVersion, config, ignorePatterns, cwd = p
   }
   return mismatches;
 }
+function getCalVerConfig(config) {
+  if (!config.versioning.calver) {
+    throw new Error('CalVer configuration is required when versioning.type is "calver"');
+  }
+  return config.versioning.calver;
+}
 const CONFIG_FILE_NAMES = [
   ".versionguard.yml",
   ".versionguard.yaml",
@@ -632,11 +1373,19 @@ const CONFIG_FILE_NAMES = [
 const DEFAULT_CONFIG = {
   versioning: {
     type: "semver",
+    schemeRules: {
+      maxNumericSegments: 3,
+      allowedModifiers: ["dev", "alpha", "beta", "rc"]
+    },
     calver: {
       format: "YYYY.MM.PATCH",
-      preventFutureDates: true
+      preventFutureDates: true,
+      strictMutualExclusion: true
     }
   },
+  manifest: {
+    source: "auto"
+  },
   sync: {
     files: ["README.md", "CHANGELOG.md"],
     patterns: [
@@ -757,13 +1506,7 @@ 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;
+  return getCalVerFeedback(version, getCalVerConfig(config), previousVersion);
 }
 function getSemVerFeedback(version, previousVersion) {
   const errors = [];
@@ -779,7 +1522,7 @@ function getSemVerFeedback(version, previousVersion) {
       });
       suggestions.push({
         message: `Remove the 'v' prefix`,
-        fix: `npm version ${cleanVersion}`,
+        fix: `npx versionguard fix --version ${cleanVersion}`,
         autoFixable: true
       });
     } else if (version.split(".").length === 2) {
@@ -789,7 +1532,7 @@ function getSemVerFeedback(version, previousVersion) {
       });
       suggestions.push({
         message: `Add patch number (e.g., ${version}.0)`,
-        fix: `npm version ${version}.0`,
+        fix: `npx versionguard fix --version ${version}.0`,
         autoFixable: true
       });
     } else if (/^\d+\.\d+\.\d+\.\d+$/.test(version)) {
@@ -839,7 +1582,7 @@ function getSemVerFeedback(version, previousVersion) {
         });
         suggestions.push({
           message: `Version must be greater than ${previousVersion}`,
-          fix: `npm version ${increment(previousVersion, "patch")}`,
+          fix: `npx versionguard fix --version ${increment(previousVersion, "patch")}`,
           autoFixable: true
         });
       } else if (comparison === 0) {
@@ -849,7 +1592,7 @@ function getSemVerFeedback(version, previousVersion) {
         });
         suggestions.push({
           message: `Bump the version`,
-          fix: `npm version ${increment(previousVersion, "patch")}`,
+          fix: `npx versionguard fix --version ${increment(previousVersion, "patch")}`,
           autoFixable: true
         });
       } else {
@@ -896,7 +1639,7 @@ function getCalVerFeedback(version, calverConfig, previousVersion) {
     });
     suggestions.push({
       message: `Expected format: ${format2}`,
-      fix: `Update package.json to use current date: "${getCurrentVersion(format2)}"`,
+      fix: `Update version to current date: "${getCurrentVersion(format2)}"`,
       autoFixable: true
     });
     return { valid: false, errors, suggestions, canAutoFix: true };
@@ -919,21 +1662,21 @@ function getCalVerFeedback(version, calverConfig, previousVersion) {
   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() })}`,
+      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: `npm version ${formatCalVerVersion({ ...parsed, month: 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: `npm version ${formatCalVerVersion({ ...parsed, day: now.getDate() })}`,
+      fix: `npx versionguard fix --version ${formatCalVerVersion({ ...parsed, day: now.getDate() })}`,
       autoFixable: true
     });
   }
@@ -947,7 +1690,7 @@ function getCalVerFeedback(version, calverConfig, previousVersion) {
         });
         suggestions.push({
           message: `CalVer must increase over time`,
-          fix: `npm version ${increment$1(previousVersion, format2)}`,
+          fix: `npx versionguard fix --version ${increment$1(previousVersion, format2)}`,
           autoFixable: true
         });
       }
@@ -1003,7 +1746,7 @@ function getChangelogFeedback(hasEntry, version, latestChangelogVersion) {
   }
   if (latestChangelogVersion && latestChangelogVersion !== version) {
     suggestions.push({
-      message: `CHANGELOG.md latest entry is ${latestChangelogVersion}, but package.json is ${version}`,
+      message: `CHANGELOG.md latest entry is ${latestChangelogVersion}, but manifest version is ${version}`,
       fix: `Make sure versions are in sync`,
       autoFixable: false
     });
@@ -1014,7 +1757,7 @@ function getTagFeedback(tagVersion, packageVersion, hasUnsyncedFiles) {
   const suggestions = [];
   if (tagVersion !== packageVersion) {
     suggestions.push({
-      message: `Git tag "${tagVersion}" doesn't match package.json "${packageVersion}"`,
+      message: `Git tag "${tagVersion}" doesn't match manifest version "${packageVersion}"`,
       fix: `Delete tag and recreate: git tag -d ${tagVersion} && git tag ${packageVersion}`,
       autoFixable: false
     });
@@ -1028,25 +1771,43 @@ function getTagFeedback(tagVersion, packageVersion, hasUnsyncedFiles) {
   }
   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" };
+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" };
   }
-  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);
+  provider.setVersion(targetVersion, cwd);
   return {
     fixed: true,
-    message: `Updated package.json from ${oldVersion} to ${targetVersion}`,
-    file: packagePath
+    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);
+  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)`,
@@ -1102,9 +1863,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 }
 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 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);
@@ -1138,7 +1899,7 @@ function suggestNextVersion(currentVersion, config, changeType) {
       });
     }
   } else {
-    const format2 = getCalVerConfig$1(config).format;
+    const format2 = getCalVerConfig(config).format;
     const currentCal = getCurrentVersion(format2);
     suggestions.push({
       version: currentCal,
@@ -1151,12 +1912,6 @@ function suggestNextVersion(currentVersion, config, changeType) {
   }
   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;
-}
 const HOOK_NAMES = ["pre-commit", "pre-push", "post-tag"];
 function checkHooksPathOverride(cwd) {
   try {
@@ -1165,6 +1920,15 @@ function checkHooksPathOverride(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",
@@ -1315,7 +2079,7 @@ function createTag(version, message, autoFix = true, config, cwd = process.cwd()
         actions
       };
     }
-    const packageVersion = getPackageVersion(cwd);
+    const packageVersion = getPackageVersion(cwd, config.manifest);
     const shouldAutoFix = autoFix;
     const preflightError = getTagPreflightError(config, cwd, version, shouldAutoFix);
     if (preflightError) {
@@ -1328,7 +2092,7 @@ function createTag(version, message, autoFix = true, config, cwd = process.cwd()
     if (version !== packageVersion && !autoFix) {
       return {
         success: false,
-        message: `Version mismatch: package.json is ${packageVersion}, tag is ${version}`,
+        message: `Version mismatch: manifest version is ${packageVersion}, tag is ${version}`,
         actions: []
       };
     }
@@ -1388,15 +2152,15 @@ function handlePostTag(config, cwd = process.cwd()) {
         actions
       };
     }
-    const packageVersion = getPackageVersion(cwd);
+    const packageVersion = getPackageVersion(cwd, config.manifest);
     if (tag.version !== packageVersion) {
       return {
         success: false,
-        message: `Tag version ${tag.version} doesn't match package.json ${packageVersion}`,
+        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}`,
-          `  npm version ${tag.version}`,
+          `  Update manifest to ${tag.version}`,
           `  git tag ${tag.name}`
         ]
       };
@@ -1427,11 +2191,12 @@ function getTagPreflightError(config, cwd, expectedVersion, allowAutoFix = false
   if (hasDirtyWorktree(cwd)) {
     return "Working tree must be clean before creating or validating release tags";
   }
-  const version = expectedVersion ?? getPackageVersion(cwd);
+  const version = expectedVersion ?? getPackageVersion(cwd, config.manifest);
   const versionResult = config.versioning.type === "semver" ? validate$1(version) : validate$2(
     version,
     config.versioning.calver?.format ?? "YYYY.MM.PATCH",
-    config.versioning.calver?.preventFutureDates ?? true
+    config.versioning.calver?.preventFutureDates ?? true,
+    config.versioning.schemeRules
   );
   if (!versionResult.valid) {
     return versionResult.errors[0]?.message ?? `Invalid version: ${version}`;
@@ -1515,13 +2280,18 @@ function validateVersion(version, config) {
     return validate$1(version);
   }
   const calverConfig = getCalVerConfig(config);
-  return validate$2(version, calverConfig.format, calverConfig.preventFutureDates);
+  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);
+    version = getPackageVersion(cwd, config.manifest);
   } catch (err) {
     return {
       valid: false,
@@ -1592,7 +2362,7 @@ function doctor(config, cwd = process.cwd()) {
   };
 }
 function sync(config, cwd = process.cwd()) {
-  const version = getPackageVersion(cwd);
+  const version = getPackageVersion(cwd, config.manifest);
   syncVersion(version, config.sync, cwd);
 }
 function canBump(currentVersion, newVersion, config) {
@@ -1627,12 +2397,6 @@ function canBump(currentVersion, newVersion, config) {
   }
   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;
@@ -1641,30 +2405,41 @@ function isWorktreeClean(cwd) {
   }
 }
 export {
-  fixPackageVersion as A,
-  getAllTags as B,
-  getLatestTag as C,
-  getTagFeedback as D,
-  semver as E,
-  suggestTagMessage as F,
-  sync as G,
-  syncVersion as H,
-  validateChangelog as I,
-  validateTagForPush as J,
-  validateVersion as K,
-  getPackageVersion as a,
-  getVersionFeedback as b,
-  getSyncFeedback as c,
-  getChangelogFeedback as d,
-  doctor as e,
-  fixAll as f,
+  fixChangelog as A,
+  fixPackageVersion as B,
+  getAllTags as C,
+  getCalVerConfig as D,
+  getLatestTag as E,
+  getTagFeedback as F,
+  GitTagSource as G,
+  getVersionSource as H,
+  initConfig as I,
+  JsonVersionSource as J,
+  resolveVersionSource as K,
+  semver as L,
+  suggestTagMessage as M,
+  sync as N,
+  syncVersion as O,
+  validateChangelog as P,
+  validateTagForPush as Q,
+  RegexVersionSource as R,
+  validateVersion as S,
+  TomlVersionSource as T,
+  VersionFileSource as V,
+  YamlVersionSource as Y,
+  installHooks as a,
+  getPackageVersion as b,
+  getVersionFeedback as c,
+  getSyncFeedback as d,
+  getChangelogFeedback as e,
+  doctor as f,
   getConfig as g,
   handlePostTag as h,
-  initConfig as i,
-  fixSyncIssues as j,
-  setPackageVersion as k,
-  createTag as l,
-  installHooks as m,
+  isValidCalVerFormat as i,
+  fixAll as j,
+  fixSyncIssues as k,
+  setPackageVersion as l,
+  createTag as m,
   areHooksInstalled as n,
   calver as o,
   canBump as p,
@@ -1677,6 +2452,6 @@ export {
   checkHookIntegrity as w,
   checkHooksPathOverride as x,
   checkHuskyBypass as y,
-  fixChangelog as z
+  detectManifests as z
 };
-//# sourceMappingURL=index-BwE_OaV3.js.map
+//# sourceMappingURL=index-B3R60bYJ.js.map