package-versioner 0.6.4 → 0.7.1

package/dist/index.js

@@ -1,79 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as fs7 from "node:fs";
-import path5 from "node:path";
+import * as fs10 from "fs";
+import path8 from "path";
 import { Command } from "commander";
 
-// src/config.ts
-import * as fs from "node:fs";
-import { cwd } from "node:process";
-function loadConfig(configPath) {
-  const localProcess = cwd();
-  const filePath = configPath || `${localProcess}/version.config.json`;
-  return new Promise((resolve, reject) => {
-    fs.readFile(filePath, "utf-8", (err, data) => {
-      if (err) {
-        reject(new Error(`Could not locate the config file at ${filePath}: ${err.message}`));
-        return;
-      }
-      try {
-        const config = JSON.parse(data);
-        resolve(config);
-      } catch (err2) {
-        const errorMessage = err2 instanceof Error ? err2.message : String(err2);
-        reject(new Error(`Failed to parse config file ${filePath}: ${errorMessage}`));
-      }
-    });
-  });
-}
-
-// 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/changelog/changelogRegenerator.ts
+import { execSync as execSync2 } from "child_process";
+import fs from "fs";
+import path from "path";
 
 // src/utils/logging.ts
 import chalk from "chalk";
@@ -156,15 +91,514 @@ function log(message, level = "info") {
   }
 }
 
