@releasekit/version 0.2.0-next.9 → 0.3.0-next.0

package/dist/cli.cjs

@@ -98,7 +98,7 @@ var import_commander = require("commander");
 var import_config = require("@releasekit/config");
 
 // src/types.ts
-function toVersionConfig(config) {
+function toVersionConfig(config, gitConfig) {
   if (!config) {
     return {
       tagTemplate: "v{version}",
@@ -107,7 +107,8 @@ function toVersionConfig(config) {
       sync: true,
       packages: [],
       updateInternalDependencies: "minor",
-      versionPrefix: ""
+      versionPrefix: "",
+      baseBranch: gitConfig?.branch
     };
   }
   return {
@@ -126,57 +127,28 @@ function toVersionConfig(config) {
       releaseType: bp.releaseType
     })),
     defaultReleaseType: config.defaultReleaseType,
-    skipHooks: config.skipHooks,
     mismatchStrategy: config.mismatchStrategy,
     versionPrefix: config.versionPrefix ?? "",
     prereleaseIdentifier: config.prereleaseIdentifier,
-    baseBranch: config.baseBranch,
+    baseBranch: gitConfig?.branch,
     cargo: config.cargo
   };
 }
 
 // src/config.ts
 function loadConfig(options) {
-  const versionConfig = (0, import_config.loadVersionConfig)(options);
-  return toVersionConfig(versionConfig);
+  const fullConfig = (0, import_config.loadConfig)(options);
+  return toVersionConfig(fullConfig.version, fullConfig.git);
 }
 
 // src/core/versionEngine.ts
-var import_node_process4 = require("process");
+var import_node_process2 = require("process");
 var import_get_packages = require("@manypkg/get-packages");
 
 // src/errors/gitError.ts
 init_baseError();
 var GitError = class extends BaseVersionError {
 };
-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",
-    ["TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */]: "Git tag already exists"
-  };
-  const suggestions = {
-    ["NOT_GIT_REPO" /* NOT_GIT_REPO */]: [
-      "Initialize git repository with: git init",
-      "Ensure you are in the correct directory"
-    ],
-    ["TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */]: [
-      "Delete the existing tag: git tag -d <tag-name>",
-      "Use a different version by incrementing manually",
-      "Check if this version was already released"
-    ],
-    ["GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */]: void 0,
-    ["NO_FILES" /* NO_FILES */]: void 0,
-    ["NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */]: void 0,
-    ["GIT_ERROR" /* GIT_ERROR */]: void 0
-  };
-  const baseMessage = messages[code];
-  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
-  return new GitError(fullMessage, code, suggestions[code]);
-}
 
 // src/errors/versionError.ts
 init_baseError();
@@ -401,13 +373,83 @@ var path6 = __toESM(require("path"), 1);
 init_commandExecutor();
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
 var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
+function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting all commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
+function commitTouchesAnyPackage(projectDir, commitHash, packageDirs, sharedPackageDirs = []) {
+  try {
+    const output = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
+      cwd: projectDir,
+      encoding: "utf8"
+    }).toString().trim();
+    if (!output) {
+      return false;
+    }
+    const changedFiles = output.split("\n");
+    return changedFiles.some((file) => {
+      return packageDirs.some((pkgDir) => {
+        if (sharedPackageDirs.some((sharedDir) => pkgDir.includes(sharedDir))) {
+          return false;
+        }
+        const normalizedFile = file.replace(/\\/g, "/");
+        const normalizedPkgDir = pkgDir.replace(/\\/g, "/").replace(/^\.\//, "");
+        return normalizedFile.startsWith(normalizedPkgDir);
+      });
+    });
+  } catch (error) {
+    log(
+      `Error checking if commit ${commitHash} touches packages: ${error instanceof Error ? error.message : String(error)}`,
+      "debug"
+    );
+    return false;
+  }
+}
+function extractRepoLevelChangelogEntries(projectDir, revisionRange, packageDirs, sharedPackageDirs = []) {
+  try {
+    const allCommits = extractAllChangelogEntriesWithHash(projectDir, revisionRange);
+    const repoLevelCommits = allCommits.filter((commit) => {
+      const touchesPackage = commitTouchesAnyPackage(projectDir, commit.hash, packageDirs, sharedPackageDirs);
+      return !touchesPackage;
+    });
+    if (repoLevelCommits.length > 0) {
+      log(
+        `Found ${repoLevelCommits.length} repo-level commit(s) (including shared packages: ${sharedPackageDirs.join(", ")})`,
+        "debug"
+      );
+    }
+    return repoLevelCommits.map((c) => c.entry);
+  } catch (error) {
+    log(`Error extracting repo-level commits: ${error instanceof Error ? error.message : String(error)}`, "warning");
+    return [];
+  }
+}
 function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
