package-versioner 0.7.0 → 0.7.1

package/README.md

@@ -5,7 +5,7 @@
   <img src="https://img.shields.io/npm/v/package-versioner" /></a>
 <a href="https://www.npmjs.com/package/package-versioner" alt="NPM Downloads">
   <img src="https://img.shields.io/npm/dw/package-versioner" /></a>
-
+<br/><br/>
 A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits. Supports both single package projects and monorepos with flexible versioning strategies.
 
 ## Features
@@ -103,14 +103,13 @@ Customize behavior by creating a `version.config.json` file in your project root
   "commitMessage": "chore: release ${packageName}@${version} [skip ci]",
   "updateChangelog": true,
   "changelogFormat": "keep-a-changelog",
-  "monorepo": {
-    "synced": true,
-    "skip": [
-      "docs",
-      "e2e"
-    ],
-    "packagePath": "packages"
-  },
+  "synced": true,
+  "skip": [
+    "docs",
+    "e2e"
+  ],
+  "packages": ["packages/*"],
+  "mainPackage": "primary-package",
   "cargo": {
     "enabled": true,
     "paths": ["src/", "crates/"]
@@ -118,15 +117,28 @@ Customize behavior by creating a `version.config.json` file in your project root
 }
 ```
 
-**Notes:** 
-- Options like `synced`, `packages`, and `updateInternalDependencies` enable monorepo-specific behaviours.
-- The `tagTemplate` and `packageTagTemplate` allow you to customize how Git tags are formatted for releases.
-- The `commitMessage` template can include CI skip tokens like `[skip ci]` if you want to prevent CI runs after version commits (e.g., `"commitMessage": "chore: release ${packageName}@${version} [skip ci]"`). See [CI/CD Integration](./docs/CI_CD_INTEGRATION.md) for more details.
-- The `updateChangelog` option controls whether to automatically generate and update changelogs for each package (default: true).
-- The `changelogFormat` option sets the changelog style to either "keep-a-changelog" (default) or "angular".
-- The `cargo` options can help when working with Rust projects:
-  - `enabled` (default: `true`): Set to `false` to disable Cargo.toml version handling
-  - `paths` (optional): Specify directories to search for Cargo.toml files
+### Configuration Options
+
+#### General Options (All Projects)
+- `preset`: Conventional commits preset to use for version calculation (default: "angular")
+- `versionPrefix`: Prefix for version numbers in tags (default: "v")
+- `tagTemplate`: Template for Git tags (default: "${prefix}${version}")
+- `commitMessage`: Template for commit messages (default: "chore(release): ${version}")
+- `updateChangelog`: Whether to automatically update changelogs (default: true)
+- `changelogFormat`: Format for changelogs - "keep-a-changelog" or "angular" (default: "keep-a-changelog")
+- `cargo`: Options for Rust projects:
+  - `enabled`: Whether to handle Cargo.toml files (default: true)
+  - `paths`: Directories to search for Cargo.toml files (optional)
+
+#### Monorepo-Specific Options
+- `synced`: Whether all packages should be versioned together (default: true)
+- `skip`: Array of package names to exclude from versioning
+- `packages`: Glob patterns for package discovery (e.g., ["packages/*"])
+- `mainPackage`: Package name whose commit history should drive version determination
+- `packageTagTemplate`: Template for package-specific Git tags (default: "${packageName}@${prefix}${version}")
+- `updateInternalDependencies`: How to update internal dependencies ("patch", "minor", "major", or "inherit")
+
+For more details on CI/CD integration and advanced usage, see [CI/CD Integration](./docs/CI_CD_INTEGRATION.md).
 
 ## How Versioning Works
 

package/dist/index.cjs

@@ -732,6 +732,11 @@ async function gitProcess(options) {
     }
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
+    log(`Git process error: ${errorMessage}`, "error");
+    if (err instanceof Error && err.stack) {
+      console.error("Git process stack trace:");
+      console.error(err.stack);
+    }
     throw createGitError("GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */, errorMessage);
   }
 }
@@ -761,9 +766,16 @@ async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, d
     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("Git operation error details:");
       console.error(error.stack || error.message);
+      if (errorMessage.includes("Command failed:")) {
+        const cmdOutput = errorMessage.split("Command failed:")[1];
+        if (cmdOutput) {
+          console.error("Git command output:", cmdOutput.trim());
+        }
+      }
     } else {
-      console.error(error);
+      console.error("Unknown git error:", error);
     }
     throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
   }
@@ -1917,16 +1929,41 @@ function createSyncedStrategy(config) {
         commitMessage = "chore(release): v${version}",
         prereleaseIdentifier,
         dryRun,
-        skipHooks
+        skipHooks,
+        mainPackage
       } = config;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
       const latestTag = await getLatestTag();
+      let mainPkgPath = packages.root;
+      let mainPkgName;
+      if (mainPackage) {
+        const mainPkg = packages.packages.find((p) => p.packageJson.name === mainPackage);
+        if (mainPkg) {
+          mainPkgPath = mainPkg.dir;
+          mainPkgName = mainPkg.packageJson.name;
+          log(`Using ${mainPkgName} as primary package for version determination`, "info");
+        } else {
+          log(
+            `Main package '${mainPackage}' not found. Using root package for version determination.`,
+            "warning"
+          );
+        }
+      }
+      if (!mainPkgPath) {
+        mainPkgPath = process.cwd();
+        log(
+          `No valid package path found, using current working directory: ${mainPkgPath}`,
+          "warning"
+        );
+      }
       const nextVersion = await calculateVersion(config, {
         latestTag,
         versionPrefix: formattedPrefix,
         branchPattern,
         baseBranch,
         prereleaseIdentifier,
+        path: mainPkgPath,
+        name: mainPkgName,
         type: config.type
       });
       if (!nextVersion) {
@@ -1936,11 +1973,15 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path7.join(packages.root, "package.json");
-        if (import_node_fs7.default.existsSync(rootPkgPath)) {
-          updatePackageVersion(rootPkgPath, nextVersion);
-          files.push(rootPkgPath);
-          updatedPackages.push("root");
+        if (packages.root) {
+          const rootPkgPath = path7.join(packages.root, "package.json");
+          if (import_node_fs7.default.existsSync(rootPkgPath)) {
+            updatePackageVersion(rootPkgPath, nextVersion);
+            files.push(rootPkgPath);
+            updatedPackages.push("root");
+          }
+        } else {
+          log("Root package path is undefined, skipping root package.json update", "warning");
         }
       } catch (error) {
         const errMessage = error instanceof Error ? error.message : String(error);
@@ -1980,6 +2021,7 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
+        mainPackage,
         versionPrefix,
         tagTemplate,
         packageTagTemplate,
@@ -1987,13 +2029,17 @@ function createSingleStrategy(config) {
         dryRun,
         skipHooks
       } = config;
-      if (!configPackages || configPackages.length !== 1) {
+      let packageName;
+      if (mainPackage) {
+        packageName = mainPackage;
+      } else if (configPackages && configPackages.length === 1) {
+        packageName = configPackages[0];
+      } else {
         throw createVersionError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          "Single mode requires exactly one package name"
+          "Single mode requires either mainPackage or exactly one package in the packages array"
         );
       }
-      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);
@@ -2117,7 +2163,7 @@ function createStrategy(config) {
   if (config.synced) {
     return createSyncedStrategy(config);
   }
-  if (((_a = config.packages) == null ? void 0 : _a.length) === 1) {
+  if (config.mainPackage || ((_a = config.packages) == null ? void 0 : _a.length) === 1) {
     return createSingleStrategy(config);
   }
   return createAsyncStrategy(config);
@@ -2162,6 +2208,13 @@ var VersionEngine = class {
       if (!pkgsResult || !pkgsResult.packages) {
         throw createVersionError("PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */);
       }
+      if (!pkgsResult.root) {
+        log(
+          "Root path is undefined in packages result, setting to current working directory",
+          "warning"
+        );
+        pkgsResult.root = (0, import_node_process5.cwd)();
+      }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
     } catch (error) {
@@ -2182,9 +2235,22 @@ var VersionEngine = class {
     } catch (error) {
       if (error instanceof VersionError || error instanceof GitError) {
         log(`Version engine failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
