@releasekit/version 0.7.44 → 0.7.46

package/dist/{baseError-DQHIJACF.js → baseError-6PKATI6Z.js}

@@ -1,6 +1,6 @@
 import {
   BaseVersionError
-} from "./chunk-Q3FHZORY.js";
+} from "./chunk-3FG6RVHS.js";
 export {
   BaseVersionError
 };

package/dist/chunk-3FG6RVHS.js

@@ -0,0 +1,18 @@
+// src/errors/baseError.ts
+import { ReleaseKitError } from "@releasekit/core";
+var BaseVersionError = class _BaseVersionError extends ReleaseKitError {
+  code;
+  suggestions;
+  constructor(message, code, suggestions) {
+    super(message);
+    this.code = code;
+    this.suggestions = suggestions ?? [];
+  }
+  static isVersionError(error) {
+    return error instanceof _BaseVersionError;
+  }
+};
+
+export {
+  BaseVersionError
+};

package/dist/{chunk-UBCKZYTO.js → chunk-V44UWRAP.js}

@@ -1,413 +1,13 @@
 import {
-  BaseVersionError,
-  ReleaseKitError,
-  sanitizePackageName
-} from "./chunk-Q3FHZORY.js";
+  BaseVersionError
+} from "./chunk-3FG6RVHS.js";
 import {
   execAsync,
   execSync
 } from "./chunk-LMPZV35Z.js";
 