+  return extractCommitsFromGitLog(projectDir, revisionRange, true);
+}
+function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
   try {
-    const output = execSync(
-      "git",
-      ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges", "--", "."],
-      { cwd: projectDir, encoding: "utf8" }
-    ).toString();
+    const args = ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"];
+    if (filterToPath) {
+      args.push("--", ".");
+    }
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
     const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
@@ -504,162 +546,6 @@ function extractIssueIds(body) {
 init_baseError();
 init_commandExecutor();
 
-// src/git/commands.ts
-var import_node_process = require("process");
-init_commandExecutor();
-
-// src/git/repository.ts
-var import_node_fs = require("fs");
-var import_node_path2 = require("path");
-init_commandExecutor();
-function isGitRepository(directory) {
-  const gitDir = (0, import_node_path2.join)(directory, ".git");
-  if (!(0, import_node_fs.existsSync)(gitDir)) {
-    return false;
-  }
-  const stats = (0, import_node_fs.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) {
-  return execAsync("git", ["add", ...files]);
-}
-async function gitCommit(options) {
-  const args = ["commit"];
-  if (options.amend) {
-    args.push("--amend");
-  }
-  if (options.author) {
-    args.push("--author", options.author);
-  }
-  if (options.date) {
-    args.push("--date", options.date);
-  }
-  if (options.skipHooks) {
-    args.push("--no-verify");
-  }
-  args.push("-m", options.message);
-  return execAsync("git", args);
-}
-async function createGitTag(options) {
-  const { tag, message = "" } = options;
-  const args = ["tag", "-a", "-m", message, tag];
-  try {
-    return await execAsync("git", args);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("already exists")) {
-      throw createGitError(
-        "TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */,
-        `Tag '${tag}' already exists in the repository. Please use a different version or delete the existing tag first.`
-      );
-    }
-    throw createGitError("GIT_ERROR" /* GIT_ERROR */, errorMessage);
-  }
-}
-async function gitProcess(options) {
-  const { files, nextTag, commitMessage, skipHooks, dryRun } = options;
-  if (!isGitRepository((0, import_node_process.cwd)())) {
-    throw createGitError("NOT_GIT_REPO" /* NOT_GIT_REPO */);
-  }
-  try {
-    if (!dryRun) {
-      await gitAdd(files);
-      await gitCommit({
-        message: commitMessage,
-        skipHooks
-      });
-      if (nextTag) {
-        const tagMessage = `New Version ${nextTag} generated at ${(/* @__PURE__ */ new Date()).toISOString()}`;
-        await createGitTag({
-          tag: nextTag,
-          message: tagMessage
-        });
-      }
-    } else {
-      log("[DRY RUN] Would add files:", "info");
-      for (const file of files) {
-        log(`  - ${file}`, "info");
-      }
-      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
-      if (nextTag) {
-        log(`[DRY RUN] Would create tag: ${nextTag}`, "info");
-      }
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    if (errorMessage.includes("already exists") && nextTag) {
-      log(`Tag '${nextTag}' already exists in the repository.`, "error");
-      throw createGitError(
-        "TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */,
-        `Tag '${nextTag}' already exists in the repository. Please use a different version or delete the existing tag first.`
-      );
-    }
-    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);
-  }
-}
-async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, dryRun) {
-  try {
-    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) {
-    if (error instanceof GitError) {
-      throw error;
-    }
-    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("Unknown git error:", error);
-    }
-    throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
-  }
-}
-
 // src/git/tagsAndBranches.ts
 var import_git_semver_tags = require("git-semver-tags");
 var import_semver = __toESM(require("semver"), 1);
@@ -708,8 +594,8 @@ To fix this:
   let result = template.replace(/\$\{version\}/g, version).replace(/\$\{packageName\}/g, packageName || "");
   if (additionalContext) {
     for (const [key, value] of Object.entries(additionalContext)) {
-      const placeholder = `\${${key}}`;
-      result = result.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), value);
+      const placeholder = `${key ? `\${${key}}` : ""}`;
+      result = result.replace(new RegExp(escapeRegExp(placeholder), "g"), value);
     }
   }
   return result;