+        if (error instanceof GitError) {
+          console.error("Git error details:");
+          if (error.message.includes("Command failed:")) {
+            const cmdOutput = error.message.split("Command failed:")[1];
+            if (cmdOutput) {
+              console.error("Command output:", cmdOutput.trim());
+            }
+          }
+        }
       } else {
         const errorMessage = error instanceof Error ? error.message : String(error);
         log(`Version engine failed: ${errorMessage}`, "error");
+        if (error instanceof Error && error.stack) {
+          console.error("Error stack trace:");
+          console.error(error.stack);
+        }
       }
       throw error;
     }
@@ -2263,6 +2329,16 @@ async function run() {
         printJsonOutput();
       } catch (error) {
         log(error instanceof Error ? error.message : String(error), "error");
+        if (error instanceof Error) {
+          console.error("Error details:");
+          console.error(error.stack || error.message);
+          if (error.message.includes("Command failed:")) {
+            const cmdOutput = error.message.split("Command failed:")[1];
+            if (cmdOutput) {
+              console.error("Command output:", cmdOutput.trim());
+            }
+          }
+        }
         process.exit(1);
       }
     });

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as fs9 from "node:fs";
-import path7 from "node:path";
+import * as fs10 from "fs";
+import path8 from "path";
 import { Command } from "commander";
 
 // src/changelog/changelogRegenerator.ts
