package-versioner 0.8.2 → 0.8.4

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import * as fs10 from "fs";
-import path8 from "path";
+import path9 from "path";
 import { Command } from "commander";
 
 // src/changelog/changelogRegenerator.ts
@@ -126,7 +126,8 @@ function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
   }
 }
 function parseCommitMessage(message) {
-  const match = message.match(CONVENTIONAL_COMMIT_REGEX);
+  const trimmedMessage = message.trim();
+  const match = trimmedMessage.match(CONVENTIONAL_COMMIT_REGEX);
   if (match) {
     const [, type, scope, breakingMark, subject, body = ""] = match;
     const breakingFromMark = breakingMark === "!";
@@ -150,8 +151,8 @@ function parseCommitMessage(message) {
       // Store original type for custom formatting
     };
   }
-  if (!message.startsWith("Merge") && !message.match(/^v?\d+\.\d+\.\d+/)) {
-    const firstLine = message.split("\n")[0].trim();
+  if (!trimmedMessage.startsWith("Merge") && !trimmedMessage.match(/^v?\d+\.\d+\.\d+/)) {
+    const firstLine = trimmedMessage.split("\n")[0].trim();
     return {
       type: "changed",
       description: firstLine
@@ -199,7 +200,9 @@ function formatChangelogEntries(format, version, date, entries, packageName, rep
     const hasBreaking = entry.description.includes("**BREAKING**");
     return {
       ...entry,
-      breaking: hasBreaking
+      breaking: hasBreaking,
+      // Clean up the description to remove the **BREAKING** prefix since we'll handle it in formatting
+      description: hasBreaking ? entry.description.replace("**BREAKING** ", "") : entry.description
     };
   });
   return format === "keep-a-changelog" ? formatKeepAChangelogEntries(version, date, formattingEntries, repoUrl) : formatAngularEntries(version, date, formattingEntries, packageName);
@@ -212,15 +215,19 @@ function formatKeepAChangelogEntries(version, date, entries, repoUrl) {
   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;
+    let entryText;
+    if (entry.breaking) {
+      entryText = entry.scope ? `- **BREAKING** **${entry.scope}**: ${entry.description}` : `- **BREAKING** ${entry.description}`;
+    } else {
+      entryText = entry.scope ? `- **${entry.scope}**: ${entry.description}` : `- ${entry.description}`;
+    }
     const entryType = entry.originalType || entry.type;
     switch (entryType) {
       case "feat":
-        added.push(formattedEntry);
+        added.push(entryText);
         break;
       case "fix":
-        fixed.push(formattedEntry);
+        fixed.push(entryText);
         break;
       case "docs":
       case "style":
@@ -228,38 +235,38 @@ function formatKeepAChangelogEntries(version, date, entries, repoUrl) {
       case "perf":
       case "build":
       case "ci":
-        changed.push(formattedEntry);
+        changed.push(entryText);
         break;
       case "test":
         break;
       case "chore":
         if (entry.description.toLowerCase().includes("deprecat")) {
-          deprecated.push(formattedEntry);
+          deprecated.push(entryText);
         } else {
-          changed.push(formattedEntry);
+          changed.push(entryText);
         }
         break;
       // Keep-a-changelog standard types
       case "added":
-        added.push(formattedEntry);
+        added.push(entryText);
         break;
       case "changed":
-        changed.push(formattedEntry);
+        changed.push(entryText);
         break;
       case "deprecated":
-        deprecated.push(formattedEntry);
+        deprecated.push(entryText);
         break;
       case "removed":
-        removed.push(formattedEntry);
+        removed.push(entryText);
         break;
       case "fixed":
-        fixed.push(formattedEntry);
+        fixed.push(entryText);
         break;
       case "security":
-        security.push(formattedEntry);
+        security.push(entryText);
         break;
       default:
-        changed.push(formattedEntry);
+        changed.push(entryText);
     }
   }
   let content = `## [${version}] - ${date}
@@ -424,13 +431,25 @@ function getAngularTemplate() {
 // 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 command = `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) => {
+    const allTags = tagOutput.split("\n").filter((tag) => !!tag);
+    let filteredTags = allTags;
+    if (since) {
+      const sinceIndex = allTags.findIndex((tag) => tag === since);
+      if (sinceIndex >= 0) {
+        filteredTags = allTags.slice(sinceIndex);
+      } else {
+        log(
+          `Warning: --since tag "${since}" not found in git history, including all tags`,
+          "warning"
+        );
+      }
+    }
+    return filteredTags.map((tag) => {
       try {
         const date = execSync2(`git log -1 --format=%ad --date=short ${tag}`, {
           encoding: "utf8"
@@ -479,7 +498,10 @@ async function regenerateChangelog(options) {
     }
   } catch {
   }
-  const tags = getAllVersionTags(since, versionPrefix);
+  let tags = getAllVersionTags(since, versionPrefix);
+  if (!tags.length && since) {
+    tags = getAllVersionTags(void 0, 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").'
@@ -493,7 +515,28 @@ async function regenerateChangelog(options) {
     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;
+      let tagRange;
+      if (previousTag) {
+        tagRange = `${previousTag}..${currentTag.tag}`;
+      } else if (since && currentTag.tag === since) {
+        try {
+          const allTagsCmd = `git tag --list "${versionPrefix}*" --sort=creatordate`;
+          const allTagsOutput = execSync2(allTagsCmd, { encoding: "utf8" }).trim();
+          const allTags = allTagsOutput.split("\n").filter((tag) => !!tag);
+          const sinceIndex = allTags.findIndex((tag) => tag === since);
+          const actualPreviousTag = sinceIndex > 0 ? allTags[sinceIndex - 1] : null;
+          if (actualPreviousTag) {
+            tagRange = `${actualPreviousTag}..${currentTag.tag}`;
+          } else {
+            tagRange = currentTag.tag;
+          }
+        } catch (error) {
+          log(`Failed to find previous tag for ${currentTag.tag}: ${error}`, "warning");
+          tagRange = currentTag.tag;
+        }
+      } else {
+        tagRange = currentTag.tag;
+      }
       const entries = extractChangelogEntriesFromCommits(projectDir, tagRange);
       if (!entries.length) {
         log(`No changelog entries found for ${currentTag.tag}, adding placeholder entry`, "info");
@@ -606,33 +649,163 @@ function createVersionError(code, details) {
   return new VersionError(fullMessage, code);
 }
 
-// src/utils/packageMatching.ts
-function matchesPackageTarget(packageName, target) {
-  if (packageName === target) {
+// src/utils/packageFiltering.ts
+import path2 from "path";
+import micromatch from "micromatch";
+function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
+  if (configTargets.length === 0) {
+    log("No config targets specified, returning all packages", "debug");
+    return packages;
+  }
+  const matchedPackages = /* @__PURE__ */ new Set();
+  for (const target of configTargets) {
+    const dirMatches = filterByDirectoryPattern(packages, target, workspaceRoot);
+    const nameMatches = filterByPackageNamePattern(packages, target);
+    dirMatches.forEach((pkg) => matchedPackages.add(pkg));
+    nameMatches.forEach((pkg) => matchedPackages.add(pkg));
+  }
+  return Array.from(matchedPackages);
+}
+function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
+  if (pattern === "./" || pattern === ".") {
+    return packages.filter((pkg) => pkg.dir === workspaceRoot);
+  }
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  return packages.filter((pkg) => {
+    const relativePath = path2.relative(workspaceRoot, pkg.dir);
+    const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+    if (normalizedPattern === normalizedRelativePath) {
+      return true;
+    }
+    try {
+      return micromatch.isMatch(normalizedRelativePath, normalizedPattern, {
+        dot: true,
+        noglobstar: false,
+        bash: true
+      });
+    } catch (error) {
+      log(
+        `Invalid directory pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`,
+        "warning"
+      );
+      return false;
+    }
+  });
+}
+function filterByPackageNamePattern(packages, pattern) {
+  return packages.filter((pkg) => {
+    var _a;
+    if (!((_a = pkg.packageJson) == null ? void 0 : _a.name) || typeof pkg.packageJson.name !== "string") {
+      return false;
+    }
+    return matchesPackageNamePattern(pkg.packageJson.name, pattern);
+  });
+}
+function matchesPackageNamePattern(packageName, pattern) {
+  if (packageName === pattern) {
     return true;
   }
-  if (target.endsWith("/*")) {
-    const scope = target.slice(0, -2);
-    if (scope.startsWith("@")) {
-      return packageName.startsWith(`${scope}/`);
-    }
+  if (pattern.startsWith("@") && pattern.endsWith("/*") && !pattern.includes("**")) {
+    const scope = pattern.slice(0, -2);
     return packageName.startsWith(`${scope}/`);
   }
-  if (target === "*") {
-    return true;
+  try {
+    return micromatch.isMatch(packageName, pattern, {
+      dot: true,
+      contains: false,
+      noglobstar: false,
+      bash: true
+    });
+  } catch (error) {
+    log(
+      `Invalid package name pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`,
+      "warning"
+    );
+    return false;
   }
-  return false;
-}
-function shouldMatchPackageTargets(packageName, targets) {
-  return targets.some((target) => matchesPackageTarget(packageName, target));
-}
-function shouldProcessPackage(packageName, skip = []) {
-  return !skip.includes(packageName);
 }
 
 // src/core/versionStrategies.ts
+import { execSync as execSync5 } from "child_process";
 import fs9 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
+
+// src/changelog/changelogManager.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function updateChangelog(packagePath, packageName, version, entries, repoUrl, format = "keep-a-changelog") {
+  try {
+    const changelogPath = path3.join(packagePath, "CHANGELOG.md");
+    let existingContent = "";
+    if (fs3.existsSync(changelogPath)) {
+      existingContent = fs3.readFileSync(changelogPath, "utf8");
+    }
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const newVersionContent = formatChangelogEntries(
+      format,
+      version,
+      today,
+      entries,
+      packageName,
+      repoUrl
+    );
+    let finalContent;
+    if (existingContent) {
+      if (format === "keep-a-changelog") {
+        const headerEndIndex = existingContent.indexOf("\n## ");
+        if (headerEndIndex > 0) {
+          const beforeVersions = existingContent.substring(0, headerEndIndex);
+          const afterVersions = existingContent.substring(headerEndIndex);
+          finalContent = `${beforeVersions}
+${newVersionContent}
+${afterVersions}`;
+        } else {
+          finalContent = `${existingContent}
+${newVersionContent}
+`;
+        }
+      } else {
+        const headerEndIndex = existingContent.indexOf("\n## ");
+        if (headerEndIndex > 0) {
+          const beforeVersions = existingContent.substring(0, headerEndIndex);
+          const afterVersions = existingContent.substring(headerEndIndex);
+          finalContent = `${beforeVersions}
+${newVersionContent}
+${afterVersions}`;
+        } else {
+          finalContent = `${existingContent}
+${newVersionContent}
+`;
+        }
+      }
+    } else {
+      if (format === "keep-a-changelog") {
+        finalContent = `# Changelog
+
+All notable changes to ${packageName} will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+${newVersionContent}
+`;
+      } else {
+        finalContent = `# Changelog
+
+${newVersionContent}
+`;
+      }
+    }
+    log(`Writing changelog to: ${changelogPath}`, "info");
+    fs3.writeFileSync(changelogPath, finalContent);
+    log(`Updated changelog at ${changelogPath}`, "success");
+  } catch (error) {
+    log(
+      `Error updating changelog: ${error instanceof Error ? error.message : String(error)}`,
+      "error"
+    );
+  }
+}
 
 // src/git/commands.ts
 import { cwd as cwd2 } from "process";
@@ -658,11 +831,11 @@ var execAsync = (command, options) => {
 var execSync3 = (command, args) => nativeExecSync(command, { maxBuffer: 1024 * 1024 * 10, ...args });
 
 // src/git/repository.ts
-import { existsSync, statSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, statSync } from "fs";
+import { join as join2 } from "path";
 function isGitRepository(directory) {
-  const gitDir = join(directory, ".git");
-  if (!existsSync(gitDir)) {
+  const gitDir = join2(directory, ".git");
+  if (!existsSync2(gitDir)) {
     return false;
   }
   const stats = statSync(gitDir);
@@ -1020,21 +1193,21 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 }
 
 // src/package/packageManagement.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import * as TOML from "smol-toml";
 function getCargoInfo(cargoPath) {
   var _a;
-  if (!fs3.existsSync(cargoPath)) {
+  if (!fs4.existsSync(cargoPath)) {
     log(`Cargo.toml file not found at: ${cargoPath}`, "error");
     throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
   }
   try {
-    const fileContent = fs3.readFileSync(cargoPath, "utf8");
+    const fileContent = fs4.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");
@@ -1044,7 +1217,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path2.dirname(cargoPath),
+      dir: path4.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -1057,12 +1230,12 @@ function getCargoInfo(cargoPath) {
   }
 }
 function isCargoToml(filePath) {
-  return path2.basename(filePath) === "Cargo.toml";
+  return path4.basename(filePath) === "Cargo.toml";
 }
 function updateCargoVersion(cargoPath, version) {
   var _a;
   try {
-    const originalContent = fs3.readFileSync(cargoPath, "utf8");
+    const originalContent = fs4.readFileSync(cargoPath, "utf8");
     const cargo = TOML.parse(originalContent);
     const packageName = (_a = cargo.package) == null ? void 0 : _a.name;
     if (!packageName) {
@@ -1074,7 +1247,7 @@ function updateCargoVersion(cargoPath, version) {
       cargo.package.version = version;
     }
     const updatedContent = TOML.stringify(cargo);
-    fs3.writeFileSync(cargoPath, updatedContent);
+    fs4.writeFileSync(cargoPath, updatedContent);
     addPackageUpdate(packageName, version, cargoPath);
     log(`Updated Cargo.toml at ${cargoPath} to version ${version}`, "success");
   } catch (error) {
@@ -1093,11 +1266,11 @@ function updatePackageVersion(packagePath, version) {
     return;
   }
   try {
-    const packageContent = fs4.readFileSync(packagePath, "utf8");
+    const packageContent = fs5.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     packageJson.version = version;
-    fs4.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+    fs5.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
     addPackageUpdate(packageName, version, packagePath);
     log(`Updated package.json at ${packagePath} to version ${version}`, "success");
@@ -1113,334 +1286,9 @@ function updatePackageVersion(packagePath, version) {
 // src/package/packageProcessor.ts
 import { execSync as execSync4 } from "child_process";
 import * as fs8 from "fs";
-import path6 from "path";
+import path7 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 "process";
 import { Bumper } from "conventional-recommended-bump";
@@ -1448,10 +1296,10 @@ import semver3 from "semver";
 
 // src/utils/manifestHelpers.ts
 import fs6 from "fs";
-import path5 from "path";
+import path6 from "path";
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path5.join(packageDir, "package.json");
-  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path6.join(packageDir, "package.json");
+  const cargoTomlPath = path6.join(packageDir, "Cargo.toml");
   if (fs6.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
@@ -1496,8 +1344,8 @@ function getVersionFromManifests(packageDir) {
   };
 }
 function throwIfNoManifestsFound(packageDir) {
-  const packageJsonPath = path5.join(packageDir, "package.json");
-  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path6.join(packageDir, "package.json");
+  const cargoTomlPath = path6.join(packageDir, "Cargo.toml");
   throw new Error(
     `Neither package.json nor Cargo.toml found at ${packageDir}. Checked paths: ${packageJsonPath}, ${cargoTomlPath}. Cannot determine version.`
   );
@@ -1774,6 +1622,42 @@ function calculateNextVersion(version, manifestType, name, releaseType, prerelea
   return result || initialVersion;
 }
 
+// src/utils/packageMatching.ts
+import micromatch2 from "micromatch";
+function matchesPackageTarget(packageName, target) {
+  if (packageName === target) {
+    return true;
+  }
+  if (target.startsWith("@") && target.endsWith("/*") && !target.includes("**")) {
+    const scope = target.slice(0, -2);
+    return packageName.startsWith(`${scope}/`);
+  }
+  try {
+    return micromatch2.isMatch(packageName, target, {
+      dot: true,
+      contains: false,
+      // Changed to false to ensure full pattern matching
+      noglobstar: false,
+      bash: true
+    });
+  } catch (error) {
+    log(
+      `Invalid pattern "${target}": ${error instanceof Error ? error.message : String(error)}`,
+      "warning"
+    );
+    return false;
+  }
+}
+function shouldMatchPackageTargets(packageName, targets) {
+  return targets.some((target) => matchesPackageTarget(packageName, target));
+}
+function shouldProcessPackage(packageName, skip = []) {
+  if (skip.length === 0) {
+    return true;
+  }
+  return !shouldMatchPackageTargets(packageName, skip);
+}
+
 // src/package/packageProcessor.ts
 var PackageProcessor = class {
   skip;
@@ -1884,22 +1768,20 @@ var PackageProcessor = class {
       if (this.fullConfig.updateChangelog !== false) {
         let changelogEntries = [];
         try {
-          let revisionRange = latestTag;
+          let revisionRange;
           if (latestTag) {
             try {
               execSync4(`git rev-parse --verify "${latestTag}"`, {
                 cwd: pkgPath,
                 stdio: "ignore"
               });
+              revisionRange = `${latestTag}..HEAD`;
             } catch {
-              log(
-                `Tag ${latestTag} doesn't exist, using recent commits from HEAD for changelog`,
-                "debug"
-              );
-              revisionRange = "HEAD~10..HEAD";
+              log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
+              revisionRange = "HEAD";
             }
           } else {
-            revisionRange = "HEAD~10..HEAD";
+            revisionRange = "HEAD";
           }
           changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
           if (changelogEntries.length === 0) {
@@ -1924,7 +1806,7 @@ var PackageProcessor = class {
         }
         let repoUrl;
         try {
-          const packageJsonPath2 = path6.join(pkgPath, "package.json");
+          const packageJsonPath2 = path7.join(pkgPath, "package.json");
           if (fs8.existsSync(packageJsonPath2)) {
             const packageJson = JSON.parse(fs8.readFileSync(packageJsonPath2, "utf8"));
             if (packageJson.repository) {
@@ -1953,7 +1835,7 @@ var PackageProcessor = class {
           this.fullConfig.changelogFormat
         );
       }
-      const packageJsonPath = path6.join(pkgPath, "package.json");
+      const packageJsonPath = path7.join(pkgPath, "package.json");
       if (fs8.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion);
       }
@@ -1962,13 +1844,13 @@ 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 = path6.resolve(pkgPath, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path7.resolve(pkgPath, cargoPath, "Cargo.toml");
             if (fs8.existsSync(resolvedCargoPath)) {
               updatePackageVersion(resolvedCargoPath, nextVersion);
             }
           }
         } else {
-          const cargoTomlPath = path6.join(pkgPath, "Cargo.toml");
+          const cargoTomlPath = path7.join(pkgPath, "Cargo.toml");
           if (fs8.existsSync(cargoTomlPath)) {
             updatePackageVersion(cargoTomlPath, nextVersion);
           }
@@ -2006,7 +1888,7 @@ var PackageProcessor = class {
     }
     const filesToCommit = [];
     for (const info of updatedPackagesInfo) {
-      const packageJsonPath = path6.join(info.path, "package.json");
+      const packageJsonPath = path7.join(info.path, "package.json");
       if (fs8.existsSync(packageJsonPath)) {
         filesToCommit.push(packageJsonPath);
       }
@@ -2015,13 +1897,13 @@ 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 = path6.resolve(info.path, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path7.resolve(info.path, cargoPath, "Cargo.toml");
             if (fs8.existsSync(resolvedCargoPath)) {
               filesToCommit.push(resolvedCargoPath);
             }
           }
         } else {
-          const cargoTomlPath = path6.join(info.path, "Cargo.toml");
+          const cargoTomlPath = path7.join(info.path, "Cargo.toml");
           if (fs8.existsSync(cargoTomlPath)) {
             filesToCommit.push(cargoTomlPath);
           }
@@ -2084,7 +1966,7 @@ function createSyncedStrategy(config) {
         mainPackage
       } = config;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
-      const latestTag = await getLatestTag();
+      let latestTag = await getLatestTag();
       let mainPkgPath = packages.root;
       let mainPkgName;
       if (mainPackage) {
@@ -2107,6 +1989,21 @@ function createSyncedStrategy(config) {
           "warning"
         );
       }
+      if (mainPkgName) {
+        const packageSpecificTag = await getLatestTagForPackage(mainPkgName, formattedPrefix, {
+          tagTemplate,
+          packageSpecificTags: config.packageSpecificTags
+        });
+        if (packageSpecificTag) {
+          latestTag = packageSpecificTag;
+          log(`Using package-specific tag for ${mainPkgName}: ${latestTag}`, "debug");
+        } else {
+          log(
+            `No package-specific tag found for ${mainPkgName}, using global tag: ${latestTag}`,
+            "debug"
+          );
+        }
+      }
       const nextVersion = await calculateVersion(config, {
         latestTag,
         versionPrefix: formattedPrefix,
@@ -2118,7 +2015,8 @@ function createSyncedStrategy(config) {
         type: config.type
       });
       if (!nextVersion) {
-        log("No version change needed", "info");
+        const msg = mainPkgName ? `No version change needed for ${mainPkgName}` : "No version change needed";
+        log(msg, "info");
         return;
       }
       const files = [];
@@ -2126,7 +2024,7 @@ function createSyncedStrategy(config) {
       const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
-          const rootPkgPath = path7.join(packages.root, "package.json");
+          const rootPkgPath = path8.join(packages.root, "package.json");
           if (fs9.existsSync(rootPkgPath)) {
             updatePackageVersion(rootPkgPath, nextVersion);
             files.push(rootPkgPath);
@@ -2144,7 +2042,7 @@ function createSyncedStrategy(config) {
         if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path7.join(pkg.dir, "package.json");
+        const packageJsonPath = path8.join(pkg.dir, "package.json");
         if (processedPaths.has(packageJsonPath)) {
           continue;
         }
@@ -2160,7 +2058,7 @@ function createSyncedStrategy(config) {
         return;
       }
       let tagPackageName = null;
-      let commitPackageName = void 0;
+      let commitPackageName;
       if (config.packageSpecificTags && packages.packages.length === 1) {
         tagPackageName = packages.packages[0].packageJson.name;
         commitPackageName = packages.packages[0].packageJson.name;
@@ -2194,7 +2092,6 @@ function createSingleStrategy(config) {
   return async (packages) => {
     try {
       const {
-        packages: configPackages,
         mainPackage,
         versionPrefix,
         tagTemplate,
@@ -2205,12 +2102,12 @@ function createSingleStrategy(config) {
       let packageName;
       if (mainPackage) {
         packageName = mainPackage;
-      } else if (configPackages && configPackages.length === 1) {
-        packageName = configPackages[0];
+      } else if (packages.packages.length === 1) {
+        packageName = packages.packages[0].packageJson.name;
       } else {
         throw createVersionError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          "Single mode requires either mainPackage or exactly one package in the packages array"
+          "Single mode requires either mainPackage or exactly one resolved package"
         );
       }
       const pkg = packages.packages.find((p) => p.packageJson.name === packageName);
@@ -2228,50 +2125,114 @@ function createSingleStrategy(config) {
         latestTagResult = globalTagResult || "";
       }
       const latestTag = latestTagResult;
-      let nextVersion = void 0;
-      try {
-        nextVersion = await calculateVersion(config, {
-          latestTag,
-          versionPrefix: formattedPrefix,
-          path: pkgPath,
-          name: packageName,
-          type: config.type
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw createVersionError("VERSION_CALCULATION_ERROR" /* VERSION_CALCULATION_ERROR */, errorMessage);
-      }
-      if (nextVersion === void 0 || nextVersion === "") {
+      let nextVersion;
+      nextVersion = await calculateVersion(config, {
+        latestTag,
+        versionPrefix: formattedPrefix,
+        branchPattern: config.branchPattern,
+        baseBranch: config.baseBranch,
+        prereleaseIdentifier: config.prereleaseIdentifier,
+        path: pkgPath,
+        name: packageName,
+        type: config.type
+      });
+      if (!nextVersion) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path7.join(pkgPath, "package.json");
+      if (config.updateChangelog !== false) {
+        let changelogEntries = [];
+        try {
+          let revisionRange;
+          if (latestTag) {
+            try {
+              execSync5(`git rev-parse --verify "${latestTag}"`, {
+                cwd: pkgPath,
+                stdio: "ignore"
+              });
+              revisionRange = `${latestTag}..HEAD`;
+            } catch {
+              log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
+              revisionRange = "HEAD";
+            }
+          } else {
+            revisionRange = "HEAD";
+          }
+          changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
+          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 = path8.join(pkgPath, "package.json");
+          if (fs9.existsSync(packageJsonPath2)) {
+            const packageJson = JSON.parse(fs9.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,
+          packageName,
+          nextVersion,
+          changelogEntries,
+          repoUrl,
+          config.changelogFormat
+        );
+      }
+      const packageJsonPath = path8.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion);
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
-      const nextTag = formatTag(
+      const tagName = formatTag(
         nextVersion,
         formattedPrefix,
         packageName,
         tagTemplate,
         config.packageSpecificTags
       );
-      const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, packageName);
-      await createGitCommitAndTag(
-        [packageJsonPath],
-        nextTag,
-        formattedCommitMessage,
-        skipHooks,
-        dryRun
-      );
+      const commitMsg = formatCommitMessage(commitMessage, nextVersion, packageName);
+      if (!dryRun) {
+        await createGitCommitAndTag([packageJsonPath], tagName, commitMsg, skipHooks, dryRun);
+        log(`Created tag: ${tagName}`, "success");
+      } else {
+        log(`Would create tag: ${tagName}`, "info");
+      }
     } catch (error) {
       if (error instanceof VersionError || error instanceof GitError) {
-        log(
-          `Single Package Strategy failed: ${error.message} (${error.code || "UNKNOWN"})`,
-          "error"
-        );
+        log(`Single Strategy failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
       } else {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Single Package Strategy failed: ${errorMessage}`, "error");
+        log(`Single Strategy failed: ${errorMessage}`, "error");
       }
       throw error;
     }
@@ -2327,13 +2288,9 @@ function createAsyncStrategy(config) {
   };
 }
 function createStrategy(config) {
-  var _a;
   if (config.synced) {
     return createSyncedStrategy(config);
   }
-  if (config.mainPackage || ((_a = config.packages) == null ? void 0 : _a.length) === 1) {
-    return createSingleStrategy(config);
-  }
   return createAsyncStrategy(config);
 }
 function createStrategyMap(config) {
@@ -2385,8 +2342,10 @@ var VersionEngine = class {
       }
       if (this.config.packages && this.config.packages.length > 0) {
         const originalCount = pkgsResult.packages.length;
-        const filteredPackages = pkgsResult.packages.filter(
-          (pkg) => shouldMatchPackageTargets(pkg.packageJson.name, this.config.packages)
+        const filteredPackages = filterPackagesByConfig(
+          pkgsResult.packages,
+          this.config.packages,
+          pkgsResult.root
         );
         pkgsResult.packages = filteredPackages;
         log(
@@ -2396,11 +2355,6 @@ var VersionEngine = class {
         if (filteredPackages.length === 0) {
           log("Warning: No packages matched the specified patterns in config.packages", "warning");
         }
-      } else {
-        log(
-          `Processing all ${pkgsResult.packages.length} workspace packages (no packages filter specified)`,
-          "info"
-        );
       }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
@@ -2413,11 +2367,11 @@ var VersionEngine = class {
   }
   /**
    * Run the current strategy
+   * @param packages Workspace packages to process
    * @param targets Optional package targets to process (only used by async strategy)
    */
-  async run(targets = []) {
+  async run(packages, targets = []) {
     try {
-      const packages = await this.getWorkspacePackages();
       return this.currentStrategy(packages, targets);
     } catch (error) {
       if (error instanceof VersionError || error instanceof GitError) {
@@ -2454,8 +2408,8 @@ var VersionEngine = class {
 // src/index.ts
 function getPackageVersion() {
   try {
-    const packageJsonPath = path8.resolve(
-      path8.dirname(import.meta.url.replace("file:", "")),
+    const packageJsonPath = path9.resolve(
+      path9.dirname(import.meta.url.replace("file:", "")),
       "../package.json"
     );
     const packageJsonContent = fs10.readFileSync(packageJsonPath, "utf-8");
@@ -2492,24 +2446,31 @@ async function run() {
           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);
+        const pkgsResult = await engine.getWorkspacePackages();
+        const resolvedCount = pkgsResult.packages.length;
+        log(`Resolved ${resolvedCount} packages from workspace`, "debug");
+        log(`Config packages: ${JSON.stringify(config.packages)}`, "debug");
+        log(`Config synced: ${config.synced}`, "debug");
         if (config.synced) {
           log("Using synced versioning strategy.", "info");
           engine.setStrategy("synced");
-          await engine.run();
-        } else if (config.packages && config.packages.length === 1) {
+          await engine.run(pkgsResult);
+        } else if (resolvedCount === 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();
+          await engine.run(pkgsResult);
+        } else if (resolvedCount === 0) {
+          throw new Error("No packages found in workspace");
         } 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);
+          await engine.run(pkgsResult, cliTargets);
         }
         log("Versioning process completed.", "success");
         printJsonOutput();
@@ -2528,38 +2489,43 @@ async function run() {
         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(
+    program.command("changelog").description("Changelog management commands").option("--regenerate", "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"'
+      var _a;
+      if (options.regenerate) {
+        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,
+            path9.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);
         }
-        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);
+      } else {
+        (_a = program.commands.find((cmd) => cmd.name() === "changelog")) == null ? void 0 : _a.help();
       }
     });
     program.parse(process.argv);