@@ -908,16 +794,16 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 }
 
 // src/package/packageManagement.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-
-// src/cargo/cargoHandler.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
+
+// src/cargo/cargoHandler.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_config2 = require("@releasekit/config");
 var TOML = __toESM(require("smol-toml"), 1);
 function getCargoInfo(cargoPath) {
-  if (!import_node_fs2.default.existsSync(cargoPath)) {
+  if (!import_node_fs.default.existsSync(cargoPath)) {
     log(`Cargo.toml file not found at: ${cargoPath}`, "error");
     throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
   }
@@ -931,7 +817,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: import_node_path3.default.dirname(cargoPath),
+      dir: import_node_path2.default.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -957,7 +843,7 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
         cargo.package.version = version;
       }
       const updatedContent = TOML.stringify(cargo);
-      import_node_fs2.default.writeFileSync(cargoPath, updatedContent);
+      import_node_fs.default.writeFileSync(cargoPath, updatedContent);
     }
     addPackageUpdate(packageName, version, cargoPath);
     log(`${dryRun ? "[DRY RUN] Would update" : "Updated"} Cargo.toml at ${cargoPath} to version ${version}`, "success");
@@ -977,12 +863,12 @@ function updatePackageVersion(packagePath, version, dryRun = false) {
     return;
   }
   try {
-    const packageContent = import_node_fs3.default.readFileSync(packagePath, "utf8");
+    const packageContent = import_node_fs2.default.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     if (!dryRun) {
       packageJson.version = version;
-      import_node_fs3.default.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+      import_node_fs2.default.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
     }
     addPackageUpdate(packageName, version, packagePath);
@@ -1002,13 +888,21 @@ function updatePackageVersion(packagePath, version, dryRun = false) {
 // src/package/packageProcessor.ts
 var fs5 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
-var import_node_process3 = require("process");
 
 // src/core/versionCalculator.ts
-var import_node_process2 = require("process");
+var import_node_process = require("process");
 var import_conventional_recommended_bump = require("conventional-recommended-bump");
 var import_semver3 = __toESM(require("semver"), 1);
 
+// src/git/repository.ts
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+init_commandExecutor();
+function getCurrentBranch() {
+  const result = execSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return result.toString().trim();
+}
+
 // src/utils/manifestHelpers.ts
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
@@ -1066,13 +960,13 @@ var import_semver2 = __toESM(require("semver"), 1);
 
 // src/git/tagVerification.ts
 init_commandExecutor();
-function verifyTag(tagName, cwd4) {
+function verifyTag(tagName, cwd3) {
   if (!tagName || tagName.trim() === "") {
     return { exists: false, reachable: false, error: "Empty tag name" };
   }
   try {
     execSync("git", ["rev-parse", "--verify", tagName], {
-      cwd: cwd4,
+      cwd: cwd3,
       stdio: "ignore"
     });
     return { exists: true, reachable: true };
@@ -1169,11 +1063,11 @@ var VersionMismatchError = class extends Error {
     this.name = "VersionMismatchError";
   }
 };
-async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error", strictReachable = false) {
+async function getBestVersionSource(tagName, packageVersion, cwd3, mismatchStrategy = "error", strictReachable = false) {
   if (!tagName?.trim()) {
     return packageVersion ? { source: "package", version: packageVersion, reason: "No git tag provided" } : { source: "initial", version: "0.1.0", reason: "No git tag or package version available" };
   }
-  const verification = verifyTag(tagName, cwd4);
+  const verification = verifyTag(tagName, cwd3);
   if (!verification.exists || !verification.reachable) {
     if (strictReachable) {
       throw new Error(
@@ -1328,7 +1222,7 @@ async function calculateVersion(config, options) {
     const escapedTagPattern = escapeRegExp3(tagSearchPattern);
     let versionSource;
     if (pkgPath) {
-      const packageDir = pkgPath || (0, import_node_process2.cwd)();
+      const packageDir = pkgPath || (0, import_node_process.cwd)();
       const manifestResult = getVersionFromManifests(packageDir);
       const packageVersion = manifestResult.manifestFound && manifestResult.version ? manifestResult.version : void 0;
       versionSource = await getBestVersionSource(
@@ -1391,7 +1285,7 @@ async function calculateVersion(config, options) {
       const releaseTypeFromCommits = recommendedBump && "releaseType" in recommendedBump ? recommendedBump.releaseType : void 0;
       const currentVersion = getCurrentVersionFromSource2();
       if (versionSource && versionSource.source === "git") {
-        const checkPath = pkgPath || (0, import_node_process2.cwd)();
+        const checkPath = pkgPath || (0, import_node_process.cwd)();
         const commitsLength = getCommitsLength(checkPath, versionSource.version);
         if (commitsLength === 0) {
           log(
@@ -1477,7 +1371,6 @@ var PackageProcessor = class {
   tagTemplate;
   commitMessageTemplate;
   dryRun;
-  skipHooks;
   getLatestTag;
   config;
   // Config for version calculation
@@ -1488,7 +1381,6 @@ var PackageProcessor = class {
     this.tagTemplate = options.tagTemplate;
     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;
@@ -1591,6 +1483,19 @@ var PackageProcessor = class {
           revisionRange = "HEAD";
         }
         changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
+        const allPackageDirs = packages.map((p) => p.dir);
+        const sharedPackageNames = ["config", "core", "@releasekit/config", "@releasekit/core"];
+        const sharedPackageDirs = packages.filter((p) => sharedPackageNames.includes(p.packageJson.name)).map((p) => p.dir);
+        const repoLevelEntries = extractRepoLevelChangelogEntries(
+          pkgPath,
+          revisionRange,
+          allPackageDirs,
+          sharedPackageDirs
+        );
+        if (repoLevelEntries.length > 0) {
+          log(`Adding ${repoLevelEntries.length} repo-level commit(s) to ${name} changelog`, "debug");
+          changelogEntries = [...repoLevelEntries, ...changelogEntries];
+        }
         if (changelogEntries.length === 0) {
           changelogEntries = [
             {
@@ -1678,19 +1583,12 @@ var PackageProcessor = class {
         this.tagTemplate,
         this.fullConfig.packageSpecificTags
       );
-      const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
       tags.push(packageTag);
-      if (!this.dryRun) {
-        try {
-          await createGitTag({ tag: packageTag, message: tagMessage });
-          log(`Created tag: ${packageTag}`, "success");
-        } catch (tagError) {
-          log(`Failed to create tag ${packageTag} for ${name}: ${tagError.message}`, "error");
-          log(tagError.stack || "No stack trace available", "error");
-        }
-      } else {
+      if (this.dryRun) {
         log(`[DRY RUN] Would create tag: ${packageTag}`, "info");
+      } else {
+        log(`Version ${nextVersion} prepared (tag: ${packageTag})`, "success");
       }
       updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
     }
@@ -1698,34 +1596,15 @@ var PackageProcessor = class {
       log("No packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
-    const filesToCommit = [];
-    for (const info of updatedPackagesInfo) {
-      const packageJsonPath = import_node_path6.default.join(info.path, "package.json");
-      if (fs5.existsSync(packageJsonPath)) {
-        filesToCommit.push(packageJsonPath);
-      }
-      const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
-      if (cargoEnabled) {
-        const cargoPaths = this.fullConfig.cargo?.paths;
-        if (cargoPaths && cargoPaths.length > 0) {
-          for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = import_node_path6.default.resolve(info.path, cargoPath, "Cargo.toml");
-            if (fs5.existsSync(resolvedCargoPath)) {
-              filesToCommit.push(resolvedCargoPath);
-            }
-          }
-        } else {
-          const cargoTomlPath = import_node_path6.default.join(info.path, "Cargo.toml");
-          if (fs5.existsSync(cargoTomlPath)) {
-            filesToCommit.push(cargoTomlPath);
-          }
-        }
-      }
-    }
     const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
     const representativeVersion = updatedPackagesInfo[0]?.version || "multiple";
     let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
-    const placeholderRegex = /\$\{[^}]+\}/;
+    const MAX_COMMIT_MSG_LENGTH = 1e4;
+    if (commitMessage.length > MAX_COMMIT_MSG_LENGTH) {
+      log("Commit message template too long, truncating", "warning");
+      commitMessage = commitMessage.slice(0, MAX_COMMIT_MSG_LENGTH);
+    }
+    const placeholderRegex = /\$\{[^{}$]{1,1000}\}/;
     if (updatedPackagesInfo.length === 1 && placeholderRegex.test(commitMessage)) {
       const packageName = updatedPackagesInfo[0].name;
       commitMessage = formatCommitMessage(commitMessage, representativeVersion, packageName);
@@ -1733,21 +1612,7 @@ var PackageProcessor = class {
       commitMessage = `chore(release): ${packageNames} ${representativeVersion}`;
     }
     setCommitMessage(commitMessage);
-    if (!this.dryRun) {
-      try {
-        await gitAdd(filesToCommit);
-        await gitCommit({ message: commitMessage, skipHooks: this.skipHooks });
-        log(`Created commit for targeted release: ${packageNames}`, "success");
-      } catch (commitError) {
-        log("Failed to create commit for targeted release.", "error");
-        console.error(commitError);
-        (0, import_node_process3.exit)(1);
-      }
-    } else {
-      log("[DRY RUN] Would add files:", "info");
-      for (const file of filesToCommit) {
-        log(`  - ${file}`, "info");
-      }
+    if (this.dryRun) {
       log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
     }
     return {
@@ -1798,7 +1663,6 @@ function createSyncStrategy(config) {
         commitMessage = `chore(release): v\${version}`,
         prereleaseIdentifier,
         dryRun,
-        skipHooks,
         mainPackage
       } = config;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
@@ -1948,7 +1812,13 @@ function createSyncStrategy(config) {
         config.packageSpecificTags || false
       );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, commitPackageName, void 0);
-      await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
+      addTag(nextTag);
+      setCommitMessage(formattedCommitMessage);
+      if (!dryRun) {
+        log(`Version ${nextVersion} prepared (tag: ${nextTag})`, "success");
+      } else {
+        log(`Would create tag: ${nextTag}`, "info");
+      }
     } catch (error) {
       if (BaseVersionError.isVersionError(error)) {
         log(`Synced Strategy failed: ${error.message} (${error.code})`, "error");
@@ -1963,14 +1833,7 @@ function createSyncStrategy(config) {
 function createSingleStrategy(config) {
   return async (packages) => {
     try {
-      const {
-        mainPackage,
-        versionPrefix,
-        tagTemplate,
-        commitMessage = `chore(release): \${version}`,
-        dryRun,
-        skipHooks
-      } = config;
+      const { mainPackage, versionPrefix, tagTemplate, commitMessage = `chore(release): \${version}`, dryRun } = config;
       let packageName;
       if (mainPackage) {
         packageName = mainPackage;
@@ -2090,9 +1953,10 @@ function createSingleStrategy(config) {
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
       const tagName = formatTag(nextVersion, formattedPrefix, packageName, tagTemplate, config.packageSpecificTags);
       const commitMsg = formatCommitMessage(commitMessage, nextVersion, packageName);
+      addTag(tagName);
+      setCommitMessage(commitMsg);
       if (!dryRun) {
-        await createGitCommitAndTag(filesToCommit, tagName, commitMsg, skipHooks, dryRun);
-        log(`Created tag: ${tagName}`, "success");
+        log(`Version ${nextVersion} prepared (tag: ${tagName})`, "success");
       } else {
         log(`Would create tag: ${tagName}`, "info");
       }
@@ -2117,7 +1981,6 @@ function createAsyncStrategy(config) {
     tagTemplate: config.tagTemplate,
     commitMessageTemplate: config.commitMessage || "",
     dryRun: config.dryRun || false,
-    skipHooks: config.skipHooks || false,
     getLatestTag: dependencies.getLatestTag,
     fullConfig: config,
     // Extract common version configuration properties
@@ -2205,13 +2068,13 @@ var VersionEngine = class {
       if (this.workspaceCache) {
         return this.workspaceCache;
       }
-      const pkgsResult = (0, import_get_packages.getPackagesSync)((0, import_node_process4.cwd)());
+      const pkgsResult = (0, import_get_packages.getPackagesSync)((0, import_node_process2.cwd)());
       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_process4.cwd)();
+        pkgsResult.root = (0, import_node_process2.cwd)();
       }
       if (this.config.packages && this.config.packages.length > 0) {
         const originalCount = pkgsResult.packages.length;

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   loadConfig,
   log,
   printJsonOutput
-} from "./chunk-7F6RMN2K.js";
+} from "./chunk-4OGOAITO.js";
 import "./chunk-GQLJ7JQY.js";
 import "./chunk-LMPZV35Z.js";