-import { execSync as execSync2 } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
+import { execSync as execSync2 } from "child_process";
+import fs from "fs";
+import path from "path";
 
 // src/utils/logging.ts
 import chalk from "chalk";
@@ -92,7 +92,7 @@ function log(message, level = "info") {
 }
 
 // src/changelog/commitParser.ts
-import { execSync } from "node:child_process";
+import { execSync } from "child_process";
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
 var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
 function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
@@ -521,8 +521,8 @@ async function writeChangelog(content, outputPath, dryRun) {
 }
 
 // src/config.ts
-import * as fs2 from "node:fs";
-import { cwd } from "node:process";
+import * as fs2 from "fs";
+import { cwd } from "process";
 function loadConfig(configPath) {
   const localProcess = cwd();
   const filePath = configPath || `${localProcess}/version.config.json`;
@@ -544,7 +544,7 @@ function loadConfig(configPath) {
 }
 
 // src/core/versionEngine.ts
-import { cwd as cwd4 } from "node:process";
+import { cwd as cwd4 } from "process";
 import { getPackagesSync } from "@manypkg/get-packages";
 
 // src/errors/gitError.ts
@@ -591,14 +591,14 @@ function createVersionError(code, details) {
 }
 
 // src/core/versionStrategies.ts
-import fs8 from "node:fs";
-import * as path6 from "node:path";
+import fs9 from "fs";
+import * as path7 from "path";
 
 // src/git/commands.ts
-import { cwd as cwd2 } from "node:process";
+import { cwd as cwd2 } from "process";
 
 // src/git/commandExecutor.ts
-import { exec, execSync as nativeExecSync } from "node:child_process";
+import { exec, execSync as nativeExecSync } from "child_process";
 var execAsync = (command, options) => {
   const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
   return new Promise((resolve, reject) => {
@@ -618,8 +618,8 @@ var execAsync = (command, options) => {
 var execSync3 = (command, args) => nativeExecSync(command, { maxBuffer: 1024 * 1024 * 10, ...args });
 
 // src/git/repository.ts
-import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
 function isGitRepository(directory) {
   const gitDir = join(directory, ".git");
   if (!existsSync(gitDir)) {
@@ -699,6 +699,11 @@ async function gitProcess(options) {
     }
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
+    log(`Git process error: ${errorMessage}`, "error");
+    if (err instanceof Error && err.stack) {
+      console.error("Git process stack trace:");
+      console.error(err.stack);
+    }
     throw createGitError("GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */, errorMessage);
   }
 }
@@ -728,9 +733,16 @@ async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, d
     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("Git operation error details:");
       console.error(error.stack || error.message);
+      if (errorMessage.includes("Command failed:")) {
+        const cmdOutput = errorMessage.split("Command failed:")[1];
+        if (cmdOutput) {
+          console.error("Git command output:", cmdOutput.trim());
+        }
+      }
     } else {
-      console.error(error);
+      console.error("Unknown git error:", error);
     }
     throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
   }
@@ -878,11 +890,12 @@ async function getLatestTagForPackage(packageName, versionPrefix) {
 }
 
 // src/package/packageManagement.ts
-import fs4 from "node:fs";
+import fs4 from "fs";
+import path3 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs3 from "node:fs";
-import path2 from "node:path";
+import fs3 from "fs";
+import path2 from "path";
 import * as TOML from "smol-toml";
 function getCargoInfo(cargoPath) {
   var _a;
@@ -968,13 +981,13 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs7 from "node:fs";
-import path5 from "node:path";
-import { exit } from "node:process";
+import * as fs8 from "fs";
+import path6 from "path";
+import { exit } from "process";
 
 // src/changelog/changelogManager.ts
-import * as fs5 from "node:fs";
-import * as path3 from "node:path";
+import * as fs5 from "fs";
+import * as path4 from "path";
 function createChangelog(_packagePath, packageName) {
   return {
     projectName: packageName,
@@ -990,7 +1003,7 @@ function parseChangelog(filePath) {
     fs5.readFileSync(filePath, "utf8");
     log(`Parsed changelog at ${filePath}`, "info");
     return {
-      projectName: path3.basename(path3.dirname(filePath)),
+      projectName: path4.basename(path4.dirname(filePath)),
       unreleased: [],
       versions: []
     };
@@ -1259,7 +1272,7 @@ function generateChangelogContent(changelog, repoUrl, format = "keep-a-changelog
 }
 function updateChangelog(packagePath, packageName, version, entries, repoUrl, format = "keep-a-changelog") {
   try {
-    const changelogPath = path3.join(packagePath, "CHANGELOG.md");
+    const changelogPath = path4.join(packagePath, "CHANGELOG.md");
     let changelog;
     if (fs5.existsSync(changelogPath)) {
       const existingChangelog = parseChangelog(changelogPath);
@@ -1298,16 +1311,16 @@ function capitalizeFirstLetter(input) {
 }
 
 // src/core/versionCalculator.ts
-import { cwd as cwd3 } from "node:process";
+import { cwd as cwd3 } from "process";
 import { Bumper } from "conventional-recommended-bump";
 import semver2 from "semver";
 
 // src/utils/manifestHelpers.ts
-import fs6 from "node:fs";
-import path4 from "node:path";
+import fs6 from "fs";
+import path5 from "path";
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path4.join(packageDir, "package.json");
-  const cargoTomlPath = path4.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
   if (fs6.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
@@ -1352,14 +1365,15 @@ function getVersionFromManifests(packageDir) {
   };
 }
 function throwIfNoManifestsFound(packageDir) {
-  const packageJsonPath = path4.join(packageDir, "package.json");
-  const cargoTomlPath = path4.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
   throw new Error(
     `Neither package.json nor Cargo.toml found at ${packageDir}. Checked paths: ${packageJsonPath}, ${cargoTomlPath}. Cannot determine version.`
   );
 }
 
 // src/utils/versionUtils.ts
+import fs7 from "fs";
 import semver from "semver";
 import * as TOML2 from "smol-toml";
 var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
@@ -1719,9 +1733,9 @@ var PackageProcessor = class {
         }
         let repoUrl;
         try {
-          const packageJsonPath2 = path5.join(pkgPath, "package.json");
-          if (fs7.existsSync(packageJsonPath2)) {
-            const packageJson = JSON.parse(fs7.readFileSync(packageJsonPath2, "utf8"));
+          const packageJsonPath2 = path6.join(pkgPath, "package.json");
+          if (fs8.existsSync(packageJsonPath2)) {
+            const packageJson = JSON.parse(fs8.readFileSync(packageJsonPath2, "utf8"));
             if (packageJson.repository) {
               if (typeof packageJson.repository === "string") {
                 repoUrl = packageJson.repository;
@@ -1748,8 +1762,8 @@ var PackageProcessor = class {
           this.fullConfig.changelogFormat
         );
       }
-      const packageJsonPath = path5.join(pkgPath, "package.json");
-      if (fs7.existsSync(packageJsonPath)) {
+      const packageJsonPath = path6.join(pkgPath, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion);
       }
       const cargoEnabled = ((_a = this.fullConfig.cargo) == null ? void 0 : _a.enabled) !== false;
@@ -1757,14 +1771,14 @@ var PackageProcessor = class {
         const cargoPaths = (_b = this.fullConfig.cargo) == null ? void 0 : _b.paths;
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path5.resolve(pkgPath, cargoPath, "Cargo.toml");
-            if (fs7.existsSync(resolvedCargoPath)) {
+            const resolvedCargoPath = path6.resolve(pkgPath, cargoPath, "Cargo.toml");
+            if (fs8.existsSync(resolvedCargoPath)) {
               updatePackageVersion(resolvedCargoPath, nextVersion);
             }
           }
         } else {
-          const cargoTomlPath = path5.join(pkgPath, "Cargo.toml");
-          if (fs7.existsSync(cargoTomlPath)) {
+          const cargoTomlPath = path6.join(pkgPath, "Cargo.toml");
+          if (fs8.existsSync(cargoTomlPath)) {
             updatePackageVersion(cargoTomlPath, nextVersion);
           }
         }
@@ -1801,8 +1815,8 @@ var PackageProcessor = class {
     }
     const filesToCommit = [];
     for (const info of updatedPackagesInfo) {
-      const packageJsonPath = path5.join(info.path, "package.json");
-      if (fs7.existsSync(packageJsonPath)) {
+      const packageJsonPath = path6.join(info.path, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
         filesToCommit.push(packageJsonPath);
       }
       const cargoEnabled = ((_c = this.fullConfig.cargo) == null ? void 0 : _c.enabled) !== false;
@@ -1810,14 +1824,14 @@ var PackageProcessor = class {
         const cargoPaths = (_d = this.fullConfig.cargo) == null ? void 0 : _d.paths;
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path5.resolve(info.path, cargoPath, "Cargo.toml");
-            if (fs7.existsSync(resolvedCargoPath)) {
+            const resolvedCargoPath = path6.resolve(info.path, cargoPath, "Cargo.toml");
+            if (fs8.existsSync(resolvedCargoPath)) {
               filesToCommit.push(resolvedCargoPath);
             }
           }
         } else {
-          const cargoTomlPath = path5.join(info.path, "Cargo.toml");
-          if (fs7.existsSync(cargoTomlPath)) {
+          const cargoTomlPath = path6.join(info.path, "Cargo.toml");
+          if (fs8.existsSync(cargoTomlPath)) {
             filesToCommit.push(cargoTomlPath);
           }
         }
@@ -1882,16 +1896,41 @@ function createSyncedStrategy(config) {
         commitMessage = "chore(release): v${version}",
         prereleaseIdentifier,
         dryRun,
-        skipHooks
+        skipHooks,
+        mainPackage
       } = config;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
       const latestTag = await getLatestTag();
+      let mainPkgPath = packages.root;
+      let mainPkgName;
+      if (mainPackage) {
+        const mainPkg = packages.packages.find((p) => p.packageJson.name === mainPackage);
+        if (mainPkg) {
+          mainPkgPath = mainPkg.dir;
+          mainPkgName = mainPkg.packageJson.name;
+          log(`Using ${mainPkgName} as primary package for version determination`, "info");
+        } else {
+          log(
+            `Main package '${mainPackage}' not found. Using root package for version determination.`,
+            "warning"
+          );
+        }
+      }
+      if (!mainPkgPath) {
+        mainPkgPath = process.cwd();
+        log(
+          `No valid package path found, using current working directory: ${mainPkgPath}`,
+          "warning"
+        );
+      }
       const nextVersion = await calculateVersion(config, {
         latestTag,
         versionPrefix: formattedPrefix,
         branchPattern,
         baseBranch,
         prereleaseIdentifier,
+        path: mainPkgPath,
+        name: mainPkgName,
         type: config.type
       });
       if (!nextVersion) {
@@ -1901,11 +1940,15 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path6.join(packages.root, "package.json");
-        if (fs8.existsSync(rootPkgPath)) {
-          updatePackageVersion(rootPkgPath, nextVersion);
-          files.push(rootPkgPath);
-          updatedPackages.push("root");
+        if (packages.root) {
+          const rootPkgPath = path7.join(packages.root, "package.json");
+          if (fs9.existsSync(rootPkgPath)) {
+            updatePackageVersion(rootPkgPath, nextVersion);
+            files.push(rootPkgPath);
+            updatedPackages.push("root");
+          }
+        } else {
+          log("Root package path is undefined, skipping root package.json update", "warning");
         }
       } catch (error) {
         const errMessage = error instanceof Error ? error.message : String(error);
@@ -1915,7 +1958,7 @@ function createSyncedStrategy(config) {
         if (!shouldProcessPackage(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path6.join(pkg.dir, "package.json");
+        const packageJsonPath = path7.join(pkg.dir, "package.json");
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
@@ -1945,6 +1988,7 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
+        mainPackage,
         versionPrefix,
         tagTemplate,
         packageTagTemplate,
@@ -1952,13 +1996,17 @@ function createSingleStrategy(config) {
         dryRun,
         skipHooks
       } = config;
-      if (!configPackages || configPackages.length !== 1) {
+      let packageName;
+      if (mainPackage) {
+        packageName = mainPackage;
+      } else if (configPackages && configPackages.length === 1) {
+        packageName = configPackages[0];
+      } else {
         throw createVersionError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          "Single mode requires exactly one package name"
+          "Single mode requires either mainPackage or exactly one package in the packages array"
         );
       }
-      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);
@@ -1988,7 +2036,7 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path6.join(pkgPath, "package.json");
+      const packageJsonPath = path7.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion);
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
       const nextTag = formatTag(
@@ -2082,7 +2130,7 @@ function createStrategy(config) {
   if (config.synced) {
     return createSyncedStrategy(config);
   }
-  if (((_a = config.packages) == null ? void 0 : _a.length) === 1) {
+  if (config.mainPackage || ((_a = config.packages) == null ? void 0 : _a.length) === 1) {
     return createSingleStrategy(config);
   }
   return createAsyncStrategy(config);
@@ -2127,6 +2175,13 @@ var VersionEngine = class {
       if (!pkgsResult || !pkgsResult.packages) {
         throw createVersionError("PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */);
       }
+      if (!pkgsResult.root) {
+        log(
+          "Root path is undefined in packages result, setting to current working directory",
+          "warning"
+        );
+        pkgsResult.root = cwd4();
+      }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
     } catch (error) {
@@ -2147,9 +2202,22 @@ var VersionEngine = class {
     } catch (error) {
       if (error instanceof VersionError || error instanceof GitError) {
         log(`Version engine failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
+        if (error instanceof GitError) {
+          console.error("Git error details:");
+          if (error.message.includes("Command failed:")) {
+            const cmdOutput = error.message.split("Command failed:")[1];
+            if (cmdOutput) {
+              console.error("Command output:", cmdOutput.trim());
+            }
+          }
+        }
       } else {
         const errorMessage = error instanceof Error ? error.message : String(error);
         log(`Version engine failed: ${errorMessage}`, "error");
+        if (error instanceof Error && error.stack) {
+          console.error("Error stack trace:");
+          console.error(error.stack);
+        }
       }
       throw error;
     }
@@ -2166,11 +2234,11 @@ var VersionEngine = class {
 // src/index.ts
 function getPackageVersion() {
   try {
-    const packageJsonPath = path7.resolve(
-      path7.dirname(import.meta.url.replace("file:", "")),
+    const packageJsonPath = path8.resolve(
+      path8.dirname(import.meta.url.replace("file:", "")),
       "../package.json"
     );
-    const packageJsonContent = fs9.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = fs10.readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     return packageJson.version || "0.0.0";
   } catch (error) {
@@ -2227,6 +2295,16 @@ async function run() {
         printJsonOutput();
       } catch (error) {
         log(error instanceof Error ? error.message : String(error), "error");
+        if (error instanceof Error) {
+          console.error("Error details:");
+          console.error(error.stack || error.message);
+          if (error.message.includes("Command failed:")) {
+            const cmdOutput = error.message.split("Command failed:")[1];
+            if (cmdOutput) {
+              console.error("Command output:", cmdOutput.trim());
+            }
+          }
+        }
         process.exit(1);
       }
     });
@@ -2253,7 +2331,7 @@ async function run() {
         const content = await regenerateChangelog(regenerateOptions);
         await writeChangelog(
           content,
-          path7.resolve(options.projectDir, options.output),
+          path8.resolve(options.projectDir, options.output),
           options.dryRun
         );
         if (!options.dryRun) {

package/package-versioner.schema.json

@@ -56,6 +56,11 @@
       "default": [],
       "description": "List of packages to include in versioning"
     },
+    "mainPackage": {
+      "type": "string",
+      "minLength": 1,
+      "description": "The package to use for version determination"
+    },
     "versionStrategy": {
       "type": "string",
       "enum": ["branchPattern", "commitMessage"],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "package-versioner",
   "description": "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits.",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -39,23 +39,23 @@
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@types/figlet": "^1.5.5",
-    "@types/node": "^22.15.17",
+    "@types/node": "^24.0.3",
     "@types/semver": "^7.3.13",
-    "@vitest/coverage-v8": "^3.1.3",
+    "@vitest/coverage-v8": "^3.2.3",
     "husky": "^9.1.7",
-    "lint-staged": "^16.0.0",
-    "tsup": "^8.4.0",
-    "tsx": "^4.19.4",
+    "lint-staged": "^16.1.2",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
+    "vitest": "^3.2.3"
   },
   "dependencies": {
     "@manypkg/get-packages": "^3.0.0",
     "chalk": "^5.4.1",
-    "commander": "^13.1.0",
+    "commander": "^14.0.0",
     "conventional-changelog-angular": "^8.0.0",
     "conventional-commits-filter": "^5.0.0",
-    "conventional-recommended-bump": "^11.0.0",
+    "conventional-recommended-bump": "^11.2.0",
     "figlet": "^1.8.1",
     "git-semver-tags": "^8.0.0",
     "semver": "^7.7.2",