+// src/changelog/commitParser.ts
+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) {
+  try {
+    const command = `git log ${revisionRange} --pretty=format:"%B---COMMIT_DELIMITER---" --no-merges`;
+    const output = execSync(command, {
+      cwd: projectDir,
+      encoding: "utf8"
+    });
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
+  } catch (error) {
+    log(`Error extracting commits: ${error}`, "error");
+    return [];
+  }
+}
+function parseCommitMessage(message) {
+  const match = message.match(CONVENTIONAL_COMMIT_REGEX);
+  if (match) {
+    const [, type, scope, breakingMark, subject, body = ""] = match;
+    const breakingFromMark = breakingMark === "!";
+    const breakingChangeMatch = body.match(BREAKING_CHANGE_REGEX);
+    const hasBreakingChange = breakingFromMark || breakingChangeMatch !== null;
+    const changelogType = mapCommitTypeToChangelogType(type);
+    if (!changelogType) {
+      return null;
+    }
+    const issueIds = extractIssueIds(body);
+    let description = subject;
+    if (hasBreakingChange) {
+      description = `**BREAKING** ${description}`;
+    }
+    return {
+      type: changelogType,
+      description,
+      scope: scope || void 0,
+      issueIds: issueIds.length > 0 ? issueIds : void 0,
+      originalType: type
+      // Store original type for custom formatting
+    };
+  }
+  if (!message.startsWith("Merge") && !message.match(/^v?\d+\.\d+\.\d+/)) {
+    const firstLine = message.split("\n")[0].trim();
+    return {
+      type: "changed",
+      description: firstLine
+    };
+  }
+  return null;
+}
+function mapCommitTypeToChangelogType(type) {
+  switch (type) {
+    case "feat":
+      return "added";
+    case "fix":
+      return "fixed";
+    case "docs":
+    case "style":
+    case "refactor":
+    case "perf":
+    case "build":
+    case "ci":
+      return "changed";
+    case "revert":
+      return "removed";
+    case "chore":
+      return "changed";
+    case "test":
+      return null;
+    default:
+      return "changed";
+  }
+}
+function extractIssueIds(body) {
+  const issueRegex = /(?:fix|fixes|close|closes|resolve|resolves)\s+#(\d+)/gi;
+  const issueIds = [];
+  let match = issueRegex.exec(body);
+  while (match !== null) {
+    issueIds.push(`#${match[1]}`);
+    match = issueRegex.exec(body);
+  }
+  return issueIds;
+}
+
+// src/changelog/formatters.ts
+function formatChangelogEntries(format, version, date, entries, packageName, repoUrl) {
+  const formattingEntries = entries.map((entry) => {
+    const hasBreaking = entry.description.includes("**BREAKING**");
+    return {
+      ...entry,
+      breaking: hasBreaking
+    };
+  });
+  return format === "keep-a-changelog" ? formatKeepAChangelogEntries(version, date, formattingEntries, repoUrl) : formatAngularEntries(version, date, formattingEntries, packageName);
+}
+function formatKeepAChangelogEntries(version, date, entries, repoUrl) {
+  const added = [];
+  const changed = [];
+  const deprecated = [];
+  const removed = [];
+  const fixed = [];
+  const security = [];
+  for (const entry of entries) {
+    const entryText = entry.scope ? `- **${entry.scope}**: ${entry.description}` : `- ${entry.description}`;
+    const formattedEntry = entry.breaking ? entryText.replace(/^- /, "- **BREAKING** ") : entryText;
+    const entryType = entry.originalType || entry.type;
+    switch (entryType) {
+      case "feat":
+        added.push(formattedEntry);
+        break;
+      case "fix":
+        fixed.push(formattedEntry);
+        break;
+      case "docs":
+      case "style":
+      case "refactor":
+      case "perf":
+      case "build":
+      case "ci":
+        changed.push(formattedEntry);
+        break;
+      case "test":
+        break;
+      case "chore":
+        if (entry.description.toLowerCase().includes("deprecat")) {
+          deprecated.push(formattedEntry);
+        } else {
+          changed.push(formattedEntry);
+        }
+        break;
+      // Keep-a-changelog standard types
+      case "added":
+        added.push(formattedEntry);
+        break;
+      case "changed":
+        changed.push(formattedEntry);
+        break;
+      case "deprecated":
+        deprecated.push(formattedEntry);
+        break;
+      case "removed":
+        removed.push(formattedEntry);
+        break;
+      case "fixed":
+        fixed.push(formattedEntry);
+        break;
+      case "security":
+        security.push(formattedEntry);
+        break;
+      default:
+        changed.push(formattedEntry);
+    }
+  }
+  let content = `## [${version}] - ${date}
+
+`;
+  if (added.length > 0) {
+    content += `### Added
+
+${added.join("\n")}
+
+`;
+  }
+  if (changed.length > 0) {
+    content += `### Changed
+
+${changed.join("\n")}
+
+`;
+  }
+  if (deprecated.length > 0) {
+    content += `### Deprecated
+
+${deprecated.join("\n")}
+
+`;
+  }
+  if (removed.length > 0) {
+    content += `### Removed
+
+${removed.join("\n")}
+
+`;
+  }
+  if (fixed.length > 0) {
+    content += `### Fixed
+
+${fixed.join("\n")}
+
+`;
+  }
+  if (security.length > 0) {
+    content += `### Security
+
+${security.join("\n")}
+
+`;
+  }
+  if (repoUrl) {
+    content += `[${version}]: ${repoUrl}/compare/v${version}...HEAD
+`;
+  }
+  return content.trim();
+}
+function formatAngularEntries(version, date, entries, packageName) {
+  const features = [];
+  const bugfixes = [];
+  const performance = [];
+  const breaking = [];
+  for (const entry of entries) {
+    if (entry.breaking) {
+      breaking.push(entry);
+    }
+    const entryType = entry.originalType || entry.type;
+    switch (entryType) {
+      case "feat":
+      case "added":
+        features.push(entry);
+        break;
+      case "fix":
+      case "fixed":
+        bugfixes.push(entry);
+        break;
+      case "perf":
+        performance.push(entry);
+        break;
+    }
+  }
+  let content = `## [${version}]${packageName ? ` (${packageName})` : ""} (${date})
+
+`;
+  if (features.length > 0) {
+    content += "### Features\n\n";
+    content += formatAngularTypeEntries(features);
+    content += "\n";
+  }
+  if (bugfixes.length > 0) {
+    content += "### Bug Fixes\n\n";
+    content += formatAngularTypeEntries(bugfixes);
+    content += "\n";
+  }
+  if (performance.length > 0) {
+    content += "### Performance Improvements\n\n";
+    content += formatAngularTypeEntries(performance);
+    content += "\n";
+  }
+  if (breaking.length > 0) {
+    content += "### BREAKING CHANGES\n\n";
+    content += formatAngularTypeEntries(breaking);
+    content += "\n";
+  }
+  return content.trim();
+}
+function formatAngularTypeEntries(entries) {
+  var _a;
+  const entriesByScope = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const scope = entry.scope || "";
+    if (!entriesByScope.has(scope)) {
+      entriesByScope.set(scope, []);
+    }
+    (_a = entriesByScope.get(scope)) == null ? void 0 : _a.push(entry);
+  }
+  const result = [];
+  for (const [scope, scopeEntries] of Object.entries(groupEntriesByScope(entries))) {
+    if (scope !== "undefined" && scope !== "") {
+      result.push(`* **${scope}:**`);
+      for (const entry of scopeEntries) {
+        const description = entry.description.replace("**BREAKING** ", "");
+        result.push(`  * ${description}`);
+      }
+    } else {
+      for (const entry of scopeEntries) {
+        const description = entry.description.replace("**BREAKING** ", "");
+        result.push(`* ${description}`);
+      }
+    }
+  }
+  return result.join("\n");
+}
+function groupEntriesByScope(entries) {
+  const result = {};
+  for (const entry of entries) {
+    const scope = entry.scope || "";
+    if (!result[scope]) {
+      result[scope] = [];
+    }
+    result[scope].push(entry);
+  }
+  return result;
+}
+
+// src/changelog/templates.ts
+function getDefaultTemplate(format) {
+  return format === "keep-a-changelog" ? getKeepAChangelogTemplate() : getAngularTemplate();
+}
+function getKeepAChangelogTemplate() {
+  return `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+`;
+}
+function getAngularTemplate() {
+  return `# Changelog
+
+`;
+}
+
+// src/changelog/changelogRegenerator.ts
+function getAllVersionTags(since, versionPrefix = "v") {
+  try {
+    const command = since ? `git tag --list "${versionPrefix}*" --sort=creatordate --contains ${since}` : `git tag --list "${versionPrefix}*" --sort=creatordate`;
+    const tagOutput = execSync2(command, { encoding: "utf8" }).trim();
+    if (!tagOutput) {
+      return [];
+    }
+    const tags = tagOutput.split("\n").filter((tag) => !!tag);
+    return tags.map((tag) => {
+      try {
+        const date = execSync2(`git log -1 --format=%ad --date=short ${tag}`, {
+          encoding: "utf8"
+        }).trim();
+        const version = tag.replace(new RegExp(`^${versionPrefix}`), "");
+        return { tag, version, date };
+      } catch (error) {
+        log(`Failed to get date for tag ${tag}: ${error}`, "warning");
+        return { tag, version: tag.replace(new RegExp(`^${versionPrefix}`), ""), date: "Unknown" };
+      }
+    });
+  } catch (error) {
+    log(`Failed to get version tags: ${error}`, "error");
+    return [];
+  }
+}
+async function regenerateChangelog(options) {
+  const { format, since, projectDir } = options;
+  const packageJsonPath = path.join(projectDir, "package.json");
+  let packageName = "";
+  let repoUrl = options.repoUrl;
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      packageName = packageJson.name || "";
+      if (!repoUrl && packageJson.repository) {
+        if (typeof packageJson.repository === "string") {
+          repoUrl = packageJson.repository;
+        } else if (packageJson.repository.url) {
+          repoUrl = packageJson.repository.url;
+        }
+        if ((repoUrl == null ? void 0 : repoUrl.startsWith("git+")) && (repoUrl == null ? void 0 : repoUrl.endsWith(".git"))) {
+          repoUrl = repoUrl.substring(4, repoUrl.length - 4);
+        }
+      }
+    } catch (error) {
+      log(`Failed to read package.json: ${error}`, "warning");
+    }
+  }
+  let versionPrefix = "v";
+  try {
+    const allTags = execSync2("git tag --list", { encoding: "utf8" }).trim().split("\n");
+    const versionTag = allTags.find((tag) => /^[vV][0-9]/.test(tag));
+    if (versionTag) {
+      versionPrefix = versionTag.charAt(0);
+    }
+  } catch {
+  }
+  const tags = getAllVersionTags(since, versionPrefix);
+  if (!tags.length) {
+    throw new Error(
+      'No version tags found in git history. Make sure you have tags that start with the version prefix (usually "v").'
+    );
+  }
+  let changelogContent = getDefaultTemplate(format);
+  log(`Found ${tags.length} version tags, generating changelog...`, "info");
+  const versions = [];
+  for (let i = tags.length - 1; i >= 0; i--) {
+    const currentTag = tags[i];
+    const previousTag = i > 0 ? tags[i - 1].tag : null;
+    log(`Processing changes for ${currentTag.tag}...`, "info");
+    try {
+      const tagRange = previousTag ? `${previousTag}..${currentTag.tag}` : currentTag.tag;
+      const entries = extractChangelogEntriesFromCommits(projectDir, tagRange);
+      if (!entries.length) {
+        log(`No changelog entries found for ${currentTag.tag}, adding placeholder entry`, "info");
+        entries.push({
+          type: "changed",
+          description: `Release version ${currentTag.version}`
+        });
+      }
+      versions.unshift(
+        formatChangelogEntries(
+          format,
+          currentTag.version,
+          currentTag.date,
+          entries,
+          packageName,
+          repoUrl
+        )
+      );
+    } catch (error) {
+      log(`Failed to process version ${currentTag.tag}: ${error}`, "error");
+    }
+  }
+  changelogContent += versions.join("\n\n");
+  return changelogContent;
+}
+async function writeChangelog(content, outputPath, dryRun) {
+  if (dryRun) {
+    log("--- Changelog Preview ---", "info");
+    console.log(content);
+    log("--- End Preview ---", "info");
+    return;
+  }
+  try {
+    fs.writeFileSync(outputPath, content, "utf8");
+    log(`Changelog successfully written to ${outputPath}`, "success");
+  } catch (error) {
+    throw new Error(
+      `Failed to write changelog: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/config.ts
+import * as fs2 from "fs";
+import { cwd } from "process";
+function loadConfig(configPath) {
+  const localProcess = cwd();
+  const filePath = configPath || `${localProcess}/version.config.json`;
+  return new Promise((resolve, reject) => {
+    fs2.readFile(filePath, "utf-8", (err, data) => {
+      if (err) {
+        reject(new Error(`Could not locate the config file at ${filePath}: ${err.message}`));
+        return;
+      }
+      try {
+        const config = JSON.parse(data);
+        resolve(config);
+      } catch (err2) {
+        const errorMessage = err2 instanceof Error ? err2.message : String(err2);
+        reject(new Error(`Failed to parse config file ${filePath}: ${errorMessage}`));
+      }
+    });
+  });
+}
+
+// src/core/versionEngine.ts
+import { cwd as cwd4 } from "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/core/versionStrategies.ts
-import fs6 from "node:fs";
-import * as path4 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) => {
@@ -181,11 +615,11 @@ var execAsync = (command, options) => {
     );
   });
 };
-var execSync = (command, args) => nativeExecSync(command, { maxBuffer: 1024 * 1024 * 10, ...args });
+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)) {
@@ -196,14 +630,14 @@ function isGitRepository(directory) {
     return false;
   }
   try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd: directory });
+    execSync3("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");
+  const result = execSync3("git rev-parse --abbrev-ref HEAD");
   return result.toString().trim();
 }
 
@@ -265,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);
   }
 }
@@ -294,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 */);
   }
@@ -347,7 +793,7 @@ function createTemplateString(template, variables) {
 function getCommitsLength(pkgRoot) {
   try {
     const gitCommand = `git rev-list --count HEAD ^$(git describe --tags --abbrev=0) ${pkgRoot}`;
-    const amount = execSync(gitCommand).toString().trim();
+    const amount = execSync3(gitCommand).toString().trim();
     return Number(amount);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -444,20 +890,21 @@ async function getLatestTagForPackage(packageName, versionPrefix) {
 }
 
 // src/package/packageManagement.ts
-import fs3 from "node:fs";
+import fs4 from "fs";
+import path3 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs2 from "node:fs";
-import path from "node:path";
+import fs3 from "fs";
+import path2 from "path";
 import * as TOML from "smol-toml";
 function getCargoInfo(cargoPath) {
   var _a;
-  if (!fs2.existsSync(cargoPath)) {
+  if (!fs3.existsSync(cargoPath)) {
     log(`Cargo.toml file not found at: ${cargoPath}`, "error");
     throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
   }
   try {
-    const fileContent = fs2.readFileSync(cargoPath, "utf8");
+    const fileContent = fs3.readFileSync(cargoPath, "utf8");
     const cargo = TOML.parse(fileContent);
     if (!((_a = cargo.package) == null ? void 0 : _a.name)) {
       log(`Package name not found in: ${cargoPath}`, "error");
@@ -467,7 +914,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path.dirname(cargoPath),
+      dir: path2.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -480,12 +927,12 @@ function getCargoInfo(cargoPath) {
   }
 }
 function isCargoToml(filePath) {
-  return path.basename(filePath) === "Cargo.toml";
+  return path2.basename(filePath) === "Cargo.toml";
 }
 function updateCargoVersion(cargoPath, version) {
   var _a;
   try {
-    const originalContent = fs2.readFileSync(cargoPath, "utf8");
+    const originalContent = fs3.readFileSync(cargoPath, "utf8");
     const cargo = TOML.parse(originalContent);
     const packageName = (_a = cargo.package) == null ? void 0 : _a.name;
     if (!packageName) {
@@ -497,7 +944,7 @@ function updateCargoVersion(cargoPath, version) {
       cargo.package.version = version;
     }
     const updatedContent = TOML.stringify(cargo);
-    fs2.writeFileSync(cargoPath, updatedContent);
+    fs3.writeFileSync(cargoPath, updatedContent);
     addPackageUpdate(packageName, version, cargoPath);
     log(`Updated Cargo.toml at ${cargoPath} to version ${version}`, "success");
   } catch (error) {
@@ -516,11 +963,11 @@ function updatePackageVersion(packagePath, version) {
     return;
   }
   try {
-    const packageContent = fs3.readFileSync(packagePath, "utf8");
+    const packageContent = fs4.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     packageJson.version = version;
-    fs3.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+    fs4.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
     addPackageUpdate(packageName, version, packagePath);
     log(`Updated package.json at ${packagePath} to version ${version}`, "success");
@@ -534,24 +981,349 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs5 from "node:fs";
-import path3 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 "fs";
+import * as path4 from "path";
+function createChangelog(_packagePath, packageName) {
+  return {
+    projectName: packageName,
+    unreleased: [],
+    versions: []
+  };
+}
+function parseChangelog(filePath) {
+  try {
+    if (!fs5.existsSync(filePath)) {
+      return null;
+    }
+    fs5.readFileSync(filePath, "utf8");
+    log(`Parsed changelog at ${filePath}`, "info");
+    return {
+      projectName: path4.basename(path4.dirname(filePath)),
+      unreleased: [],
+      versions: []
+    };
+  } catch (error) {
+    log(
+      `Error parsing changelog: ${error instanceof Error ? error.message : String(error)}`,
+      "error"
+    );
+    return null;
+  }
+}
+function generateLinks(changelog, repoUrl) {
+  var _a, _b;
+  if (!repoUrl || changelog.versions.length === 0) {
+    return "";
+  }
+  let links = "\n";
+  if (changelog.unreleased.length > 0) {
+    const latestVersion = ((_a = changelog.versions[0]) == null ? void 0 : _a.version) || "";
+    links += `[unreleased]: ${repoUrl}/compare/v${latestVersion}...HEAD
+`;
+  }
+  for (let i = 0; i < changelog.versions.length; i++) {
+    const currentVersion = changelog.versions[i].version;
+    const previousVersion = (_b = changelog.versions[i + 1]) == null ? void 0 : _b.version;
+    if (previousVersion) {
+      links += `[${currentVersion}]: ${repoUrl}/compare/v${previousVersion}...v${currentVersion}
+`;
+    } else if (i === changelog.versions.length - 1) {
+      links += `[${currentVersion}]: ${repoUrl}/releases/tag/v${currentVersion}
+`;
+    }
+  }
+  return links;
+}
+function generateAngularChangelogContent(changelog, repoUrl) {
+  let content = "# Changelog\n\n";
+  if (changelog.unreleased.length > 0) {
+    content += "## [Unreleased]\n\n";
+    const groupedByType = groupEntriesByAngularType(changelog.unreleased);
+    for (const [type, entries] of Object.entries(groupedByType)) {
+      content += `### ${formatAngularType(type)}
+
+`;
+      const groupedByScope = groupEntriesByScope2(entries);
+      for (const [scope, scopeEntries] of Object.entries(groupedByScope)) {
+        if (scope !== "undefined" && scope !== "") {
+          content += `* **${scope}:**
+`;
+          for (const entry of scopeEntries) {
+            content += formatAngularEntry(entry, false);
+          }
+          content += "\n";
+        } else {
+          for (const entry of scopeEntries) {
+            content += formatAngularEntry(entry, true);
+          }
+        }
+      }
+      content += "\n";
+    }
+    const breakingChanges = changelog.unreleased.filter(
+      (entry) => entry.description.includes("**BREAKING**")
+    );
+    if (breakingChanges.length > 0) {
+      content += "### BREAKING CHANGES\n\n";
+      for (const entry of breakingChanges) {
+        const description = entry.description.replace("**BREAKING** ", "");
+        content += `* ${entry.scope ? `**${entry.scope}:** ` : ""}${description}`;
+        if (entry.issueIds && entry.issueIds.length > 0) {
+          content += ` (${entry.issueIds.join(", ")})`;
+        }
+        content += "\n";
+      }
+      content += "\n";
+    }
+  }
+  for (const version of changelog.versions) {
+    content += `## [${version.version}] - ${version.date}
+
+`;
+    const groupedByType = groupEntriesByAngularType(version.entries);
+    for (const [type, entries] of Object.entries(groupedByType)) {
+      content += `### ${formatAngularType(type)}
+
+`;
+      const groupedByScope = groupEntriesByScope2(entries);
+      for (const [scope, scopeEntries] of Object.entries(groupedByScope)) {
+        if (scope !== "undefined" && scope !== "") {
+          content += `* **${scope}:**
+`;
+          for (const entry of scopeEntries) {
+            content += formatAngularEntry(entry, false);
+          }
+          content += "\n";
+        } else {
+          for (const entry of scopeEntries) {
+            content += formatAngularEntry(entry, true);
+          }
+        }
+      }
+      content += "\n";
+    }
+    const breakingChanges = version.entries.filter(
+      (entry) => entry.description.includes("**BREAKING**")
+    );
+    if (breakingChanges.length > 0) {
+      content += "### BREAKING CHANGES\n\n";
+      for (const entry of breakingChanges) {
+        const description = entry.description.replace("**BREAKING** ", "");
+        content += `* ${entry.scope ? `**${entry.scope}:** ` : ""}${description}`;
+        if (entry.issueIds && entry.issueIds.length > 0) {
+          content += ` (${entry.issueIds.join(", ")})`;
+        }
+        content += "\n";
+      }
+      content += "\n";
+    }
+  }
+  content += generateLinks(changelog, repoUrl);
+  return content;
+}
+function groupEntriesByAngularType(entries) {
+  const result = {};
+  for (const entry of entries) {
+    const type = entry.originalType || mapToAngularType(entry.type);
+    if (!result[type]) {
+      result[type] = [];
+    }
+    result[type].push(entry);
+  }
+  return result;
+}
+function mapToAngularType(type) {
+  switch (type) {
+    case "added":
+      return "feat";
+    case "fixed":
+      return "fix";
+    case "changed":
+      return "perf";
+    case "deprecated":
+    case "removed":
+    case "security":
+      return type;
+    default:
+      return type;
+  }
+}
+function formatAngularType(type) {
+  switch (type) {
+    case "feat":
+      return "Features";
+    case "fix":
+      return "Bug Fixes";
+    case "perf":
+      return "Performance Improvements";
+    case "security":
+      return "Security";
+    case "deprecated":
+      return "Deprecated";
+    case "removed":
+      return "Removed";
+    default:
+      return capitalizeFirstLetter(type);
+  }
+}
+function groupEntriesByScope2(entries) {
+  const result = {};
+  for (const entry of entries) {
+    const scope = entry.scope || "";
+    if (!result[scope]) {
+      result[scope] = [];
+    }
+    result[scope].push(entry);
+  }
+  return result;
+}
+function formatAngularEntry(entry, includeScope) {
+  let result = "  * ";
+  if (includeScope && entry.scope) {
+    result += `**${entry.scope}:** `;
+  }
+  let description = entry.description;
+  if (!includeScope && entry.scope && description.startsWith(`**${entry.scope}**: `)) {
+    description = description.substring(`**${entry.scope}**: `.length);
+  }
+  if (description.startsWith("**BREAKING** ")) {
+    description = description.substring("**BREAKING** ".length);
+  }
+  result += description;
+  if (entry.issueIds && entry.issueIds.length > 0) {
+    result += ` (${entry.issueIds.join(", ")})`;
+  }
+  result += "\n";
+  return result;
+}
+function generateChangelogContent(changelog, repoUrl, format = "keep-a-changelog") {
+  if (format === "angular") {
+    return generateAngularChangelogContent(changelog, repoUrl);
+  }
+  let content = "# Changelog\n\n";
+  content += `All notable changes to ${changelog.projectName} will be documented in this file.
+
+`;
+  content += "The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),\n";
+  content += "and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n";
+  if (changelog.unreleased.length > 0) {
+    content += "## [Unreleased]\n\n";
+    const grouped = changelog.unreleased.reduce(
+      (acc, entry) => {
+        if (!acc[entry.type]) {
+          acc[entry.type] = [];
+        }
+        acc[entry.type].push(entry);
+        return acc;
+      },
+      {}
+    );
+    for (const [type, entries] of Object.entries(grouped)) {
+      content += `### ${capitalizeFirstLetter(type)}
+
+`;
+      for (const entry of entries) {
+        let entryText = `- ${entry.description}`;
+        if (entry.issueIds && entry.issueIds.length > 0) {
+          entryText += ` (${entry.issueIds.join(", ")})`;
+        }
+        content += `${entryText}.
+`;
+      }
+      content += "\n";
+    }
+  }
+  for (const version of changelog.versions) {
+    content += `## [${version.version}] - ${version.date}
+
+`;
+    const grouped = version.entries.reduce(
+      (acc, entry) => {
+        if (!acc[entry.type]) {
+          acc[entry.type] = [];
+        }
+        acc[entry.type].push(entry);
+        return acc;
+      },
+      {}
+    );
+    for (const [type, entries] of Object.entries(grouped)) {
+      content += `### ${capitalizeFirstLetter(type)}
+
+`;
+      for (const entry of entries) {
+        let entryText = `- ${entry.description}`;
+        if (entry.issueIds && entry.issueIds.length > 0) {
+          entryText += ` (${entry.issueIds.join(", ")})`;
+        }
+        content += `${entryText}.
+`;
+      }
+      content += "\n";
+    }
+  }
+  content += generateLinks(changelog, repoUrl);
+  return content;
+}
+function updateChangelog(packagePath, packageName, version, entries, repoUrl, format = "keep-a-changelog") {
+  try {
+    const changelogPath = path4.join(packagePath, "CHANGELOG.md");
+    let changelog;
+    if (fs5.existsSync(changelogPath)) {
+      const existingChangelog = parseChangelog(changelogPath);
+      if (existingChangelog) {
+        changelog = existingChangelog;
+      } else {
+        changelog = createChangelog(packagePath, packageName);
+      }
+    } else {
+      changelog = createChangelog(packagePath, packageName);
+    }
+    if (version) {
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const newVersion = {
+        version,
+        date: today,
+        entries: [...changelog.unreleased, ...entries]
+      };
+      changelog.unreleased = [];
+      changelog.versions.unshift(newVersion);
+    } else {
+      changelog.unreleased = [...changelog.unreleased, ...entries];
+    }
+    const content = generateChangelogContent(changelog, repoUrl, format);
+    fs5.writeFileSync(changelogPath, content);
+    log(`Updated changelog at ${changelogPath}`, "success");
+  } catch (error) {
+    log(
+      `Error updating changelog: ${error instanceof Error ? error.message : String(error)}`,
+      "error"
+    );
+  }
+}
+function capitalizeFirstLetter(input) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
 
 // 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 fs4 from "node:fs";
-import path2 from "node:path";
+import fs6 from "fs";
+import path5 from "path";
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path2.join(packageDir, "package.json");
-  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
-  if (fs4.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+  if (fs6.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
       if (packageJson.version) {
         log(`Found version ${packageJson.version} in package.json`, "debug");
         return {
@@ -567,7 +1339,7 @@ function getVersionFromManifests(packageDir) {
       log(`Error reading package.json: ${errMsg}`, "warning");
     }
   }
-  if (fs4.existsSync(cargoTomlPath)) {
+  if (fs6.existsSync(cargoTomlPath)) {
     try {
       const cargoInfo = getCargoInfo(cargoTomlPath);
       if (cargoInfo.version) {
@@ -593,14 +1365,15 @@ function getVersionFromManifests(packageDir) {
   };
 }
 function throwIfNoManifestsFound(packageDir) {
-  const packageJsonPath = path2.join(packageDir, "package.json");
-  const cargoTomlPath = path2.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"];
@@ -849,7 +1622,7 @@ var PackageProcessor = class {
    * Process packages based on targeting criteria
    */
   async processPackages(packages) {
-    var _a;
+    var _a, _b, _c, _d, _e;
     const tags = [];
     const updatedPackagesInfo = [];
     if (!packages || !Array.isArray(packages)) {
@@ -934,13 +1707,81 @@ var PackageProcessor = class {
       if (!nextVersion) {
         continue;
       }
-      const packageJsonPath = path3.join(pkgPath, "package.json");
-      const cargoTomlPath = path3.join(pkgPath, "Cargo.toml");
-      if (fs5.existsSync(packageJsonPath)) {
+      if (this.fullConfig.updateChangelog !== false) {
+        let changelogEntries = [];
+        try {
+          changelogEntries = extractChangelogEntriesFromCommits(pkgPath, latestTag);
+          if (changelogEntries.length === 0) {
+            changelogEntries = [
+              {
+                type: "changed",
+                description: `Update version to ${nextVersion}`
+              }
+            ];
+          }
+        } catch (error) {
+          log(
+            `Error extracting changelog entries: ${error instanceof Error ? error.message : String(error)}`,
+            "warning"
+          );
+          changelogEntries = [
+            {
+              type: "changed",
+              description: `Update version to ${nextVersion}`
+            }
+          ];
+        }
+        let repoUrl;
+        try {
+          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;
+              } else if (packageJson.repository.url) {
+                repoUrl = packageJson.repository.url;
+              }
+              if ((repoUrl == null ? void 0 : repoUrl.startsWith("git+")) && (repoUrl == null ? void 0 : repoUrl.endsWith(".git"))) {
+                repoUrl = repoUrl.substring(4, repoUrl.length - 4);
+              }
+            }
+          }
+        } catch (error) {
+          log(
+            `Could not determine repository URL for changelog links: ${error instanceof Error ? error.message : String(error)}`,
+            "warning"
+          );
+        }
+        updateChangelog(
+          pkgPath,
+          name,
+          nextVersion,
+          changelogEntries,
+          repoUrl,
+          this.fullConfig.changelogFormat
+        );
+      }
+      const packageJsonPath = path6.join(pkgPath, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion);
       }
-      if (fs5.existsSync(cargoTomlPath)) {
-        updatePackageVersion(cargoTomlPath, nextVersion);
+      const cargoEnabled = ((_a = this.fullConfig.cargo) == null ? void 0 : _a.enabled) !== false;
+      if (cargoEnabled) {
+        const cargoPaths = (_b = this.fullConfig.cargo) == null ? void 0 : _b.paths;
+        if (cargoPaths && cargoPaths.length > 0) {
+          for (const cargoPath of cargoPaths) {
+            const resolvedCargoPath = path6.resolve(pkgPath, cargoPath, "Cargo.toml");
+            if (fs8.existsSync(resolvedCargoPath)) {
+              updatePackageVersion(resolvedCargoPath, nextVersion);
+            }
+          }
+        } else {
+          const cargoTomlPath = path6.join(pkgPath, "Cargo.toml");
+          if (fs8.existsSync(cargoTomlPath)) {
+            updatePackageVersion(cargoTomlPath, nextVersion);
+          }
+        }
       }
       const packageTag = formatTag(
         nextVersion,
@@ -972,9 +1813,32 @@ var PackageProcessor = class {
       log("No targeted packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
-    const filesToCommit = updatedPackagesInfo.map((info) => path3.join(info.path, "package.json"));
+    const filesToCommit = [];
+    for (const info of updatedPackagesInfo) {
+      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;
+      if (cargoEnabled) {
+        const cargoPaths = (_d = this.fullConfig.cargo) == null ? void 0 : _d.paths;
+        if (cargoPaths && cargoPaths.length > 0) {
+          for (const cargoPath of cargoPaths) {
+            const resolvedCargoPath = path6.resolve(info.path, cargoPath, "Cargo.toml");
+            if (fs8.existsSync(resolvedCargoPath)) {
+              filesToCommit.push(resolvedCargoPath);
+            }
+          }
+        } else {
+          const cargoTomlPath = path6.join(info.path, "Cargo.toml");
+          if (fs8.existsSync(cargoTomlPath)) {
+            filesToCommit.push(cargoTomlPath);
+          }
+        }
+      }
+    }
     const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
-    const representativeVersion = ((_a = updatedPackagesInfo[0]) == null ? void 0 : _a.version) || "multiple";
+    const representativeVersion = ((_e = updatedPackagesInfo[0]) == null ? void 0 : _e.version) || "multiple";
     let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
     const placeholderRegex = /\$\{[^}]+\}/;
     if (updatedPackagesInfo.length === 1 && placeholderRegex.test(commitMessage)) {
@@ -1032,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) {
@@ -1051,20 +1940,25 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path4.join(packages.root, "package.json");
-        if (fs6.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) {
-        log("Failed to update root package.json", "error");
+      } catch (error) {
+        const errMessage = error instanceof Error ? error.message : String(error);
+        log(`Failed to update root package.json: ${errMessage}`, "error");
       }
       for (const pkg of packages.packages) {
         if (!shouldProcessPackage(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path4.join(pkg.dir, "package.json");
+        const packageJsonPath = path7.join(pkg.dir, "package.json");
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
@@ -1094,6 +1988,7 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
+        mainPackage,
         versionPrefix,
         tagTemplate,
         packageTagTemplate,
@@ -1101,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);
@@ -1137,7 +2036,7 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path4.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(
@@ -1231,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);
@@ -1276,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) {
@@ -1296,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;
     }
@@ -1315,11 +2234,11 @@ var VersionEngine = class {
 // src/index.ts
 function getPackageVersion() {
   try {
-    const packageJsonPath = path5.resolve(
-      path5.dirname(import.meta.url.replace("file:", "")),
+    const packageJsonPath = path8.resolve(
+      path8.dirname(import.meta.url.replace("file:", "")),
       "../package.json"
     );
-    const packageJsonContent = fs7.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = fs10.readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     return packageJson.version || "0.0.0";
   } catch (error) {
@@ -1328,53 +2247,104 @@ function getPackageVersion() {
   }
 }
 async function run() {
-  const buildTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const packageVersion = getPackageVersion();
-  log(`package-versioner v${packageVersion} (Build: ${buildTimestamp})`, "debug");
-  const program = new Command();
-  program.name("package-versioner").description(
-    "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits."
-  ).version(packageVersion).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>", "Specify bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --synced", "Use 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(`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.type = options.bump;
-    if (options.prerelease)
-      config.prereleaseIdentifier = options.prerelease === true ? "next" : options.prerelease;
-    const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
-    const engine = new VersionEngine(config, !!options.json);
-    if (config.synced) {
-      log("Using synced versioning strategy.", "info");
-      engine.setStrategy("synced");
-      await engine.run();
-    } else if (config.packages && config.packages.length === 1) {
-      log("Using single package versioning strategy.", "info");
-      if (cliTargets.length > 0) {
-        log("--target flag is ignored for single package strategy.", "warning");
-      }
-      engine.setStrategy("single");
-      await engine.run();
-    } else {
-      log("Using async versioning strategy.", "info");
-      if (cliTargets.length > 0) {
-        log(`Targeting specific packages: ${cliTargets.join(", ")}`, "info");
+    const buildTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const packageVersion = getPackageVersion();
+    log(`package-versioner v${packageVersion} (Build: ${buildTimestamp})`, "debug");
+    const program = new Command();
+    program.name("package-versioner").description(
+      "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits."
+    ).version(packageVersion);
+    program.command("version", { isDefault: true }).description("Version a package or packages based on configuration").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>", "Specify bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --synced", "Use 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").action(async (options) => {
+      if (options.json) {
+        enableJsonOutput(options.dryRun);
       }
-      engine.setStrategy("async");
-      await engine.run(cliTargets);
-    }
-    log("Versioning process completed.", "success");
-    printJsonOutput();
+      try {
+        const config = await loadConfig(options.config);
+        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.type = options.bump;
+        if (options.prerelease)
+          config.prereleaseIdentifier = options.prerelease === true ? "next" : options.prerelease;
+        const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
+        const engine = new VersionEngine(config, !!options.json);
+        if (config.synced) {
+          log("Using synced versioning strategy.", "info");
+          engine.setStrategy("synced");
+          await engine.run();
+        } else if (config.packages && config.packages.length === 1) {
+          log("Using single package versioning strategy.", "info");
+          if (cliTargets.length > 0) {
+            log("--target flag is ignored for single package strategy.", "warning");
+          }
+          engine.setStrategy("single");
+          await engine.run();
+        } else {
+          log("Using async versioning strategy.", "info");
+          if (cliTargets.length > 0) {
+            log(`Targeting specific packages: ${cliTargets.join(", ")}`, "info");
+          }
+          engine.setStrategy("async");
+          await engine.run(cliTargets);
+        }
+        log("Versioning process completed.", "success");
+        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);
+      }
+    });
+    program.command("regenerate-changelog").description("Regenerate a complete changelog from git history").option("-o, --output <path>", "Output path for changelog file", "CHANGELOG.md").option(
+      "-f, --format <format>",
+      "Changelog format (keep-a-changelog|angular)",
+      "keep-a-changelog"
+    ).option("-s, --since <tag>", "Start changelog from specific tag").option("-u, --repo-url <url>", "Repository URL for changelog links").option("-d, --dry-run", "Preview changelog without writing to file", false).option("-p, --project-dir <path>", "Project directory", process.cwd()).action(async (options) => {
+      try {
+        log("Regenerating changelog from git history...", "info");
+        if (options.format !== "keep-a-changelog" && options.format !== "angular") {
+          throw new Error(
+            'Invalid format specified. Must be either "keep-a-changelog" or "angular"'
+          );
+        }
+        const regenerateOptions = {
+          format: options.format,
+          since: options.since,
+          output: options.output,
+          dryRun: options.dryRun,
+          projectDir: options.projectDir,
+          repoUrl: options.repoUrl
+        };
+        const content = await regenerateChangelog(regenerateOptions);
+        await writeChangelog(
+          content,
+          path8.resolve(options.projectDir, options.output),
+          options.dryRun
+        );
+        if (!options.dryRun) {
+          log(`Changelog successfully regenerated at ${options.output}`, "success");
+        }
+      } catch (error) {
+        log(error instanceof Error ? error.message : String(error), "error");
+        process.exit(1);
+      }
+    });
+    program.parse(process.argv);
   } catch (error) {
-    log(error instanceof Error ? error.message : String(error), "error");
+    console.error("Fatal error:", error);
     process.exit(1);
   }
 }