-// ../config/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import * as TOML from "smol-toml";
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { z as z2 } from "zod";
-import { z } from "zod";
-import * as fs2 from "fs";
-import * as os from "os";
-import * as path2 from "path";
-function parseCargoToml(cargoPath) {
-  const content = fs.readFileSync(cargoPath, "utf-8");
-  return TOML.parse(content);
-}
-function isCargoToml(filePath) {
-  return path.basename(filePath) === "Cargo.toml";
-}
-var ConfigError = class extends ReleaseKitError {
-  code = "CONFIG_ERROR";
-  suggestions;
-  constructor(message, suggestions) {
-    super(message);
-    this.suggestions = suggestions ?? [
-      "Check that releasekit.config.json exists and is valid JSON",
-      "Run with --verbose for more details"
-    ];
-  }
-};
-var MAX_JSONC_LENGTH = 1e5;
-function parseJsonc(content) {
-  if (content.length > MAX_JSONC_LENGTH) {
-    throw new Error(`JSONC content too long: ${content.length} characters (max ${MAX_JSONC_LENGTH})`);
-  }
-  try {
-    return JSON.parse(content);
-  } catch {
-    const cleaned = content.replace(/\/\/[^\r\n]{0,10000}$/gm, "").replace(/\/\*[\s\S]{0,50000}?\*\//g, "").trim();
-    return JSON.parse(cleaned);
-  }
-}
-var GitConfigSchema = z.object({
-  remote: z.string().default("origin"),
-  branch: z.string().default("main"),
-  pushMethod: z.enum(["auto", "ssh", "https"]).default("auto"),
-  /**
-   * Optional env var name containing a GitHub token for HTTPS pushes.
-   * When set, publish steps can use this token without mutating git remotes.
-   */
-  httpsTokenEnv: z.string().optional(),
-  push: z.boolean().optional(),
-  skipHooks: z.boolean().optional()
-});
-var MonorepoConfigSchema = z.object({
-  mode: z.enum(["root", "packages", "both"]).optional(),
-  rootPath: z.string().optional(),
-  packagesPath: z.string().optional(),
-  mainPackage: z.string().optional()
-});
-var BranchPatternSchema = z.object({
-  pattern: z.string(),
-  releaseType: z.enum(["major", "minor", "patch", "prerelease"])
-});
-var VersionCargoConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  paths: z.array(z.string()).optional()
-});
-var VersionConfigSchema = z.object({
-  tagTemplate: z.string().default("v{version}"),
-  packageSpecificTags: z.boolean().default(false),
-  preset: z.string().default("conventional"),
-  sync: z.boolean().default(true),
-  packages: z.array(z.string()).default([]),
-  mainPackage: z.string().optional(),
-  updateInternalDependencies: z.enum(["major", "minor", "patch", "no-internal-update"]).default("minor"),
-  skip: z.array(z.string()).optional(),
-  commitMessage: z.string().optional(),
-  versionStrategy: z.enum(["branchPattern", "commitMessage"]).default("commitMessage"),
-  branchPatterns: z.array(BranchPatternSchema).optional(),
-  defaultReleaseType: z.enum(["major", "minor", "patch", "prerelease"]).optional(),
-  mismatchStrategy: z.enum(["error", "warn", "ignore", "prefer-package", "prefer-git"]).default("warn"),
-  versionPrefix: z.string().default(""),
-  prereleaseIdentifier: z.string().optional(),
-  strictReachable: z.boolean().default(false),
-  cargo: VersionCargoConfigSchema.optional()
-});
-var NpmConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  auth: z.enum(["auto", "oidc", "token"]).default("auto"),
-  provenance: z.boolean().default(true),
-  access: z.enum(["public", "restricted"]).default("public"),
-  registry: z.string().default("https://registry.npmjs.org"),
-  copyFiles: z.array(z.string()).default(["LICENSE"]),
-  tag: z.string().default("latest")
-});
-var CargoPublishConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  noVerify: z.boolean().default(false),
-  publishOrder: z.array(z.string()).default([]),
-  clean: z.boolean().default(false)
-});
-var PublishGitConfigSchema = z.object({
-  push: z.boolean().default(true),
-  pushMethod: z.enum(["auto", "ssh", "https"]).optional(),
-  remote: z.string().optional(),
-  branch: z.string().optional(),
-  httpsTokenEnv: z.string().optional(),
-  skipHooks: z.boolean().optional()
-});
-var GitHubReleaseConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  draft: z.boolean().default(true),
-  perPackage: z.boolean().default(true),
-  prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
-  /**
-   * Controls the source for the GitHub release body.
-   * - 'auto': Use release notes if enabled, else changelog, else GitHub auto-generated.
-   * - 'releaseNotes': Use LLM-generated release notes (requires notes.releaseNotes.enabled: true).
-   * - 'changelog': Use formatted changelog entries.
-   * - 'generated': Use GitHub's auto-generated notes.
-   * - 'none': No body.
-   */
-  body: z.enum(["auto", "releaseNotes", "changelog", "generated", "none"]).default("auto"),
-  /**
-   * Template string for the GitHub release title when a package name is resolved.
-   * Available variables: ${packageName} (original scoped name), ${version} (e.g. "v1.0.0").
-   * Version-only tags (e.g. "v1.0.0") always use the tag as-is.
-   */
-  /* biome-ignore lint/suspicious/noTemplateCurlyInString: default template value */
-  titleTemplate: z.string().default("${packageName}: ${version}")
-});
-var VerifyRegistryConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  maxAttempts: z.number().int().positive().default(5),
-  initialDelay: z.number().int().positive().default(15e3),
-  backoffMultiplier: z.number().positive().default(2)
-});
-var VerifyConfigSchema = z.object({
-  npm: VerifyRegistryConfigSchema.default({
-    enabled: true,
-    maxAttempts: 5,
-    initialDelay: 15e3,
-    backoffMultiplier: 2
-  }),
-  cargo: VerifyRegistryConfigSchema.default({
-    enabled: true,
-    maxAttempts: 10,
-    initialDelay: 3e4,
-    backoffMultiplier: 2
-  })
-});
-var PublishConfigSchema = z.object({
-  git: PublishGitConfigSchema.optional(),
-  npm: NpmConfigSchema.default({
-    enabled: true,
-    auth: "auto",
-    provenance: true,
-    access: "public",
-    registry: "https://registry.npmjs.org",
-    copyFiles: ["LICENSE"],
-    tag: "latest"
-  }),
-  cargo: CargoPublishConfigSchema.default({
-    enabled: false,
-    noVerify: false,
-    publishOrder: [],
-    clean: false
-  }),
-  githubRelease: GitHubReleaseConfigSchema.default({
-    enabled: true,
-    draft: true,
-    perPackage: true,
-    prerelease: "auto",
-    body: "auto",
-    /* biome-ignore lint/suspicious/noTemplateCurlyInString: default template value */
-    titleTemplate: "${packageName}: ${version}"
-  }),
-  verify: VerifyConfigSchema.default({
-    npm: {
-      enabled: true,
-      maxAttempts: 5,
-      initialDelay: 15e3,
-      backoffMultiplier: 2
-    },
-    cargo: {
-      enabled: true,
-      maxAttempts: 10,
-      initialDelay: 3e4,
-      backoffMultiplier: 2
-    }
-  })
-});
-var TemplateConfigSchema = z.object({
-  path: z.string().optional(),
-  engine: z.enum(["handlebars", "liquid", "ejs"]).optional()
-});
-var LocationModeSchema = z.enum(["root", "packages", "both"]);
-var ChangelogConfigSchema = z.object({
-  mode: LocationModeSchema.optional(),
-  file: z.string().optional(),
-  templates: TemplateConfigSchema.optional()
-});
-var LLMOptionsSchema = z.object({
-  timeout: z.number().optional(),
-  maxTokens: z.number().optional(),
-  temperature: z.number().optional()
-});
-var LLMRetryConfigSchema = z.object({
-  maxAttempts: z.number().int().positive().optional(),
-  initialDelay: z.number().nonnegative().optional(),
-  maxDelay: z.number().positive().optional(),
-  backoffFactor: z.number().positive().optional()
-});
-var LLMTasksConfigSchema = z.object({
-  summarize: z.boolean().optional(),
-  enhance: z.boolean().optional(),
-  categorize: z.boolean().optional(),
-  releaseNotes: z.boolean().optional()
-});
-var LLMCategorySchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  scopes: z.array(z.string()).optional()
-});
-var ScopeRulesSchema = z.object({
-  allowed: z.array(z.string()).optional(),
-  caseSensitive: z.boolean().default(false),
-  invalidScopeAction: z.enum(["remove", "keep", "fallback"]).default("remove"),
-  fallbackScope: z.string().optional()
-});
-var ScopeConfigSchema = z.object({
-  mode: z.enum(["restricted", "packages", "none", "unrestricted"]).default("unrestricted"),
-  rules: ScopeRulesSchema.optional()
-});
-var LLMPromptOverridesSchema = z.object({
-  enhance: z.string().optional(),
-  categorize: z.string().optional(),
-  enhanceAndCategorize: z.string().optional(),
-  summarize: z.string().optional(),
-  releaseNotes: z.string().optional()
-});
-var LLMPromptsConfigSchema = z.object({
-  instructions: LLMPromptOverridesSchema.optional(),
-  templates: LLMPromptOverridesSchema.optional()
-});
-var LLMConfigSchema = z.object({
-  provider: z.string(),
-  model: z.string(),
-  baseURL: z.string().optional(),
-  apiKey: z.string().optional(),
-  options: LLMOptionsSchema.optional(),
-  concurrency: z.number().int().positive().optional(),
-  retry: LLMRetryConfigSchema.optional(),
-  tasks: LLMTasksConfigSchema.optional(),
-  categories: z.array(LLMCategorySchema).optional(),
-  style: z.string().optional(),
-  scopes: ScopeConfigSchema.optional(),
-  prompts: LLMPromptsConfigSchema.optional()
-});
-var ReleaseNotesConfigSchema = z.object({
-  mode: LocationModeSchema.optional(),
-  file: z.string().optional(),
-  templates: TemplateConfigSchema.optional(),
-  llm: LLMConfigSchema.optional()
-});
-var NotesInputConfigSchema = z.object({
-  source: z.string().optional(),
-  file: z.string().optional()
-});
-var NotesConfigSchema = z.object({
-  changelog: z.union([z.literal(false), ChangelogConfigSchema]).optional(),
-  releaseNotes: z.union([z.literal(false), ReleaseNotesConfigSchema]).optional(),
-  updateStrategy: z.enum(["prepend", "regenerate"]).optional()
-});
-var CILabelsConfigSchema = z.object({
-  stable: z.string().default("release:stable"),
-  prerelease: z.string().default("release:prerelease"),
-  skip: z.string().default("release:skip"),
-  major: z.string().default("release:major"),
-  minor: z.string().default("release:minor"),
-  patch: z.string().default("release:patch")
-});
-var CIConfigSchema = z.object({
-  releaseStrategy: z.enum(["manual", "direct", "standing-pr", "scheduled"]).default("direct"),
-  releaseTrigger: z.enum(["commit", "label"]).default("label"),
-  prPreview: z.boolean().default(true),
-  autoRelease: z.boolean().default(false),
-  /**
-   * Commit message prefixes that should not trigger a release.
-   * Defaults to `['chore: release ']` to match the release commit template
-   * (`chore: release ${packageName} v${version}`) and provide a
-   * secondary loop-prevention guard alongside `[skip ci]`.
-   */
-  skipPatterns: z.array(z.string()).default(["chore: release "]),
-  minChanges: z.number().int().positive().default(1),
-  labels: CILabelsConfigSchema.default({
-    stable: "release:stable",
-    prerelease: "release:prerelease",
-    skip: "release:skip",
-    major: "release:major",
-    minor: "release:minor",
-    patch: "release:patch"
-  })
-});
-var ReleaseCIConfigSchema = z.object({
-  skipPatterns: z.array(z.string().min(1)).optional(),
-  minChanges: z.number().int().positive().optional(),
-  /** Set to `false` to disable GitHub release creation in CI. */
-  githubRelease: z.literal(false).optional(),
-  /** Set to `false` to disable changelog generation in CI. */
-  notes: z.literal(false).optional()
-});
-var ReleaseConfigSchema = z.object({
-  /**
-   * Optional steps to enable. The version step always runs; only 'notes' and
-   * 'publish' can be opted out. Omitting a step is equivalent to --skip-<step>.
-   */
-  steps: z.array(z.enum(["notes", "publish"])).min(1).optional(),
-  ci: ReleaseCIConfigSchema.optional()
-});
-var ReleaseKitConfigSchema = z.object({
-  git: GitConfigSchema.optional(),
-  monorepo: MonorepoConfigSchema.optional(),
-  version: VersionConfigSchema.optional(),
-  publish: PublishConfigSchema.optional(),
-  notes: NotesConfigSchema.optional(),
-  ci: CIConfigSchema.optional(),
-  release: ReleaseConfigSchema.optional()
-});
-var MAX_INPUT_LENGTH = 1e4;
-function substituteVariables(value) {
-  if (value.length > MAX_INPUT_LENGTH) {
-    throw new Error(`Input too long: ${value.length} characters (max ${MAX_INPUT_LENGTH})`);
-  }
-  const envPattern = /\{env:([^}]{1,1000})\}/g;
-  const filePattern = /\{file:([^}]{1,1000})\}/g;
-  let result = value;
-  result = result.replace(envPattern, (_, varName) => {
-    return process.env[varName] ?? "";
-  });
-  result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path2.join(os.homedir(), filePath.slice(1)) : filePath;
-    try {
-      return fs2.readFileSync(expandedPath, "utf-8").trim();
-    } catch {
-      return "";
-    }
-  });
-  return result;
-}
-var SOLE_REFERENCE_PATTERN = /^\{(?:env|file):[^}]+\}$/;
-function substituteInObject(obj) {
-  if (typeof obj === "string") {
-    const result = substituteVariables(obj);
-    if (result === "" && SOLE_REFERENCE_PATTERN.test(obj)) {
-      return void 0;
-    }
-    return result;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => substituteInObject(item));
-  }
-  if (obj && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = substituteInObject(value);
-    }
-    return result;
-  }
-  return obj;
-}
-var AUTH_DIR = path2.join(os.homedir(), ".config", "releasekit");
-var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
-var CONFIG_FILE = "releasekit.config.json";
-function loadConfigFile(configPath) {
-  if (!fs3.existsSync(configPath)) {
-    return {};
-  }
-  try {
-    const content = fs3.readFileSync(configPath, "utf-8");
-    const parsed = parseJsonc(content);
-    const substituted = substituteInObject(parsed);
-    return ReleaseKitConfigSchema.parse(substituted);
-  } catch (error) {
-    if (error instanceof z2.ZodError) {
-      const issues = error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new ConfigError(`Config validation errors:
-${issues}`);
-    }
-    if (error instanceof SyntaxError) {
-      throw new ConfigError(`Invalid JSON in config file: ${error.message}`);
-    }
-    throw error;
-  }
-}
-function loadConfig(options) {
-  const cwd3 = options?.cwd ?? process.cwd();
-  const configPath = options?.configPath ?? path3.join(cwd3, CONFIG_FILE);
-  return loadConfigFile(configPath);
-}
+// src/config.ts
+import { loadConfig as loadReleaseKitConfig } from "@releasekit/config";
 
 // src/types.ts
 function toVersionConfig(config, gitConfig) {
@@ -448,8 +48,8 @@ function toVersionConfig(config, gitConfig) {
 }
 
 // src/config.ts
-function loadConfig2(options) {
-  const fullConfig = loadConfig(options);
+function loadConfig(options) {
+  const fullConfig = loadReleaseKitConfig(options);
   return toVersionConfig(fullConfig.version, fullConfig.git);
 }
 
@@ -511,7 +111,7 @@ function createVersionError(code, details) {
 }
 
 // src/utils/jsonOutput.ts
-import fs4 from "fs";
+import fs from "fs";
 var _jsonOutputMode = false;
 var _pendingWrites = [];
 var _jsonData = {
@@ -531,14 +131,14 @@ function enableJsonOutput(dryRun = false) {
   _jsonData.commitMessage = void 0;
   _pendingWrites.length = 0;
 }
-function recordPendingWrite(path10, content) {
+function recordPendingWrite(path7, content) {
   if (!_jsonOutputMode) return;
-  _pendingWrites.push({ path: path10, content });
+  _pendingWrites.push({ path: path7, content });
 }
 function flushPendingWrites() {
   try {
-    for (const { path: path10, content } of _pendingWrites) {
-      fs4.writeFileSync(path10, content);
+    for (const { path: path7, content } of _pendingWrites) {
+      fs.writeFileSync(path7, content);
     }
   } finally {
     _pendingWrites.length = 0;
@@ -582,12 +182,13 @@ function printJsonOutput() {
 
 // src/core/versionCalculator.ts
 import { cwd } from "process";
+import { sanitizePackageName as sanitizePackageName2 } from "@releasekit/core";
 import { Bumper } from "conventional-recommended-bump";
 import semver3 from "semver";
 
 // src/git/repository.ts
-import { existsSync as existsSync3, statSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
 function getCurrentBranch() {
   const result = execSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
   return result.toString().trim();
@@ -597,6 +198,9 @@ function getCurrentBranch() {
 import { getSemverTags } from "git-semver-tags";
 import semver from "semver";
 
+// src/utils/formatting.ts
+import { sanitizePackageName } from "@releasekit/core";
+
 // src/utils/logging.ts
 import chalk from "chalk";
 import figlet from "figlet";
@@ -806,15 +410,16 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 }
 
 // src/utils/manifestHelpers.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs3 from "fs";
+import path2 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs5 from "fs";
-import path4 from "path";
-import * as TOML2 from "smol-toml";
+import fs2 from "fs";
+import path from "path";
+import { isCargoToml, parseCargoToml } from "@releasekit/config";
+import * as TOML from "smol-toml";
 function getCargoInfo(cargoPath) {
-  if (!fs5.existsSync(cargoPath)) {
+  if (!fs2.existsSync(cargoPath)) {
     log(`Cargo.toml file not found at: ${cargoPath}`, "error");
     throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
   }
@@ -828,7 +433,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path4.dirname(cargoPath),
+      dir: path.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -852,11 +457,11 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
     } else {
       cargo.package.version = version;
     }
-    const updatedContent = TOML2.stringify(cargo);
+    const updatedContent = TOML.stringify(cargo);
     if (dryRun) {
       recordPendingWrite(cargoPath, updatedContent);
     } else {
-      fs5.writeFileSync(cargoPath, updatedContent);
+      fs2.writeFileSync(cargoPath, updatedContent);
     }
     addPackageUpdate(packageName, version, cargoPath);
     log(`${dryRun ? "[DRY RUN] Would update" : "Updated"} Cargo.toml at ${cargoPath} to version ${version}`, "success");
@@ -871,11 +476,11 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
 
 // src/utils/manifestHelpers.ts
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path5.join(packageDir, "package.json");
-  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
-  if (fs6.existsSync(packageJsonPath)) {
+  const packageJsonPath = path2.join(packageDir, "package.json");
+  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
+  if (fs3.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
       if (packageJson.version) {
         log(`Found version ${packageJson.version} in package.json`, "debug");
         return {
@@ -891,7 +496,7 @@ function getVersionFromManifests(packageDir) {
       log(`Error reading package.json: ${errMsg}`, "warning");
     }
   }
-  if (fs6.existsSync(cargoTomlPath)) {
+  if (fs3.existsSync(cargoTomlPath)) {
     try {
       const cargoInfo = getCargoInfo(cargoTomlPath);
       if (cargoInfo.version) {
@@ -918,7 +523,8 @@ function getVersionFromManifests(packageDir) {
 }
 
 // src/utils/versionUtils.ts
-import fs7 from "fs";
+import fs4 from "fs";
+import { parseCargoToml as parseCargoToml2 } from "@releasekit/config";
 import semver2 from "semver";
 
 // src/git/tagVerification.ts
@@ -1160,7 +766,7 @@ async function calculateVersion(config, options) {
   try {
     let buildTagStripPattern2 = function(packageName, prefix) {
       if (!packageName) return escapeRegExp(prefix);
-      const sanitized = sanitizePackageName(packageName);
+      const sanitized = sanitizePackageName2(packageName);
       const escapedRaw = escapeRegExp(`${packageName}@${prefix}`);
       const escapedDash = escapeRegExp(`${sanitized}-${prefix}`);
       return `(?:${escapedRaw}|${escapedDash})`;
@@ -1293,8 +899,8 @@ async function calculateVersion(config, options) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs9 from "fs";
-import path7 from "path";
+import * as fs6 from "fs";
+import path4 from "path";
 
 // src/changelog/commitParser.ts
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
@@ -1498,15 +1104,15 @@ function shouldProcessPackage(packageName, skip = []) {
 }
 
 // src/package/packageManagement.ts
-import fs8 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path3 from "path";
 function updatePackageVersion(packagePath, version, dryRun = false) {
   if (isCargoToml(packagePath)) {
     updateCargoVersion(packagePath, version, dryRun);
     return;
   }
   try {
-    const packageContent = fs8.readFileSync(packagePath, "utf8");
+    const packageContent = fs5.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     const updatedContent = `${JSON.stringify({ ...packageJson, version }, null, 2)}
@@ -1514,7 +1120,7 @@ function updatePackageVersion(packagePath, version, dryRun = false) {
     if (dryRun) {
       recordPendingWrite(packagePath, updatedContent);
     } else {
-      fs8.writeFileSync(packagePath, updatedContent);
+      fs5.writeFileSync(packagePath, updatedContent);
     }
     addPackageUpdate(packageName, version, packagePath);
     log(
@@ -1684,9 +1290,9 @@ var PackageProcessor = class {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path7.join(pkgPath, "package.json");
-        if (fs9.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath2, "utf8"));
+        const packageJsonPath2 = path4.join(pkgPath, "package.json");
+        if (fs6.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
             if (typeof packageJson.repository === "string") {
               repoUrl = packageJson.repository;
@@ -1712,8 +1318,8 @@ var PackageProcessor = class {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path7.join(pkgPath, "package.json");
-      if (fs9.existsSync(packageJsonPath)) {
+      const packageJsonPath = path4.join(pkgPath, "package.json");
+      if (fs6.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion, this.dryRun);
       }
       const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
@@ -1723,9 +1329,9 @@ var PackageProcessor = class {
         log(`Cargo paths config for ${name}: ${JSON.stringify(cargoPaths)}`, "debug");
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path7.resolve(pkgPath, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path4.resolve(pkgPath, cargoPath, "Cargo.toml");
             log(`Checking cargo path for ${name}: ${resolvedCargoPath}`, "debug");
-            if (fs9.existsSync(resolvedCargoPath)) {
+            if (fs6.existsSync(resolvedCargoPath)) {
               log(`Found Cargo.toml for ${name} at ${resolvedCargoPath}, updating...`, "debug");
               updatePackageVersion(resolvedCargoPath, nextVersion, this.dryRun);
             } else {
@@ -1733,9 +1339,9 @@ var PackageProcessor = class {
             }
           }
         } else {
-          const cargoTomlPath = path7.join(pkgPath, "Cargo.toml");
+          const cargoTomlPath = path4.join(pkgPath, "Cargo.toml");
           log(`Checking default cargo path for ${name}: ${cargoTomlPath}`, "debug");
-          if (fs9.existsSync(cargoTomlPath)) {
+          if (fs6.existsSync(cargoTomlPath)) {
             log(`Found Cargo.toml for ${name} at ${cargoTomlPath}, updating...`, "debug");
             updatePackageVersion(cargoTomlPath, nextVersion, this.dryRun);
           } else {
@@ -1801,8 +1407,8 @@ var PackageProcessor = class {
 };
 
 // src/core/versionStrategies.ts
-import fs10 from "fs";
-import * as path8 from "path";
+import fs7 from "fs";
+import * as path5 from "path";
 function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
   return shouldProcessPackage(pkgName, config.skip);
@@ -1816,15 +1422,15 @@ function updateCargoFiles(packageDir, version, cargoConfig, dryRun = false) {
   const cargoPaths = cargoConfig?.paths;
   if (cargoPaths && cargoPaths.length > 0) {
     for (const cargoPath of cargoPaths) {
-      const resolvedCargoPath = path8.resolve(packageDir, cargoPath, "Cargo.toml");
-      if (fs10.existsSync(resolvedCargoPath)) {
+      const resolvedCargoPath = path5.resolve(packageDir, cargoPath, "Cargo.toml");
+      if (fs7.existsSync(resolvedCargoPath)) {
         updatePackageVersion(resolvedCargoPath, version, dryRun);
         updatedFiles.push(resolvedCargoPath);
       }
     }
   } else {
-    const cargoTomlPath = path8.join(packageDir, "Cargo.toml");
-    if (fs10.existsSync(cargoTomlPath)) {
+    const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+    if (fs7.existsSync(cargoTomlPath)) {
       updatePackageVersion(cargoTomlPath, version, dryRun);
       updatedFiles.push(cargoTomlPath);
     }
@@ -1904,8 +1510,8 @@ function createSyncStrategy(config) {
       const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
-          const rootPkgPath = path8.join(packages.root, "package.json");
-          if (fs10.existsSync(rootPkgPath)) {
+          const rootPkgPath = path5.join(packages.root, "package.json");
+          if (fs7.existsSync(rootPkgPath)) {
             updatePackageVersion(rootPkgPath, nextVersion, dryRun);
             files.push(rootPkgPath);
             updatedPackages.push("root");
@@ -1924,7 +1530,7 @@ function createSyncStrategy(config) {
         if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path8.join(pkg.dir, "package.json");
+        const packageJsonPath = path5.join(pkg.dir, "package.json");
         if (processedPaths.has(packageJsonPath)) {
           continue;
         }
@@ -1983,9 +1589,9 @@ function createSyncStrategy(config) {
       let repoUrl = null;
       for (const searchPath of [mainPkgPath, versionSourcePath].filter(Boolean)) {
         try {
-          const pkgJsonPath = path8.join(searchPath, "package.json");
-          if (fs10.existsSync(pkgJsonPath)) {
-            const pkgJson = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf8"));
+          const pkgJsonPath = path5.join(searchPath, "package.json");
+          if (fs7.existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf8"));
             let url;
             if (typeof pkgJson.repository === "string") {
               url = pkgJson.repository;
@@ -2152,9 +1758,9 @@ function createSingleStrategy(config) {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path8.join(pkgPath, "package.json");
-        if (fs10.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs10.readFileSync(packageJsonPath2, "utf8"));
+        const packageJsonPath2 = path5.join(pkgPath, "package.json");
+        if (fs7.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs7.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
             if (typeof packageJson.repository === "string") {
               repoUrl = packageJson.repository;
@@ -2180,7 +1786,7 @@ function createSingleStrategy(config) {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path8.join(pkgPath, "package.json");
+      const packageJsonPath = path5.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion, dryRun);
       const filesToCommit = [packageJsonPath];
       const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo, dryRun);
@@ -2286,7 +1892,7 @@ var GitError = class extends BaseVersionError {
 };
 
 // src/utils/packageFiltering.ts
-import path9 from "path";
+import path6 from "path";
 import { minimatch as minimatch2 } from "minimatch";
 function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
   if (configTargets.length === 0) {
@@ -2312,7 +1918,7 @@ function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
   }
   const normalizedPattern = pattern.replace(/\\/g, "/");
   return packages.filter((pkg) => {
-    const relativePath = path9.relative(workspaceRoot, pkg.dir);
+    const relativePath = path6.relative(workspaceRoot, pkg.dir);
     const normalizedRelativePath = relativePath.replace(/\\/g, "/");
     if (normalizedPattern === normalizedRelativePath) {
       return true;
@@ -2473,7 +2079,7 @@ function createVersionCommand() {
           );
         }
       }
-      const config = loadConfig2({ cwd: options.projectDir, configPath: options.config });
+      const config = loadConfig({ cwd: options.projectDir, configPath: options.config });
       log(`Loaded configuration from ${options.config || "releasekit.config.json"}`, "info");
       if (options.dryRun) config.dryRun = true;
       if (options.sync) config.sync = true;
@@ -2517,7 +2123,7 @@ function createVersionCommand() {
       log("Versioning process completed.", "success");
       printJsonOutput();
     } catch (error) {
-      const { BaseVersionError: BaseVersionError2 } = await import("./baseError-DQHIJACF.js");
+      const { BaseVersionError: BaseVersionError2 } = await import("./baseError-6PKATI6Z.js");
       if (BaseVersionError2.isVersionError(error)) {
         error.logError();
       } else {
@@ -2529,7 +2135,7 @@ function createVersionCommand() {
 }
 
 export {
-  loadConfig2 as loadConfig,
+  loadConfig,
   VersionErrorCode,
   createVersionError,
   enableJsonOutput,

package/dist/cli.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 import {
   createVersionCommand
-} from "./chunk-UBCKZYTO.js";
-import {
-  readPackageVersion
-} from "./chunk-Q3FHZORY.js";
+} from "./chunk-V44UWRAP.js";
+import "./chunk-3FG6RVHS.js";
 import "./chunk-LMPZV35Z.js";
 
 // src/cli.ts
 import * as fs from "fs";
 import { fileURLToPath } from "url";
+import { readPackageVersion } from "@releasekit/core";
 import { Command } from "commander";
 var isMain = (() => {
   try {

package/dist/index.js

@@ -12,10 +12,10 @@ import {
   flushPendingWrites,
   getJsonData,
   loadConfig
-} from "./chunk-UBCKZYTO.js";
+} from "./chunk-V44UWRAP.js";
 import {
   BaseVersionError
-} from "./chunk-Q3FHZORY.js";
+} from "./chunk-3FG6RVHS.js";
 import "./chunk-LMPZV35Z.js";
 export {
   BaseVersionError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@releasekit/version",
-  "version": "0.7.44",
+  "version": "0.7.46",
   "description": "Semantic versioning based on Git history and conventional commits",
   "type": "module",
   "module": "./dist/index.js",

package/dist/chunk-Q3FHZORY.js

@@ -1,89 +0,0 @@
-// ../core/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import chalk from "chalk";
-function readPackageVersion(importMetaUrl) {
-  try {
-    const dir = path.dirname(fileURLToPath(importMetaUrl));
-    const packageJsonPath = path.resolve(dir, "../package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-    return packageJson.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-var LOG_LEVELS = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4
-};
-var PREFIXES = {
-  error: "[ERROR]",
-  warn: "[WARN]",
-  info: "[INFO]",
-  debug: "[DEBUG]",
-  trace: "[TRACE]"
-};
-var COLORS = {
-  error: chalk.red,
-  warn: chalk.yellow,
-  info: chalk.blue,
-  debug: chalk.gray,
-  trace: chalk.dim
-};
-var currentLevel = "info";
-var quietMode = false;
-function shouldLog(level) {
-  if (quietMode && level !== "error") return false;
-  return LOG_LEVELS[level] <= LOG_LEVELS[currentLevel];
-}
-function log(message, level = "info") {
-  if (!shouldLog(level)) return;
-  const formatted = COLORS[level](`${PREFIXES[level]} ${message}`);
-  console.error(formatted);
-}
-var ReleaseKitError = class _ReleaseKitError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-  logError() {
-    log(this.message, "error");
-    if (this.suggestions.length > 0) {
-      log("\nSuggested solutions:", "info");
-      for (const [i, suggestion] of this.suggestions.entries()) {
-        log(`${i + 1}. ${suggestion}`, "info");
-      }
-    }
-  }
-  static isReleaseKitError(error2) {
-    return error2 instanceof _ReleaseKitError;
-  }
-};
-function sanitizePackageName(name) {
-  return name.startsWith("@") ? name.slice(1).replace(/\//g, "-") : name;
-}
-
-// src/errors/baseError.ts
-var BaseVersionError = class _BaseVersionError extends ReleaseKitError {
-  code;
-  suggestions;
-  constructor(message, code, suggestions) {
-    super(message);
-    this.code = code;
-    this.suggestions = suggestions ?? [];
-  }
-  static isVersionError(error) {
-    return error instanceof _BaseVersionError;
-  }
-};
-
-export {
-  readPackageVersion,
-  ReleaseKitError,
-  sanitizePackageName,
-  BaseVersionError
-};