package-versioner 0.2.0 → 0.3.0

package/dist/index.js

@@ -26,90 +26,136 @@ function loadConfig(configPath) {
   });
 }
 
-// src/utils.ts
-import fs2 from "node:fs";
+// src/core/versionEngine.ts
+import { cwd as cwd4 } from "node:process";
+import { getPackagesSync } from "@manypkg/get-packages";
+
+// src/errors/gitError.ts
+var GitError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "GitError";
+  }
+};
+function createGitError(code, details) {
+  const messages = {
+    ["NOT_GIT_REPO" /* NOT_GIT_REPO */]: "Not a git repository",
+    ["GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */]: "Failed to create new version",
+    ["NO_FILES" /* NO_FILES */]: "No files specified for commit",
+    ["NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */]: "Commit message is required",
+    ["GIT_ERROR" /* GIT_ERROR */]: "Git operation failed"
+  };
+  const baseMessage = messages[code];
+  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
+  return new GitError(fullMessage, code);
+}
+
+// src/errors/versionError.ts
+var VersionError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "VersionError";
+  }
+};
+function createVersionError(code, details) {
+  const messages = {
+    ["CONFIG_REQUIRED" /* CONFIG_REQUIRED */]: "Configuration is required",
+    ["PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */]: "Failed to get packages information",
+    ["WORKSPACE_ERROR" /* WORKSPACE_ERROR */]: "Failed to get workspace packages",
+    ["INVALID_CONFIG" /* INVALID_CONFIG */]: "Invalid configuration",
+    ["PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */]: "Package not found",
+    ["VERSION_CALCULATION_ERROR" /* VERSION_CALCULATION_ERROR */]: "Failed to calculate version"
+  };
+  const baseMessage = messages[code];
+  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
+  return new VersionError(fullMessage, code);
+}
+
+// src/utils/logging.ts
 import chalk from "chalk";
 import figlet from "figlet";
 
-// package.json
-var package_default = {
-  name: "package-versioner",
-  description: "A powerful CLI tool for automated semantic versioning based on Git history and conventional commits. Supports monorepos with synchronized or independent package versioning strategies.",
-  version: "0.1.1",
-  type: "module",
-  main: "./dist/index.js",
-  module: "./dist/index.mjs",
-  types: "./dist/index.d.ts",
-  author: {
-    name: "Sam Maister",
-    email: "goosewobbler@protonmail.com"
-  },
-  repository: {
-    type: "git",
-    url: "https://github.com/goosewobbler/package-versioner",
-    homepage: "https://github.com/goosewobbler/package-versioner"
-  },
-  keywords: ["version", "semver", "git", "package"],
-  license: "MIT",
-  files: ["dist/**", "docs/**", "package-versioner.schema.json"],
-  bin: {
-    "package-versioner": "./dist/index.js"
-  },
-  scripts: {
-    build: "tsup src/index.ts --format esm,cjs --dts",
-    dev: "tsup src/index.ts --format esm,cjs --watch --dts",
-    clean: "rm -rf node_modules && rm -rf dist",
-    test: "vitest run --coverage",
-    "test:watch": "vitest --coverage",
-    lint: "biome check .",
-    "lint:fix": "biome check --apply .",
-    format: "biome format --write .",
-    "format:check": "biome format .",
-    fix: "pnpm run lint:fix && pnpm run format",
-    prepare: "husky"
-  },
-  "lint-staged": {
-    "*.{js,ts,jsx,tsx}": ["biome check --apply", "biome format --write"]
-  },
-  devDependencies: {
-    "@biomejs/biome": "^1.9.4",
-    "@types/figlet": "^1.5.5",
-    "@types/node": "^22.14.0",
-    "@types/semver": "^7.3.13",
-    "@vitest/coverage-v8": "^3.1.1",
-    husky: "^9.1.7",
-    "lint-staged": "^15.5.0",
-    tsup: "^8.4.0",
-    typescript: "^5.8.3",
-    vitest: "^3.1.1"
-  },
-  dependencies: {
-    "@manypkg/get-packages": "^2.2.2",
-    chalk: "^5.4.1",
-    commander: "^13.1.0",
-    "conventional-changelog-angular": "^8.0.0",
-    "conventional-recommended-bump": "^11.0.0",
-    figlet: "^1.8.0",
-    "git-semver-tags": "^8.0.0",
-    semver: "^7.7.1"
-  },
-  packageManager: "pnpm@10.8.0+sha512.0e82714d1b5b43c74610193cb20734897c1d00de89d0e18420aebc5977fa13d780a9cb05734624e81ebd81cc876cd464794850641c48b9544326b5622ca29971"
+// src/utils/jsonOutput.ts
+var _jsonOutputMode = false;
+var _jsonData = {
+  dryRun: false,
+  updates: [],
+  tags: []
 };
+function enableJsonOutput(dryRun = false) {
+  _jsonOutputMode = true;
+  _jsonData.dryRun = dryRun;
+  _jsonData.updates = [];
+  _jsonData.tags = [];
+  _jsonData.commitMessage = void 0;
+}
+function isJsonOutputMode() {
+  return _jsonOutputMode;
+}
+function addPackageUpdate(packageName, newVersion, filePath) {
+  if (!_jsonOutputMode) return;
+  _jsonData.updates.push({
+    packageName,
+    newVersion,
+    filePath
+  });
+}
+function addTag(tag) {
+  if (!_jsonOutputMode) return;
+  _jsonData.tags.push(tag);
+}
+function setCommitMessage(message) {
+  if (!_jsonOutputMode) return;
+  _jsonData.commitMessage = message;
+}
+function printJsonOutput() {
+  if (_jsonOutputMode) {
+    console.log(JSON.stringify(_jsonData, null, 2));
+  }
+}
 
-// src/utils.ts
-import { getSemverTags } from "git-semver-tags";
+// src/utils/logging.ts
+function log(message, status = "info") {
+  if (isJsonOutputMode() && status !== "error") {
+    return;
+  }
+  let chalkFn;
+  switch (status) {
+    case "success":
+      chalkFn = chalk.green;
+      break;
+    case "warning":
+      chalkFn = chalk.yellow;
+      break;
+    case "error":
+      chalkFn = chalk.red;
+      break;
+    case "debug":
+      chalkFn = chalk.gray;
+      break;
+    default:
+      chalkFn = chalk.blue;
+  }
+  console.log(chalkFn(message));
+}
 
-// src/git.ts
-import { exec, execSync as syncExec } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
+// src/core/versionStrategies.ts
+import fs3 from "node:fs";
+import path2 from "node:path";
+
+// src/git/commands.ts
 import { cwd as cwd2 } from "node:process";
-var execAsync = (command) => {
+
+// src/git/commandExecutor.ts
+import { exec, execSync as nativeExecSync } from "node:child_process";
+var execAsync = (command, options) => {
+  const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
   return new Promise((resolve, reject) => {
-    const options = { maxBuffer: 1024 * 1024 * 10 };
     exec(
       command,
-      options,
+      defaultOptions,
       (error, stdout, stderr) => {
         if (error) {
           reject(error);
@@ -120,7 +166,33 @@ var execAsync = (command) => {
     );
   });
 };
-var execSync = (command, args) => syncExec(command, { maxBuffer: 1024 * 1024 * 10, ...args });
+var execSync = (command, args) => nativeExecSync(command, { maxBuffer: 1024 * 1024 * 10, ...args });
+
+// src/git/repository.ts
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+function isGitRepository(directory) {
+  const gitDir = join(directory, ".git");
+  if (!existsSync(gitDir)) {
+    return false;
+  }
+  const stats = statSync(gitDir);
+  if (!stats.isDirectory()) {
+    return false;
+  }
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd: directory });
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+function getCurrentBranch() {
+  const result = execSync("git rev-parse --abbrev-ref HEAD");
+  return result.toString().trim();
+}
+
+// src/git/commands.ts
 async function gitAdd(files) {
   const command = `git add ${files.join(" ")}`;
   return execAsync(command);
@@ -147,36 +219,12 @@ async function createGitTag(options) {
   const command = `git tag -a -m "${message}" ${tag} ${args}`;
   return execAsync(command);
 }
-function getCommitsLength(pkgRoot) {
-  try {
-    const gitCommand = `git rev-list --count HEAD ^$(git describe --tags --abbrev=0) ${pkgRoot}`;
-    const amount = execSync(gitCommand).toString().trim();
-    return Number(amount);
-  } catch {
-    return 0;
-  }
-}
-function isGitRepository(directory) {
-  const gitDir = join(directory, ".git");
-  if (!existsSync(gitDir)) {
-    return false;
-  }
-  const stats = statSync(gitDir);
-  if (!stats.isDirectory()) {
-    return false;
-  }
-  try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd: directory });
-    return true;
-  } catch (_error) {
-    return false;
+async function gitProcess(options) {
+  const { files, nextTag, commitMessage, skipHooks, dryRun } = options;
+  if (!isGitRepository(cwd2())) {
+    throw createGitError("NOT_GIT_REPO" /* NOT_GIT_REPO */);
   }
-}
-async function gitProcess({ files, nextTag, commitMessage, skipHooks, dryRun }) {
   try {
-    if (!isGitRepository(cwd2())) {
-      throw new Error("Not a git repository (or any parent up to mount point /)");
-    }
     if (!dryRun) {
       await gitAdd(files);
       await gitCommit({
@@ -191,503 +239,301 @@ async function gitProcess({ files, nextTag, commitMessage, skipHooks, dryRun })
         });
       }
     } else {
-      log("info", "[DRY RUN] Would add files:");
+      log("[DRY RUN] Would add files:", "info");
       for (const file of files) {
-        log("info", `  - ${file}`);
+        log(`  - ${file}`, "info");
       }
-      log("info", `[DRY RUN] Would commit with message: "${commitMessage}"`);
+      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
       if (nextTag) {
-        log("info", `[DRY RUN] Would create tag: ${nextTag}`);
+        log(`[DRY RUN] Would create tag: ${nextTag}`, "info");
       }
     }
   } catch (err) {
-    console.log(err);
     const errorMessage = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to create new version: ${errorMessage}`);
+    throw createGitError("GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */, errorMessage);
   }
 }
-async function lastMergeBranchName(branches, baseBranch) {
+async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, dryRun) {
   try {
-    const branchesRegex = `${branches.join("/(.*)|")}/(.*)`;
-    const command = `git for-each-ref --sort=-committerdate --format='%(refname:short)' refs/heads --merged ${baseBranch} | grep -o -i -E "${branchesRegex}" | awk -F'[ ]' '{print $1}' | head -n 1`;
-    const { stdout } = await execAsync(command);
-    return stdout.trim();
+    if (!files || files.length === 0) {
+      throw createGitError("NO_FILES" /* NO_FILES */);
+    }
+    if (!commitMessage) {
+      throw createGitError("NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */);
+    }
+    setCommitMessage(commitMessage);
+    if (nextTag) {
+      addTag(nextTag);
+    }
+    await gitProcess({
+      files,
+      nextTag,
+      commitMessage,
+      skipHooks,
+      dryRun
+    });
+    if (!dryRun) {
+      log(`Created tag: ${nextTag}`, "success");
+    }
   } catch (error) {
-    console.error(
-      "Error while getting the last branch name:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return null;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Failed to create git commit and tag: ${errorMessage}`, "error");
+    if (error instanceof Error) {
+      console.error(error.stack || error.message);
+    } else {
+      console.error(error);
+    }
+    throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
   }
 }
-function getCurrentBranch() {
-  const result = execSync("git rev-parse --abbrev-ref HEAD");
-  return result.toString().trim();
-}
 
-// src/utils.ts
-function printFiglet() {
-  const font = "Standard";
-  figlet.text(package_default.name, { font }, (err, data) => {
-    if (err) {
-      log("warning", "Could not print figlet banner: Figlet error");
-      console.error(err);
-      return;
-    }
-    if (data) {
-      const figletText = data;
-      const versionText = `v${package_default.version}`;
-      process.stdout.write(`${chalk.hex("#FF1F57")(figletText)}
-`);
-      process.stdout.write(`${chalk.hex("#0096FF")(versionText)}
+// src/git/tagsAndBranches.ts
+import { getSemverTags } from "git-semver-tags";
 
-`);
+// src/utils/formatting.ts
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatTag(version, tagPrefix) {
+  if (!tagPrefix) return version;
+  return tagPrefix.endsWith("/") ? `${tagPrefix}${version}` : `${tagPrefix}/${version}`;
+}
+function formatTagPrefix(tagPrefix, scope) {
+  if (!tagPrefix) return "";
+  const prefix = tagPrefix.replace(/\/$/, "");
+  if (scope) {
+    return `${prefix}/${scope}`;
+  }
+  return prefix;
+}
+function formatCommitMessage(template, version, scope) {
+  return createTemplateString(template, { version, scope });
+}
+function createTemplateString(template, variables) {
+  return Object.entries(variables).reduce((result, [key, value]) => {
+    if (value === void 0) {
+      return result;
     }
-  });
+    const regex = new RegExp(`\\$\\{${key}\\}`, "g");
+    return result.replace(regex, value);
+  }, template);
 }
-function log(status, message) {
-  const statusColors = {
-    info: chalk.blue("\u2139"),
-    success: chalk.green("\u2713"),
-    error: chalk.red("\u2717"),
-    warning: chalk.yellow("\u26A0")
-  };
-  process.stdout.write(`${statusColors[status]} ${message}
-`);
+
+// src/git/tagsAndBranches.ts
+function getCommitsLength(pkgRoot) {
+  try {
+    const gitCommand = `git rev-list --count HEAD ^$(git describe --tags --abbrev=0) ${pkgRoot}`;
+    const amount = execSync(gitCommand).toString().trim();
+    return Number(amount);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Failed to get number of commits since last tag: ${errorMessage}`, "error");
+    return 0;
+  }
 }
 async function getLatestTag() {
   try {
     const tags = await getSemverTags({});
     return tags[0] || "";
   } catch (error) {
-    log("error", "Failed to get latest tag");
-    console.error(error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Failed to get latest tag: ${errorMessage}`, "error");
     if (error instanceof Error && error.message.includes("No names found")) {
-      log("info", "No tags found in the repository.");
+      log("No tags found in the repository.", "info");
     }
     return "";
   }
 }
-function formatTag(options, props) {
-  const { name, synced, tagPrefix } = options;
-  const { version } = props;
-  if (!synced && name) {
-    return `${tagPrefix ? tagPrefix : ""}${name}@${version}`;
+async function lastMergeBranchName(branches, baseBranch) {
+  try {
+    const escapedBranches = branches.map((branch) => escapeRegExp(branch));
+    const branchesRegex = `${escapedBranches.join("/(.*)|")}/(.*)`;
+    const command = `git for-each-ref --sort=-committerdate --format='%(refname:short)' refs/heads --merged ${baseBranch} | grep -o -i -E "${branchesRegex}" | awk -F'[ ]' '{print $1}' | head -n 1`;
+    const { stdout } = await execAsync(command);
+    return stdout.trim();
+  } catch (error) {
+    console.error(
+      "Error while getting the last branch name:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
   }
-  return `${tagPrefix ? tagPrefix : "v"}${version}`;
-}
-function formatTagPrefix(tagPrefix) {
-  return tagPrefix ? `${tagPrefix}@` : "";
 }
-function createTemplateString(template, data) {
-  return template.replace(/\$\{([^}]+)\}/g, (_, key) => data[key] || "");
-}
-function formatCommitMessage(template, version) {
-  return createTemplateString(template, { version });
-}
-function updatePackageVersion({ path: path2, version, name, dryRun }) {
+
+// src/package/packageManagement.ts
+import fs2 from "node:fs";
+function updatePackageVersion(packagePath, version) {
   try {
-    const pkgPath = `${path2}/package.json`;
-    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
-    pkg.version = version;
-    if (!dryRun) {
-      fs2.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    const packageContent = fs2.readFileSync(packagePath, "utf8");
+    const packageJson = JSON.parse(packageContent);
+    const packageName = packageJson.name;
+    packageJson.version = version;
+    fs2.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
-      log("success", `${name}: ${version}`);
-    } else {
-      log("info", `[DRY RUN] Would update ${name} package.json to version ${version}`);
-    }
+    addPackageUpdate(packageName, version, packagePath);
+    log(`Updated package.json at ${packagePath} to version ${version}`, "success");
   } catch (error) {
-    log("error", `Failed to update ${name} to version ${version}`);
-    console.error(error);
+    log(`Failed to update package.json at ${packagePath}`, "error");
+    if (error instanceof Error) {
+      log(error.message, "error");
+    }
+    throw error;
   }
 }
 
-// src/versionEngine.ts
-import fs3 from "node:fs";
+// src/package/packageProcessor.ts
 import path from "node:path";
-import { cwd as cwd3, exit } from "node:process";
-import { getPackagesSync } from "@manypkg/get-packages";
+import { exit } from "node:process";
+
+// src/core/versionCalculator.ts
+import { cwd as cwd3 } from "node:process";
 import { Bumper } from "conventional-recommended-bump";
 import semver from "semver";
-var VersionEngine = class {
-  config;
-  constructor(config) {
-    this.config = config;
+async function calculateVersion(config, options) {
+  const { latestTag, type, path: path3, name, branchPattern, prereleaseIdentifier } = options;
+  const originalPrefix = config.tagPrefix || "v";
+  const initialVersion = prereleaseIdentifier ? `0.0.1-${prereleaseIdentifier}` : "0.0.1";
+  function determineTagSearchPattern(packageName, prefix) {
+    if (packageName) {
+      return prefix ? `${prefix}${packageName}@` : `${packageName}@`;
+    }
+    return prefix ? `${prefix}v` : "v";
   }
-  /**
-   * Calculate the next version based on options
-   */
-  async calculateVersion(options) {
-    const { latestTag, type, path: path2, name, branchPattern, prereleaseIdentifier } = options;
-    const originalPrefix = this.config.tagPrefix || "";
-    const initialVersion = prereleaseIdentifier ? `0.0.1-${prereleaseIdentifier}` : "0.0.1";
-    const tagSearchPattern = name ? originalPrefix ? `${originalPrefix}${name}@` : `${name}@` : originalPrefix ? `${originalPrefix}v` : "v";
-    let determinedReleaseType = type || null;
-    if (determinedReleaseType) {
-      if (!latestTag) {
-        return initialVersion;
-      }
-      const currentVersion = semver.clean(latestTag.replace(tagSearchPattern, "")) || "0.0.0";
-      return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+  const tagSearchPattern = determineTagSearchPattern(name, originalPrefix);
+  const escapedTagPattern = escapeRegExp(tagSearchPattern);
+  let determinedReleaseType = type || null;
+  if (determinedReleaseType) {
+    if (!latestTag) {
+      return initialVersion;
     }
-    if (this.config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
-      const currentBranch = await getCurrentBranch();
-      const mergeBranch = await lastMergeBranchName(branchPattern, this.config.baseBranch);
-      const branch = mergeBranch || currentBranch;
-      for (const pattern of branchPattern) {
-        const [match, releaseType] = pattern.split(":");
-        if (branch.includes(match) && releaseType) {
-          determinedReleaseType = releaseType;
-          break;
-        }
-      }
-      if (determinedReleaseType) {
-        if (!latestTag) {
-          return initialVersion;
-        }
-        const currentVersion = semver.clean(latestTag.replace(tagSearchPattern, "")) || "0.0.0";
-        return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+    const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+    return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+  }
+  if (config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
+    const currentBranch = await getCurrentBranch();
+    const mergeBranch = await lastMergeBranchName(branchPattern, config.baseBranch);
+    const branch = mergeBranch || currentBranch;
+    for (const pattern of branchPattern) {
+      const [match, releaseType] = pattern.split(":");
+      if (branch.includes(match) && releaseType) {
+        determinedReleaseType = releaseType;
+        break;
       }
     }
-    try {
-      const bumper = new Bumper();
-      bumper.loadPreset(this.config.preset);
-      const recommendedBump = await bumper.bump();
-      const releaseTypeFromCommits = recommendedBump.releaseType;
+    if (determinedReleaseType) {
       if (!latestTag) {
         return initialVersion;
       }
-      const checkPath = path2 || cwd3();
-      const commitsLength = await getCommitsLength(checkPath);
-      if (commitsLength === 0) {
-        log(
-          "info",
-          `No new commits found for ${name || "project"} since ${latestTag}, skipping version bump`
-        );
-        return "";
-      }
-      if (!releaseTypeFromCommits) {
-        log(
-          "info",
-          `No relevant commits found for ${name || "project"} since ${latestTag}, skipping version bump`
-        );
-        return "";
-      }
-      const currentVersion = semver.clean(latestTag.replace(tagSearchPattern, "")) || "0.0.0";
-      return semver.inc(currentVersion, releaseTypeFromCommits, prereleaseIdentifier) || "";
-    } catch (error) {
-      log("error", `Failed to calculate version for ${name || "project"}`);
-      console.error(error);
-      if (error instanceof Error && error.message.includes("No names found")) {
-        log("info", "No tags found, proceeding with initial version calculation (if applicable).");
-        return initialVersion;
-      }
-      return "";
-    }
-  }
-  /**
-   * Process packages based on discovery, skip list, and optional target list.
-   * Returns a list of package.json file paths that were updated (or would be in dry run).
-   */
-  async processPackages(discoveredPackages = [], targets = []) {
-    const { tagPrefix, skip, dryRun } = this.config;
-    const files = [];
-    const pkgsToConsider = discoveredPackages.filter((pkg) => {
-      if (skip == null ? void 0 : skip.includes(pkg.packageJson.name)) {
-        log("info", `Skipping package ${pkg.packageJson.name} based on config skip list.`);
-        return false;
-      }
-      if (targets.length > 0) {
-        const isTargeted = targets.includes(pkg.packageJson.name);
-        if (!isTargeted) {
-        }
-        return isTargeted;
-      }
-      return true;
-    });
-    log("info", `Found ${pkgsToConsider.length} package(s) to process after filtering.`);
-    for (const pkg of pkgsToConsider) {
-      const name = pkg.packageJson.name;
-      const pkgPath = pkg.dir;
-      const prefix = formatTagPrefix(tagPrefix);
-      const latestTag = await getLatestTag();
-      const nextVersion = await this.calculateVersion({
-        latestTag,
-        tagPrefix: prefix,
-        path: pkgPath,
-        name,
-        branchPattern: this.config.branchPattern,
-        baseBranch: this.config.baseBranch,
-        prereleaseIdentifier: this.config.prereleaseIdentifier,
-        type: this.config.forceType
-      });
-      if (!nextVersion) {
-        continue;
-      }
-      updatePackageVersion({
-        path: pkgPath,
-        version: nextVersion,
-        name,
-        dryRun
-      });
-      files.push(path.join(pkgPath, "package.json"));
-    }
-    return files;
-  }
-  /**
-   * Create git commit and tag
-   */
-  async createGitCommitAndTag(files, nextTag, commitMessage, dryRun) {
-    try {
-      await gitProcess({
-        files,
-        nextTag,
-        commitMessage,
-        skipHooks: this.config.skipHooks,
-        dryRun
-      });
-      if (!dryRun) {
-        log("success", `Created tag: ${nextTag}`);
-      }
-    } catch (error) {
-      log("error", "Failed to create git commit and tag");
-      console.error(error);
-      exit(1);
+      const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
     }
   }
-  /**
-   * Synced versioning strategy (all packages get the same version)
-   */
-  async syncedStrategy() {
-    var _a;
-    const {
-      tagPrefix,
-      baseBranch,
-      branchPattern,
-      commitMessage = "chore(release): v${version}",
-      prereleaseIdentifier
-    } = this.config;
-    const prefix = formatTagPrefix(tagPrefix);
-    const latestTag = await getLatestTag();
-    const nextVersion = await this.calculateVersion({
-      latestTag,
-      tagPrefix: prefix,
-      branchPattern,
-      baseBranch,
-      prereleaseIdentifier
-    });
-    if (!nextVersion) {
-      log("info", "No version change needed");
-      return;
+  try {
+    const bumper = new Bumper();
+    bumper.loadPreset(config.preset);
+    const recommendedBump = await bumper.bump();
+    const releaseTypeFromCommits = recommendedBump.releaseType;
+    if (!latestTag) {
+      return initialVersion;
     }
-    let pkgsResult;
-    try {
-      pkgsResult = getPackagesSync(cwd3());
-      if (!pkgsResult || !pkgsResult.packages) {
-        throw new Error("Failed to get packages information");
-      }
-    } catch (error) {
-      log("error", "Failed to get packages information");
-      console.error(error);
-      exit(1);
-      return;
+    const checkPath = path3 || cwd3();
+    const commitsLength = getCommitsLength(checkPath);
+    if (commitsLength === 0) {
+      log(
+        `No new commits found for ${name || "project"} since ${latestTag}, skipping version bump`,
+        "info"
+      );
+      return "";
     }
-    const files = [];
-    try {
-      const rootPkgPath = path.join(pkgsResult.root, "package.json");
-      if (fs3.existsSync(rootPkgPath)) {
-        updatePackageVersion({
-          path: pkgsResult.root,
-          version: nextVersion,
-          name: "root",
-          dryRun: this.config.dryRun
-        });
-        files.push(rootPkgPath);
-      }
-    } catch (_error) {
-      log("error", "Failed to update root package.json");
+    if (!releaseTypeFromCommits) {
+      log(
+        `No relevant commits found for ${name || "project"} since ${latestTag}, skipping version bump`,
+        "info"
+      );
+      return "";
     }
-    for (const pkg of pkgsResult.packages) {
-      if ((_a = this.config.skip) == null ? void 0 : _a.includes(pkg.packageJson.name)) {
-        continue;
-      }
-      updatePackageVersion({
-        path: pkg.dir,
-        version: nextVersion,
-        name: pkg.packageJson.name,
-        dryRun: this.config.dryRun
-      });
-      files.push(path.join(pkg.dir, "package.json"));
+    const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+    return semver.inc(currentVersion, releaseTypeFromCommits, prereleaseIdentifier) || "";
+  } catch (error) {
+    log(`Failed to calculate version for ${name || "project"}`, "error");
+    console.error(error);
+    if (error instanceof Error && error.message.includes("No names found")) {
+      log("No tags found, proceeding with initial version calculation (if applicable).", "info");
+      return initialVersion;
     }
-    const nextTag = formatTag(
-      { synced: true, tagPrefix },
-      { tagPrefix: prefix, version: nextVersion }
-    );
-    const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
-    await this.createGitCommitAndTag(files, nextTag, formattedCommitMessage, this.config.dryRun);
+    throw error;
+  }
+}
+
+// src/package/packageProcessor.ts
+var PackageProcessor = class {
+  skip;
+  targets;
+  tagPrefix;
+  commitMessageTemplate;
+  dryRun;
+  skipHooks;
+  getLatestTag;
+  config;
+  // Config for version calculation
+  fullConfig;
+  constructor(options) {
+    this.skip = options.skip || [];
+    this.targets = options.targets || [];
+    this.tagPrefix = options.tagPrefix || "v";
+    this.commitMessageTemplate = options.commitMessageTemplate || "";
+    this.dryRun = options.dryRun || false;
+    this.skipHooks = options.skipHooks || false;
+    this.getLatestTag = options.getLatestTag;
+    this.config = options.config;
+    this.fullConfig = options.fullConfig;
   }
   /**
-   * Single package versioning strategy
+   * Set package targets to process
    */
-  async singleStrategy() {
-    const {
-      packages: configPackages,
-      tagPrefix,
-      commitMessage = "chore(release): ${version}"
-    } = this.config;
-    if (configPackages.length !== 1) {
-      log("error", "Single mode requires exactly one package name");
-      exit(1);
-    }
-    const packageName = configPackages[0];
-    let pkgsResult;
-    try {
-      pkgsResult = getPackagesSync(cwd3());
-      if (!pkgsResult || !pkgsResult.packages) {
-        throw new Error("Failed to get packages information");
-      }
-    } catch (error) {
-      log("error", "Failed to get packages information");
-      console.error(error);
-      exit(1);
-      return;
-    }
-    const pkg = pkgsResult.packages.find((p) => p.packageJson.name === packageName);
-    if (!pkg) {
-      log("error", `Package ${packageName} not found`);
-      exit(1);
-    }
-    const pkgPath = pkg.dir;
-    const prefix = formatTagPrefix(tagPrefix);
-    const latestTag = await getLatestTag();
-    let nextVersion = void 0;
-    try {
-      nextVersion = await this.calculateVersion({
-        latestTag,
-        tagPrefix: prefix,
-        path: pkgPath,
-        name: packageName
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      log("error", `Failed to calculate version for ${packageName}: ${errorMessage}`);
-    }
-    if (nextVersion === void 0 || nextVersion === "") {
-      log("info", `No version change needed for ${packageName}`);
-      return;
-    }
-    updatePackageVersion({
-      path: pkgPath,
-      version: nextVersion,
-      name: packageName,
-      dryRun: this.config.dryRun
-    });
-    const nextTag = formatTag(
-      { tagPrefix, name: packageName, synced: false },
-      { tagPrefix: prefix, version: nextVersion }
-    );
-    const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
-    await this.createGitCommitAndTag(
-      [path.join(pkgPath, "package.json")],
-      nextTag,
-      formattedCommitMessage,
-      this.config.dryRun
-    );
+  setTargets(targets) {
+    this.targets = targets;
   }
   /**
-   * Async versioning strategy (each package gets its own version)
+   * Process packages based on targeting criteria
    */
-  async asyncStrategy(cliTargets = []) {
-    if (cliTargets.length > 0) {
-      await this.asyncTargetedStrategy(cliTargets);
-      return;
-    }
-    const {
-      commitMessage = "chore(release): ${version}",
-      // Align with test expectations
-      skipHooks
-    } = this.config;
-    let pkgsResult;
-    try {
-      pkgsResult = getPackagesSync(cwd3());
-      if (!pkgsResult || !pkgsResult.packages) {
-        throw new Error("Failed to get packages information");
-      }
-    } catch (error) {
-      log("error", "Failed to get packages information");
-      console.error(error);
-      exit(1);
-      return;
-    }
-    const pkgsToProcess = await this.processPackages(pkgsResult.packages, cliTargets);
-    if (pkgsToProcess.length === 0) {
-      log("info", "No packages to process based on changes and targets");
-      return;
-    }
-    const formattedCommitMessage = commitMessage;
-    try {
-      await gitProcess({
-        files: pkgsToProcess,
-        nextTag: "",
-        // No tag for default async
-        commitMessage: formattedCommitMessage,
-        skipHooks,
-        dryRun: this.config.dryRun
-      });
-      if (!this.config.dryRun) {
-        log("success", `Created version commit for ${pkgsToProcess.length} package(s)`);
-      }
-    } catch (error) {
-      log("error", "Failed to create version commit");
-      console.error(error);
-      exit(1);
-    }
-  }
-  // --- NEW METHOD for Async + Targeted ---
-  async asyncTargetedStrategy(cliTargets) {
+  async processPackages(packages) {
     var _a;
-    const {
-      tagPrefix,
-      skip,
-      dryRun,
-      skipHooks,
-      commitMessage: commitMessageTemplate
-    } = this.config;
+    const tags = [];
     const updatedPackagesInfo = [];
-    log("info", `Processing targeted packages: ${cliTargets.join(", ")}`);
-    let pkgsResult;
-    try {
-      pkgsResult = getPackagesSync(cwd3());
-      if (!pkgsResult || !pkgsResult.packages) {
-        throw new Error("Failed to get packages information");
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      log("error", `Failed to get packages information: ${errorMessage}`);
-      exit(1);
+    const tagPrefix = this.tagPrefix;
+    if (!packages || !Array.isArray(packages)) {
+      log("Invalid packages data provided. Expected array of packages.", "error");
+      return { updatedPackages: [], tags: [] };
     }
-    const pkgsToConsider = pkgsResult.packages.filter((pkg) => {
-      if (skip == null ? void 0 : skip.includes(pkg.packageJson.name)) {
-        log("info", `Skipping package ${pkg.packageJson.name} based on config skip list.`);
+    const pkgsToConsider = packages.filter((pkg) => {
+      var _a2;
+      const pkgName = pkg.packageJson.name;
+      if ((_a2 = this.skip) == null ? void 0 : _a2.includes(pkgName)) {
+        log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
         return false;
       }
-      const isTargeted = cliTargets.includes(pkg.packageJson.name);
+      if (!this.targets || this.targets.length === 0) {
+        return true;
+      }
+      const isTargeted = this.targets.includes(pkgName);
       if (!isTargeted) {
+        log(`Package ${pkgName} not in target list, skipping.`, "info");
       }
       return isTargeted;
     });
-    log("info", `Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`);
+    log(`Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`, "info");
     if (pkgsToConsider.length === 0) {
-      log("info", "No matching targeted packages found to process.");
-      return;
+      log("No matching targeted packages found to process.", "info");
+      return { updatedPackages: [], tags: [] };
     }
     for (const pkg of pkgsToConsider) {
       const name = pkg.packageJson.name;
       const pkgPath = pkg.dir;
       const prefix = formatTagPrefix(tagPrefix);
-      const latestTag = await getLatestTag();
-      const nextVersion = await this.calculateVersion({
+      const latestTagResult = await this.getLatestTag();
+      const latestTag = latestTagResult || "";
+      const nextVersion = await calculateVersion(this.fullConfig, {
         latestTag,
         tagPrefix: prefix,
         path: pkgPath,
@@ -700,111 +546,401 @@ var VersionEngine = class {
       if (!nextVersion) {
         continue;
       }
-      updatePackageVersion({
-        path: pkgPath,
-        version: nextVersion,
-        name,
-        dryRun
-      });
-      const packageTag = formatTag(
-        { synced: false, name, tagPrefix },
-        { version: nextVersion, tagPrefix }
-      );
+      updatePackageVersion(path.join(pkgPath, "package.json"), nextVersion);
+      const packageTag = formatTag(nextVersion, tagPrefix);
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
-      if (!dryRun) {
+      addTag(packageTag);
+      tags.push(packageTag);
+      if (!this.dryRun) {
         try {
           await createGitTag({ tag: packageTag, message: tagMessage });
-          log("success", `Created tag: ${packageTag}`);
+          log(`Created tag: ${packageTag}`, "success");
         } catch (tagError) {
           log(
-            "error",
-            `Failed to create tag ${packageTag} for ${name}: ${tagError.message}`
+            `Failed to create tag ${packageTag} for ${name}: ${tagError.message}`,
+            "error"
           );
-          log("error", tagError.stack || "No stack trace available");
+          log(tagError.stack || "No stack trace available", "error");
         }
       } else {
-        log("info", `[DRY RUN] Would create tag: ${packageTag}`);
+        log(`[DRY RUN] Would create tag: ${packageTag}`, "info");
       }
       updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
     }
     if (updatedPackagesInfo.length === 0) {
-      log("info", "No targeted packages required a version update.");
-      return;
+      log("No targeted packages required a version update.", "info");
+      return { updatedPackages: [], tags };
     }
     const filesToCommit = updatedPackagesInfo.map((info) => path.join(info.path, "package.json"));
     const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
     const representativeVersion = ((_a = updatedPackagesInfo[0]) == null ? void 0 : _a.version) || "multiple";
-    let commitMessage = commitMessageTemplate || "chore(release): publish packages";
+    let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
     if (updatedPackagesInfo.length === 1 && commitMessage.includes("${version}")) {
       commitMessage = formatCommitMessage(commitMessage, representativeVersion);
     } else {
       commitMessage = `chore(release): ${packageNames} ${representativeVersion}`;
     }
     commitMessage += " [skip-ci]";
-    if (!dryRun) {
+    setCommitMessage(commitMessage);
+    if (!this.dryRun) {
       try {
         await gitAdd(filesToCommit);
-        await gitCommit({ message: commitMessage, skipHooks });
-        log("success", `Created commit for targeted release: ${packageNames}`);
+        await gitCommit({ message: commitMessage, skipHooks: this.skipHooks });
+        log(`Created commit for targeted release: ${packageNames}`, "success");
       } catch (commitError) {
-        log("error", "Failed to create commit for targeted release.");
+        log("Failed to create commit for targeted release.", "error");
         console.error(commitError);
         exit(1);
       }
     } else {
-      log("info", "[DRY RUN] Would add files:");
+      log("[DRY RUN] Would add files:", "info");
       for (const file of filesToCommit) {
-        log("info", `  - ${file}`);
+        log(`  - ${file}`, "info");
+      }
+      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
+    }
+    return {
+      updatedPackages: updatedPackagesInfo,
+      commitMessage,
+      tags
+    };
+  }
+};
+
+// src/core/versionStrategies.ts
+function shouldProcessPackage(pkg, config, targets = []) {
+  var _a;
+  const pkgName = pkg.packageJson.name;
+  if ((_a = config.skip) == null ? void 0 : _a.includes(pkgName)) {
+    return false;
+  }
+  if (!targets || targets.length === 0) {
+    return true;
+  }
+  return targets.includes(pkgName);
+}
+function createSyncedStrategy(config) {
+  return async (packages) => {
+    try {
+      const {
+        tagPrefix,
+        baseBranch,
+        branchPattern,
+        commitMessage = "chore(release): v${version}",
+        prereleaseIdentifier,
+        dryRun,
+        skipHooks
+      } = config;
+      const prefix = formatTagPrefix(tagPrefix || "v");
+      const latestTag = await getLatestTag();
+      const nextVersion = await calculateVersion(config, {
+        latestTag,
+        tagPrefix: prefix,
+        branchPattern,
+        baseBranch,
+        prereleaseIdentifier
+      });
+      if (!nextVersion) {
+        log("No version change needed", "info");
+        return;
+      }
+      const files = [];
+      const updatedPackages = [];
+      try {
+        const rootPkgPath = path2.join(packages.root, "package.json");
+        if (fs3.existsSync(rootPkgPath)) {
+          updatePackageVersion(rootPkgPath, nextVersion);
+          files.push(rootPkgPath);
+          updatedPackages.push("root");
+        }
+      } catch (_error) {
+        log("Failed to update root package.json", "error");
+      }
+      for (const pkg of packages.packages) {
+        if (!shouldProcessPackage(pkg, config)) {
+          continue;
+        }
+        const packageJsonPath = path2.join(pkg.dir, "package.json");
+        updatePackageVersion(packageJsonPath, nextVersion);
+        files.push(packageJsonPath);
+        updatedPackages.push(pkg.packageJson.name);
+      }
+      if (updatedPackages.length > 0) {
+        log(`Updated ${updatedPackages.length} package(s) to version ${nextVersion}`, "success");
+      } else {
+        log("No packages were updated", "warning");
+        return;
+      }
+      const nextTag = formatTag(nextVersion, tagPrefix || "v");
+      const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
+      await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
+    } catch (error) {
+      if (error instanceof VersionError || error instanceof GitError) {
+        log(`Synced Strategy failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
+      } else {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Synced Strategy failed: ${errorMessage}`, "error");
+      }
+      throw error;
+    }
+  };
+}
+function createSingleStrategy(config) {
+  return async (packages) => {
+    try {
+      const {
+        packages: configPackages,
+        tagPrefix,
+        commitMessage = "chore(release): ${version}",
+        dryRun,
+        skipHooks
+      } = config;
+      if (!configPackages || configPackages.length !== 1) {
+        throw createVersionError(
+          "INVALID_CONFIG" /* INVALID_CONFIG */,
+          "Single mode requires exactly one package name"
+        );
+      }
+      const packageName = configPackages[0];
+      const pkg = packages.packages.find((p) => p.packageJson.name === packageName);
+      if (!pkg) {
+        throw createVersionError("PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */, packageName);
+      }
+      const pkgPath = pkg.dir;
+      const prefix = formatTagPrefix(tagPrefix || "v");
+      const latestTag = await getLatestTag();
+      let nextVersion = void 0;
+      try {
+        nextVersion = await calculateVersion(config, {
+          latestTag,
+          tagPrefix: prefix,
+          path: pkgPath,
+          name: packageName
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw createVersionError("VERSION_CALCULATION_ERROR" /* VERSION_CALCULATION_ERROR */, errorMessage);
+      }
+      if (nextVersion === void 0 || nextVersion === "") {
+        log(`No version change needed for ${packageName}`, "info");
+        return;
       }
-      log("info", `[DRY RUN] Would commit with message: "${commitMessage}"`);
+      const packageJsonPath = path2.join(pkgPath, "package.json");
+      updatePackageVersion(packageJsonPath, nextVersion);
+      log(`Updated package ${packageName} to version ${nextVersion}`, "success");
+      const nextTag = formatTag(nextVersion, tagPrefix || "v");
+      const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
+      await createGitCommitAndTag(
+        [packageJsonPath],
+        nextTag,
+        formattedCommitMessage,
+        skipHooks,
+        dryRun
+      );
+    } catch (error) {
+      if (error instanceof VersionError || error instanceof GitError) {
+        log(
+          `Single Package Strategy failed: ${error.message} (${error.code || "UNKNOWN"})`,
+          "error"
+        );
+      } else {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Single Package Strategy failed: ${errorMessage}`, "error");
+      }
+      throw error;
     }
+  };
+}
+function createAsyncStrategy(config) {
+  const dependencies = {
+    getLatestTag
+  };
+  const processorOptions = {
+    skip: config.skip || [],
+    targets: config.packages || [],
+    tagPrefix: config.tagPrefix || "v",
+    commitMessageTemplate: config.commitMessage || "",
+    dryRun: config.dryRun || false,
+    skipHooks: config.skipHooks || false,
+    getLatestTag: dependencies.getLatestTag,
+    fullConfig: config,
+    config: {
+      branchPattern: config.branchPattern || [],
+      baseBranch: config.baseBranch || "main",
+      prereleaseIdentifier: config.prereleaseIdentifier,
+      forceType: config.forceType
+    }
+  };
+  const packageProcessor = new PackageProcessor(processorOptions);
+  return async (packages, targets = []) => {
+    try {
+      const targetPackages = targets.length > 0 ? targets : config.packages || [];
+      packageProcessor.setTargets(targetPackages);
+      if (targetPackages.length > 0) {
+        log(`Processing targeted packages: ${targetPackages.join(", ")}`, "info");
+      } else {
+        log("No targets specified, processing all non-skipped packages", "info");
+      }
+      const result = await packageProcessor.processPackages(packages.packages);
+      if (result.updatedPackages.length === 0) {
+        log("No packages required a version update.", "info");
+      } else {
+        const packageNames = result.updatedPackages.map((p) => p.name).join(", ");
+        log(`Updated ${result.updatedPackages.length} package(s): ${packageNames}`, "success");
+        if (result.tags.length > 0) {
+          log(`Created ${result.tags.length} tag(s): ${result.tags.join(", ")}`, "success");
+        }
+        if (result.commitMessage) {
+          log(`Created commit with message: "${result.commitMessage}"`, "success");
+        }
+      }
+    } catch (error) {
+      if (error instanceof VersionError || error instanceof GitError) {
+        log(`Async Strategy failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
+      } else {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Async Strategy failed: ${errorMessage}`, "error");
+      }
+      throw error;
+    }
+  };
+}
+function createStrategy(config) {
+  var _a;
+  if (config.synced) {
+    return createSyncedStrategy(config);
+  }
+  if (((_a = config.packages) == null ? void 0 : _a.length) === 1) {
+    return createSingleStrategy(config);
+  }
+  return createAsyncStrategy(config);
+}
+function createStrategyMap(config) {
+  return {
+    synced: createSyncedStrategy(config),
+    single: createSingleStrategy(config),
+    async: createAsyncStrategy(config)
+  };
+}
+
+// src/core/versionEngine.ts
+var VersionEngine = class {
+  config;
+  jsonMode;
+  workspaceCache = null;
+  strategies;
+  currentStrategy;
+  constructor(config, jsonMode = false) {
+    if (!config) {
+      throw createVersionError("CONFIG_REQUIRED" /* CONFIG_REQUIRED */);
+    }
+    if (!config.preset) {
+      config.preset = "conventional-commits";
+      log("No preset specified, using default: conventional-commits", "warning");
+    }
+    this.config = config;
+    this.jsonMode = jsonMode;
+    this.strategies = createStrategyMap(config);
+    this.currentStrategy = createStrategy(config);
+  }
+  /**
+   * Get workspace packages information - with caching for performance
+   */
+  async getWorkspacePackages() {
+    try {
+      if (this.workspaceCache) {
+        return this.workspaceCache;
+      }
+      const pkgsResult = getPackagesSync(cwd4());
+      if (!pkgsResult || !pkgsResult.packages) {
+        throw createVersionError("PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */);
+      }
+      this.workspaceCache = pkgsResult;
+      return pkgsResult;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log(`Failed to get packages information: ${errorMessage}`, "error");
+      console.error(error);
+      throw createVersionError("WORKSPACE_ERROR" /* WORKSPACE_ERROR */, errorMessage);
+    }
+  }
+  /**
+   * Run the current strategy
+   * @param targets Optional package targets to process (only used by async strategy)
+   */
+  async run(targets = []) {
+    try {
+      const packages = await this.getWorkspacePackages();
+      return this.currentStrategy(packages, targets);
+    } catch (error) {
+      if (error instanceof VersionError || error instanceof GitError) {
+        log(`Version engine failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
+      } else {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Version engine failed: ${errorMessage}`, "error");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Change the current strategy
+   * @param strategyType The strategy type to use: 'synced', 'single', or 'async'
+   */
+  setStrategy(strategyType) {
+    this.currentStrategy = this.strategies[strategyType];
   }
 };
 
 // src/index.ts
 async function run() {
-  printFiglet();
   const program = new Command();
   program.name("package-versioner").description(
-    "Automated semantic versioning based on Git history and conventional commits. Supports monorepos with synchronized or independent package versioning strategies."
-  ).version("0.0.2").option("--config <path>", "Path to the configuration file").option("--dry-run", "Simulate the versioning process without making changes").option("--synced", "Force synced versioning strategy (overrides config)").option("--bump <type>", "Force a specific release type (patch, minor, major)").option(
-    "--prerelease <identifier>",
-    "Create a prerelease version with the specified identifier"
-  ).option(
-    "-t, --target <targets>",
-    "Comma-separated list of package names to target (only for async strategy)"
-  ).parse(process.argv);
+    "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits."
+  ).version(process.env.npm_package_version || "0.0.0").option(
+    "-c, --config <path>",
+    "Path to config file (defaults to version.config.json in current directory)"
+  ).option("-d, --dry-run", "Dry run (no changes made)", false).option("-b, --bump <type>", "Force specific bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --synced", "Force synchronized versioning across all packages").option("-j, --json", "Output results as JSON", false).option("-t, --target <packages>", "Comma-delimited list of package names to target").parse(process.argv);
   const options = program.opts();
+  if (options.json) {
+    enableJsonOutput(options.dryRun);
+  }
   try {
     const config = await loadConfig(options.config);
-    log("info", `Loaded configuration from ${options.config || "version.config.json"}`);
+    log(`Loaded configuration from ${options.config || "version.config.json"}`, "info");
     if (options.dryRun) config.dryRun = true;
     if (options.synced) config.synced = true;
     if (options.bump) config.forceType = options.bump;
     if (options.prerelease)
       config.prereleaseIdentifier = options.prerelease === true ? "rc" : options.prerelease;
     const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
-    const engine = new VersionEngine(config);
+    const engine = new VersionEngine(config, !!options.json);
     if (config.synced) {
-      log("info", "Using synced versioning strategy.");
-      await engine.syncedStrategy();
+      log("Using synced versioning strategy.", "info");
+      engine.setStrategy("synced");
+      await engine.run();
     } else if (config.packages && config.packages.length === 1) {
-      log("info", "Using single package versioning strategy.");
+      log("Using single package versioning strategy.", "info");
       if (cliTargets.length > 0) {
-        log("warning", "--target flag is ignored for single package strategy.");
+        log("--target flag is ignored for single package strategy.", "warning");
       }
-      await engine.singleStrategy();
+      engine.setStrategy("single");
+      await engine.run();
     } else {
-      log("info", "Using async versioning strategy.");
+      log("Using async versioning strategy.", "info");
       if (cliTargets.length > 0) {
-        log("info", `Targeting specific packages: ${cliTargets.join(", ")}`);
+        log(`Targeting specific packages: ${cliTargets.join(", ")}`, "info");
       }
-      await engine.asyncStrategy(cliTargets);
+      engine.setStrategy("async");
+      await engine.run(cliTargets);
     }
-    log("success", "Versioning process completed.");
+    log("Versioning process completed.", "success");
+    printJsonOutput();
   } catch (error) {
-    log("error", error instanceof Error ? error.message : String(error));
+    log(error instanceof Error ? error.message : String(error), "error");
     process.exit(1);
   }
 }
-run();
+run().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});