@kb-labs/release-manager-changelog 0.6.0

package/dist/index.js

@@ -0,0 +1,1429 @@
+import simpleGit from 'simple-git';
+import { readFile, mkdir, writeFile, access } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname, join, isAbsolute } from 'path';
+import semver from 'semver';
+import { createHash } from 'crypto';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+// src/parser.ts
+async function parseCommits(options) {
+  const {
+    cwd,
+    from,
+    to = "HEAD",
+    packagePath,
+    ignoreAuthors = [],
+    includeTypes,
+    excludeTypes,
+    collapseMerges = true,
+    collapseReverts = true,
+    preferMergeSummary = true
+  } = options;
+  const git = simpleGit(cwd);
+  const format = "%H%x00%an%x00%ae%x00%ai%x00%s%x00%b%n--COMMIT_FOOTER--";
+  const useRoot = from.endsWith("^");
+  const logArgs = useRoot ? ["log", "--no-merges", "--name-status", "--root", `--format=${format}`, to] : ["log", "--no-merges", "--name-status", `--format=${format}`, `${from}..${to}`];
+  if (packagePath) {
+    logArgs.push("--", packagePath);
+  }
+  const logOutput = await git.raw(logArgs);
+  return parseGitLogOutput(logOutput, {
+    ignoreAuthors,
+    includeTypes,
+    excludeTypes});
+}
+function parseGitLogOutput(output, options) {
+  const changes = [];
+  const commits = output.split("--COMMIT_FOOTER--").filter(Boolean);
+  for (let i = 0; i < commits.length; i++) {
+    const commitBlock = commits[i];
+    if (!commitBlock) {
+      continue;
+    }
+    const lines = commitBlock.split("\n");
+    let header = "";
+    for (const line of lines) {
+      if (line.trim() && line.includes("\0")) {
+        header = line;
+        break;
+      }
+    }
+    if (!header) {
+      continue;
+    }
+    const fileLines = [];
+    if (i + 1 < commits.length) {
+      const nextBlock = commits[i + 1];
+      if (!nextBlock) {
+        continue;
+      }
+      const nextLines = nextBlock.split("\n");
+      for (const line of nextLines) {
+        if (line.trim() && line.includes("\0")) {
+          break;
+        }
+        if (line.trim()) {
+          fileLines.push(line);
+        }
+      }
+    }
+    const [sha, authorName, authorEmail, authorDate, subject, body = ""] = header.split("\0");
+    if (!sha || sha.length !== 40 || !authorName || !authorEmail || !authorDate || !subject) {
+      continue;
+    }
+    if (options.ignoreAuthors.some((pattern) => matchesGlob(authorName, pattern))) {
+      continue;
+    }
+    const convention = parseConventionalCommit(`${subject}
+
+${body || ""}`);
+    if (shouldSkipCommit(convention.type, options.includeTypes, options.excludeTypes)) {
+      continue;
+    }
+    const filesChanged = parseFileChanges(fileLines);
+    const packages = extractPackagesFromFiles(filesChanged);
+    const change = {
+      sha,
+      type: convention.type,
+      scope: convention.scope,
+      subject: convention.subject,
+      body: convention.body,
+      breaking: convention.breaking,
+      refs: extractReferences(convention.footers),
+      author: {
+        name: authorName,
+        email: authorEmail
+      },
+      coAuthors: extractCoAuthors(convention.footers),
+      packages,
+      filesChanged: filesChanged.map((f) => f.path),
+      timestamp: authorDate,
+      isMerge: false,
+      isRevert: convention.type === "revert",
+      revertOf: extractRevertOf(convention.body),
+      cherryPickOf: extractCherryPickOf(convention.footers)
+    };
+    changes.push(change);
+  }
+  return changes;
+}
+function parseConventionalCommit(commitMessage) {
+  const lines = commitMessage.split("\n");
+  const header = lines[0] || "";
+  const bodyLines = lines.slice(2);
+  const body = bodyLines.join("\n").trim();
+  const headerMatch = header.match(/^(\w+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/);
+  let parsedType;
+  let parsedScope;
+  let parsedSubject = "";
+  let hasBreaking = false;
+  if (headerMatch) {
+    parsedType = headerMatch[1];
+    parsedScope = headerMatch[2];
+    hasBreaking = headerMatch[3] === "!";
+    parsedSubject = headerMatch[4] || "";
+  } else {
+    parsedType = void 0;
+    parsedSubject = header;
+  }
+  const type = normalizeType(parsedType);
+  const breaking = [];
+  if (hasBreaking) {
+    breaking.push({ summary: parsedSubject });
+  }
+  const footers = [];
+  const footerLines = body.split("\n");
+  for (const line of footerLines) {
+    if (/^[A-Z-]+:\s*/.test(line)) {
+      footers.push(line);
+      const breakingMatch = line.match(/^BREAKING CHANGE:\s*(.+)/);
+      if (breakingMatch && breakingMatch[1]) {
+        breaking.push({ summary: breakingMatch[1] });
+      }
+    }
+  }
+  return {
+    type,
+    scope: parsedScope,
+    subject: parsedSubject,
+    body: body || void 0,
+    breaking: breaking.length > 0 ? breaking : void 0,
+    footers
+  };
+}
+function normalizeType(type) {
+  const normalized = (type || "chore").toLowerCase();
+  const validTypes = ["feat", "fix", "perf", "refactor", "docs", "build", "ci", "test", "chore", "revert", "style"];
+  return validTypes.includes(normalized) ? normalized : "chore";
+}
+function parseFileChanges(lines) {
+  const changes = [];
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("diff --git")) {
+      continue;
+    }
+    const match = line.match(/^([ADMRT])\t(.*?)$/);
+    if (!match) {
+      continue;
+    }
+    const [, status, path] = match;
+    if (!path || !status) {
+      continue;
+    }
+    if (status === "R" || status === "C") {
+      const [oldPath, newPath] = path.split("	");
+      if (newPath) {
+        changes.push({ path: newPath, status, oldPath });
+      }
+      if (oldPath) {
+        changes.push({ path: oldPath, status: "D" });
+      }
+    } else {
+      changes.push({ path, status });
+    }
+  }
+  return changes;
+}
+function extractPackagesFromFiles(files) {
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const match = file.path.match(/^packages\/([^/]+)/);
+    if (match) {
+      packages.add(`packages/${match[1]}`);
+    }
+  }
+  return Array.from(packages);
+}
+function extractReferences(footers) {
+  const refs = [];
+  for (const footer of footers) {
+    const match = footer.match(/(?:Closes|Fixes|Refs)\s+#(\d+)/i);
+    if (match && match[1]) {
+      refs.push({
+        type: footer.toLowerCase().includes("closes") || footer.toLowerCase().includes("fixes") ? "issue" : "pr",
+        id: match[1]
+      });
+    }
+  }
+  return refs;
+}
+function extractCoAuthors(footers) {
+  const coAuthors = [];
+  for (const footer of footers) {
+    const match = footer.match(/^Co-authored-by:\s*(.+?)\s*<(.+?)>$/i);
+    if (match && match[1] && match[2]) {
+      coAuthors.push({
+        name: match[1].trim(),
+        email: match[2].trim()
+      });
+    }
+  }
+  return coAuthors;
+}
+function extractRevertOf(body, footers) {
+  if (!body) {
+    return void 0;
+  }
+  const match = body.match(/revert (?:of\s+)?([0-9a-f]{40})/i);
+  return match ? match[1] : void 0;
+}
+function extractCherryPickOf(footers) {
+  for (const footer of footers) {
+    const match = footer.match(/cherry picked from (.+)/i);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  return void 0;
+}
+function shouldSkipCommit(type, includeTypes, excludeTypes) {
+  if (includeTypes && !includeTypes.includes(type)) {
+    return true;
+  }
+  if (excludeTypes && excludeTypes.includes(type)) {
+    return true;
+  }
+  return false;
+}
+function matchesGlob(text, pattern) {
+  const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(text);
+}
+var CACHE_FILE = "cache.json";
+var GRAPH_FILE = "graph.json";
+var LOCK_FILE = ".cache.lock";
+async function loadCache(cacheDir) {
+  const cachePath = join(cacheDir, CACHE_FILE);
+  try {
+    if (!existsSync(cachePath)) {
+      return null;
+    }
+    const content = await readFile(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+async function saveCache(cacheDir, cache) {
+  const cachePath = join(cacheDir, CACHE_FILE);
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+  } catch (error) {
+    console.warn(`Failed to save cache: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function getCachedChange(cache, sha) {
+  if (!cache) {
+    return null;
+  }
+  return cache.commits[sha] || null;
+}
+function updateCache(cache, commits) {
+  if (!cache) {
+    cache = {
+      meta: {
+        graphHash: "",
+        HEAD: ""
+      },
+      commits: {},
+      lastTags: {}
+    };
+  }
+  for (const commit of commits) {
+    cache.commits[commit.sha] = commit;
+  }
+  return cache;
+}
+async function saveGraphSnapshot(cacheDir, graphHash) {
+  const graphPath = join(cacheDir, GRAPH_FILE);
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    const content = JSON.stringify({ hash: graphHash, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, null, 2);
+    await writeFile(graphPath, content, "utf-8");
+    const cache = await loadCache(cacheDir);
+    if (cache) {
+      cache.meta.graphHash = graphHash;
+      await saveCache(cacheDir, cache);
+    }
+  } catch (error) {
+    console.warn(`Failed to save graph snapshot: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function updateHead(cacheDir, head) {
+  const cache = await loadCache(cacheDir);
+  if (cache) {
+    cache.meta.HEAD = head;
+    await saveCache(cacheDir, cache);
+  }
+}
+async function updateLastTag(cacheDir, packageName, tag, sha) {
+  const cache = await loadCache(cacheDir);
+  const updatedCache = updateCache(cache, []);
+  updatedCache.lastTags[packageName] = { tag, sha };
+  await saveCache(cacheDir, updatedCache);
+}
+function getLastTag(cache, packageName) {
+  if (!cache) {
+    return null;
+  }
+  return cache.lastTags[packageName] || null;
+}
+async function isCacheValid(cacheDir, from, to, currentGraphHash, currentHead) {
+  const cache = await loadCache(cacheDir);
+  if (!cache) {
+    return false;
+  }
+  if (currentGraphHash && cache.meta.graphHash && cache.meta.graphHash !== currentGraphHash) {
+    return false;
+  }
+  if (currentHead && cache.meta.HEAD && !isCommitValid(cache.meta.HEAD)) ;
+  return true;
+}
+function isCommitValid(commit, from, to) {
+  return true;
+}
+async function acquireLock(cacheDir) {
+  const lockPath = join(cacheDir, LOCK_FILE);
+  if (existsSync(lockPath)) {
+    throw new Error("Cache lock already acquired. Another process may be running.");
+  }
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(lockPath, JSON.stringify({
+    pid: process.pid,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }), "utf-8");
+  return async () => {
+    if (existsSync(lockPath)) {
+      try {
+        await writeFile(lockPath, "", "utf-8");
+      } catch {
+      }
+    }
+  };
+}
+async function resolveGitRange(options) {
+  const { cwd, from, to = "HEAD", sinceTag, autoUnshallow, requireSignedTags } = options;
+  const git = simpleGit(cwd);
+  if (sinceTag || from) {
+    await ensureHistoryDepth(git, sinceTag || from || "HEAD", "HEAD", autoUnshallow);
+  }
+  const lastTag = await findLastTag(git, requireSignedTags);
+  const fromRef = sinceTag || from || lastTag || await findFirstCommit(git);
+  const toRef = to;
+  return { from: fromRef, to: toRef };
+}
+async function findFirstCommit(git) {
+  try {
+    const result = await git.raw(["rev-list", "--max-parents=0", "HEAD"]);
+    const firstCommit = result.trim();
+    return `${firstCommit}^`;
+  } catch (error) {
+    return "HEAD~1";
+  }
+}
+async function findLastTag(git, requireSigned) {
+  try {
+    const tags = await git.tags();
+    const candidateTags = requireSigned ? await filterSignedTags(git, tags.all) : tags.all;
+    const recentTag = candidateTags.sort().reverse()[0];
+    return recentTag || null;
+  } catch (error) {
+    return null;
+  }
+}
+async function findPackageTag(git, packageName, requireSigned) {
+  try {
+    const tags = await git.tags();
+    const packageRegex = new RegExp(`@${packageName.replace("@", "")}@v?\\d+\\.\\d+\\.\\d+`);
+    const packageTags = tags.all.filter((tag) => packageRegex.test(tag));
+    const candidateTags = requireSigned ? await filterSignedTags(git, packageTags) : packageTags;
+    return candidateTags.sort().reverse()[0] || null;
+  } catch {
+    return null;
+  }
+}
+async function filterSignedTags(git, tags) {
+  const signed = [];
+  for (const tag of tags) {
+    try {
+      const content = await git.raw(["cat-file", "tag", tag]);
+      if (content.includes("-----BEGIN PGP SIGNATURE-----")) {
+        signed.push(tag);
+      }
+    } catch {
+    }
+  }
+  return signed;
+}
+async function ensureHistoryDepth(git, from, to, autoUnshallow) {
+  try {
+    await git.raw(["rev-list", "--count", `${from}..${to}`]);
+  } catch (error) {
+    if (autoUnshallow) {
+      console.log("\u26A0\uFE0F  Shallow clone detected. Fetching full history...");
+      try {
+        await git.fetch(["--prune", "--unshallow", "--tags"]);
+      } catch (fetchError) {
+        throw new Error(
+          "Shallow clone detected. Full history fetch failed. Run manually: git fetch --unshallow --tags"
+        );
+      }
+    } else {
+      throw new Error(
+        "Shallow clone detected. Use --auto-unshallow flag or run: git fetch --unshallow --tags"
+      );
+    }
+  }
+}
+function parseGitUrl(url) {
+  const match = url.match(/(?:https:\/\/([^/]+)|git@([^:]+):)(?:.*?\/)?([^/]+)\/([^/]+)(?:\.git)?$/);
+  if (!match) {
+    return null;
+  }
+  const host = match[1] || match[2] || "";
+  const owner = match[3] || "";
+  const repo = match[4] || "";
+  return { host, owner, repo };
+}
+function computeBump(changes) {
+  const hasBreaking = changes.some((c) => c.breaking && c.breaking.length > 0);
+  const hasFeature = changes.some((c) => c.type === "feat");
+  const hasFix = changes.some((c) => ["fix", "perf", "refactor"].includes(c.type));
+  if (hasBreaking) {
+    return "major";
+  }
+  if (hasFeature) {
+    return "minor";
+  }
+  if (hasFix) {
+    return "patch";
+  }
+  return "none";
+}
+function computeNextVersion(currentVersion, bump, preid) {
+  if (bump === "none") {
+    return currentVersion;
+  }
+  if (preid) {
+    const nextVersion = semver.inc(currentVersion, bump === "major" ? "major" : bump === "minor" ? "minor" : "patch");
+    if (!nextVersion) {
+      return currentVersion;
+    }
+    const prerelease = semver.prerelease(nextVersion);
+    if (prerelease && prerelease[0] === preid) {
+      prerelease[1];
+      return semver.inc(nextVersion, "prerelease", preid) || nextVersion;
+    }
+    return `${nextVersion}-${preid}.1`;
+  }
+  return semver.inc(currentVersion, bump) || currentVersion;
+}
+function getImpactReason(changes) {
+  if (changes.some((c) => c.breaking && c.breaking.length > 0)) {
+    return { reason: "breaking", details: "Contains breaking changes" };
+  }
+  if (changes.some((c) => c.type === "feat")) {
+    return { reason: "feat", details: "New features added" };
+  }
+  if (changes.some((c) => c.type === "fix")) {
+    return { reason: "fix", details: "Bug fixes included" };
+  }
+  if (changes.some((c) => c.type === "perf")) {
+    return { reason: "perf", details: "Performance improvements" };
+  }
+  return { reason: "manual", details: "Manual version bump" };
+}
+function getRipplePackages(packageName, dependencyGraph, visited = /* @__PURE__ */ new Set()) {
+  const ripple = [];
+  if (visited.has(packageName)) {
+    return ripple;
+  }
+  visited.add(packageName);
+  for (const [pkg, deps] of Object.entries(dependencyGraph)) {
+    if (deps.includes(packageName) && pkg !== packageName) {
+      if (!ripple.includes(pkg)) {
+        ripple.push(pkg);
+      }
+      const transitive = getRipplePackages(pkg, dependencyGraph, visited);
+      for (const t2 of transitive) {
+        if (!ripple.includes(t2)) {
+          ripple.push(t2);
+        }
+      }
+    }
+  }
+  return ripple;
+}
+function applyVersionPolicy(changes, affectedPackages, currentVersions, policy, dependencyGraph) {
+  const result = {};
+  const changesByPackage = {};
+  for (const change of changes) {
+    for (const pkg of change.packages) {
+      if (!changesByPackage[pkg]) {
+        changesByPackage[pkg] = [];
+      }
+      changesByPackage[pkg].push(change);
+    }
+  }
+  if (policy === "independent") {
+    for (const pkg of affectedPackages) {
+      const pkgChanges = changesByPackage[pkg] || [];
+      const bump = computeBump(pkgChanges);
+      const reasonInfo = getImpactReason(pkgChanges);
+      const currentVersion = currentVersions[pkg] || "0.0.0";
+      const nextVersion = computeNextVersion(currentVersion, bump);
+      result[pkg] = {
+        nextVersion,
+        bump,
+        reason: reasonInfo.reason
+      };
+    }
+  } else if (policy === "ripple" && dependencyGraph) {
+    const ripplePackages = /* @__PURE__ */ new Set();
+    for (const pkg of affectedPackages) {
+      const pkgChanges = changesByPackage[pkg] || [];
+      const bump = computeBump(pkgChanges);
+      const reasonInfo = getImpactReason(pkgChanges);
+      const currentVersion = currentVersions[pkg] || "0.0.0";
+      const nextVersion = computeNextVersion(currentVersion, bump);
+      result[pkg] = {
+        nextVersion,
+        bump,
+        reason: reasonInfo.reason
+      };
+      const ripple = getRipplePackages(pkg, dependencyGraph);
+      for (const rpkg of ripple) {
+        ripplePackages.add(rpkg);
+      }
+    }
+    for (const pkg of ripplePackages) {
+      if (!result[pkg]) {
+        const currentVersion = currentVersions[pkg] || "0.0.0";
+        const nextVersion = computeNextVersion(currentVersion, "patch");
+        result[pkg] = {
+          nextVersion,
+          bump: "patch",
+          reason: "ripple",
+          rippleFrom: Array.from(affectedPackages)
+        };
+      }
+    }
+  } else if (policy === "lockstep") {
+    const allChanges = Object.values(changesByPackage).flat();
+    const bump = computeBump(allChanges);
+    const reasonInfo = getImpactReason(allChanges);
+    let highestVersion = "0.0.0";
+    for (const version of Object.values(currentVersions)) {
+      if (semver.gt(version, highestVersion)) {
+        highestVersion = version;
+      }
+    }
+    const nextVersion = computeNextVersion(highestVersion, bump);
+    for (const pkg of affectedPackages) {
+      result[pkg] = {
+        nextVersion,
+        bump,
+        reason: reasonInfo.reason
+      };
+    }
+  }
+  return result;
+}
+function getAffectedPackages(changes) {
+  const packages = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    for (const pkg of change.packages) {
+      packages.add(pkg);
+    }
+  }
+  return Array.from(packages);
+}
+async function detectProvider(cwd, baseUrl) {
+  if (baseUrl) {
+    return {
+      type: inferProviderType(baseUrl),
+      baseUrl
+    };
+  }
+  const git = simpleGit(cwd);
+  try {
+    const remotes = await git.getRemotes(true);
+    const url = remotes[0]?.refs?.fetch || remotes[0]?.refs?.push;
+    if (!url) {
+      return { type: "generic", baseUrl: null };
+    }
+    const parsed = parseGitUrl(url);
+    if (!parsed) {
+      return { type: "generic", baseUrl: null };
+    }
+    const providerUrl = `https://${parsed.host}/${parsed.owner}/${parsed.repo}`;
+    return {
+      type: inferProviderType(providerUrl),
+      baseUrl: providerUrl
+    };
+  } catch (error) {
+    return { type: "generic", baseUrl: null };
+  }
+}
+function inferProviderType(url) {
+  if (url.includes("github.com") || url.includes("githubusercontent.com")) {
+    return "github";
+  }
+  if (url.includes("gitlab.com") || url.includes("gitlab")) {
+    return "gitlab";
+  }
+  return "generic";
+}
+function formatCommitLink(provider, sha) {
+  if (!provider.baseUrl) {
+    return void 0;
+  }
+  if (provider.type === "github") {
+    return `${provider.baseUrl}/commit/${sha}`;
+  }
+  if (provider.type === "gitlab") {
+    return `${provider.baseUrl}/-/commit/${sha}`;
+  }
+  return void 0;
+}
+function formatPrLink(provider, prNumber) {
+  if (!provider.baseUrl) {
+    return void 0;
+  }
+  if (provider.type === "github") {
+    return `${provider.baseUrl}/pull/${prNumber}`;
+  }
+  if (provider.type === "gitlab") {
+    return `${provider.baseUrl}/-/merge_requests/${prNumber}`;
+  }
+  return void 0;
+}
+function formatIssueLink(provider, issueNumber) {
+  if (!provider.baseUrl) {
+    return void 0;
+  }
+  if (provider.type === "github") {
+    return `${provider.baseUrl}/issues/${issueNumber}`;
+  }
+  if (provider.type === "gitlab") {
+    return `${provider.baseUrl}/-/issues/${issueNumber}`;
+  }
+  return void 0;
+}
+function enhanceChangeWithLinks(change, provider) {
+  const providerLinks = {
+    commit: formatCommitLink(provider, change.sha),
+    pr: [],
+    issues: []
+  };
+  for (const ref of change.refs) {
+    if (ref.type === "pr") {
+      const link = formatPrLink(provider, ref.id);
+      if (link) {
+        providerLinks.pr.push(link);
+        ref.url = link;
+      }
+    } else if (ref.type === "issue") {
+      const link = formatIssueLink(provider, ref.id);
+      if (link) {
+        providerLinks.issues.push(link);
+        ref.url = link;
+      }
+    }
+  }
+  if (!providerLinks.pr.length) {
+    delete providerLinks.pr;
+  }
+  if (!providerLinks.issues.length) {
+    delete providerLinks.issues;
+  }
+  return {
+    ...change,
+    providerLinks
+  };
+}
+function formatAsJson(manifest, additionalContent) {
+  const integrity = {};
+  for (const [key, content] of Object.entries(additionalContent || {})) {
+    integrity[key] = calculateSha256(content);
+  }
+  const manifestWithIntegrity = {
+    ...manifest,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0
+  };
+  return JSON.stringify(manifestWithIntegrity, null, 2);
+}
+function createReleaseManifest(range, packages, timestamp) {
+  const byType = {};
+  let breakingCount = 0;
+  for (const pkg of packages) {
+    breakingCount += pkg.breaking.length;
+    for (const change of pkg.changes) {
+      byType[change.type] = (byType[change.type] || 0) + 1;
+    }
+  }
+  return {
+    schemaVersion: "1.0",
+    range,
+    timestamp: timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    packages,
+    workspace: {
+      breakingCount,
+      byType
+    }
+  };
+}
+function calculateSha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// src/formatters/markdown.ts
+function formatPackageAsMarkdown(pkg, level = "standard", locale = "en") {
+  const lines = [];
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  lines.push(`## [${pkg.next}] - ${date}`);
+  lines.push("");
+  const reasonLabel = formatReasonLabel(pkg.reason, locale);
+  lines.push(`> **${pkg.name}** ${pkg.prev} \u2192 ${pkg.next} (${reasonLabel})`);
+  lines.push("");
+  if (pkg.breaking && pkg.breaking.length > 0) {
+    lines.push("### " + t("breaking_changes", locale));
+    lines.push("");
+    for (const breaking of pkg.breaking) {
+      lines.push(`- **${breaking.summary}**`);
+      if (breaking.notes) {
+        lines.push(`  ${breaking.notes}`);
+      }
+    }
+    lines.push("");
+  }
+  const groupedChanges = groupChangesByType(pkg.changes);
+  for (const [type, changes] of Object.entries(groupedChanges)) {
+    if (changes.length === 0) {
+      continue;
+    }
+    const sectionTitle = formatSectionTitle(type, locale);
+    lines.push(`### ${sectionTitle}`);
+    lines.push("");
+    for (const change of changes) {
+      lines.push(formatChangeLine(change, level));
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function formatChangeLine(change, level) {
+  const bullet = "-";
+  let line = `${bullet} **${change.scope || "global"}**: ${change.subject}`;
+  if (level === "compact") {
+    return line;
+  }
+  const links = [];
+  if (change.providerLinks?.commit) {
+    links.push(`[${change.sha.substring(0, 7)}](${change.providerLinks.commit})`);
+  }
+  if (change.providerLinks?.pr && change.providerLinks.pr.length > 0) {
+    for (const prLink of change.providerLinks.pr) {
+      const match = prLink.match(/[^/]+$/);
+      links.push(`[${match && match[0] ? match[0] : "PR"}](${prLink})`);
+    }
+  }
+  if (links.length > 0) {
+    line += ` (${links.join(", ")})`;
+  }
+  if (level === "detailed") {
+    const details = [];
+    if (change.author) {
+      details.push(`@${change.author.name}`);
+    }
+    if (change.coAuthors && change.coAuthors.length > 0) {
+      details.push(...change.coAuthors.map((a) => `@${a.name}`));
+    }
+    if (change.filesChanged && change.filesChanged.length > 0) {
+      details.push(`${change.filesChanged.length} files`);
+    }
+    if (details.length > 0) {
+      line += ` \u2014 ${details.join(", ")}`;
+    }
+  }
+  return line;
+}
+function groupChangesByType(changes) {
+  const grouped = {};
+  for (const change of changes) {
+    const type = change.type;
+    if (!grouped[type]) {
+      grouped[type] = [];
+    }
+    grouped[type].push(change);
+  }
+  return grouped;
+}
+function formatSectionTitle(type, locale) {
+  const titles = {
+    feat: { en: "Features", ru: "\u041D\u043E\u0432\u044B\u0435 \u0432\u043E\u0437\u043C\u043E\u0436\u043D\u043E\u0441\u0442\u0438" },
+    fix: { en: "Bug Fixes", ru: "\u0418\u0441\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u044F" },
+    perf: { en: "Performance", ru: "\u041F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C" },
+    refactor: { en: "Refactoring", ru: "\u0420\u0435\u0444\u0430\u043A\u0442\u043E\u0440\u0438\u043D\u0433" },
+    docs: { en: "Documentation", ru: "\u0414\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u0430\u0446\u0438\u044F" },
+    build: { en: "Build", ru: "\u0421\u0431\u043E\u0440\u043A\u0430" },
+    ci: { en: "CI/CD", ru: "CI/CD" },
+    test: { en: "Tests", ru: "\u0422\u0435\u0441\u0442\u044B" },
+    chore: { en: "Chores", ru: "\u041E\u0431\u0441\u043B\u0443\u0436\u0438\u0432\u0430\u043D\u0438\u0435" },
+    revert: { en: "Reverts", ru: "\u041E\u0442\u043A\u0430\u0442\u044B" }
+  };
+  return titles[type]?.[locale] || type;
+}
+function formatReasonLabel(reason, locale) {
+  const labels = {
+    breaking: { en: "major \u2014 breaking changes", ru: "major \u2014 \u043A\u0440\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u0435 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F" },
+    feat: { en: "minor \u2014 new features", ru: "minor \u2014 \u043D\u043E\u0432\u0430\u044F \u0444\u0443\u043D\u043A\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E\u0441\u0442\u044C" },
+    fix: { en: "patch \u2014 bug fixes", ru: "patch \u2014 \u0438\u0441\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u044F" },
+    perf: { en: "patch \u2014 performance", ru: "patch \u2014 \u043F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C" },
+    ripple: { en: "patch \u2014 dependency update", ru: "patch \u2014 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439" },
+    manual: { en: "manual", ru: "\u0440\u0443\u0447\u043D\u043E\u0435" }
+  };
+  return labels[reason]?.[locale] ?? reason;
+}
+function t(key, locale) {
+  const translations = {
+    breaking_changes: { en: "BREAKING CHANGES", ru: "\u041A\u0420\u0418\u0422\u0418\u0427\u0415\u0421\u041A\u0418\u0415 \u0418\u0417\u041C\u0415\u041D\u0415\u041D\u0418\u042F" }
+  };
+  return translations[key]?.[locale] ?? key;
+}
+function formatLockstepChangelog(packages, version, locale = "en") {
+  const lines = [];
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  lines.push(`## [${version}] - ${date}`);
+  lines.push("");
+  const pkgCount = packages.length;
+  const pkgWord = locale === "ru" ? "\u043F\u0430\u043A\u0435\u0442\u043E\u0432" : pkgCount === 1 ? "package" : "packages";
+  lines.push(`**${pkgCount} ${pkgWord}** bumped to v${version}`);
+  lines.push("");
+  const changed = packages.filter((p) => p.bump !== "none");
+  if (changed.length > 0) {
+    const colPkg = locale === "ru" ? "\u041F\u0430\u043A\u0435\u0442" : "Package";
+    const colPrev = locale === "ru" ? "\u041F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0430\u044F" : "Previous";
+    const colBump = locale === "ru" ? "\u0422\u0438\u043F" : "Bump";
+    lines.push(`| ${colPkg} | ${colPrev} | ${colBump} |`);
+    lines.push(`|---------|----------|------|`);
+    for (const pkg of changed) {
+      lines.push(`| \`${pkg.name}\` | ${pkg.prev} | ${pkg.bump} |`);
+    }
+    lines.push("");
+  }
+  const allBreaking = deduplicateBySummary(
+    packages.flatMap((p) => (p.breaking || []).map((b) => ({ ...b, _pkg: p.name })))
+  );
+  if (allBreaking.length > 0) {
+    lines.push(`### ${t("breaking_changes", locale)}`);
+    lines.push("");
+    for (const b of allBreaking) {
+      lines.push(`- **${b.summary}**`);
+      if (b.notes) {
+        lines.push(`  ${b.notes}`);
+      }
+    }
+    lines.push("");
+  }
+  const seenShas = /* @__PURE__ */ new Set();
+  const allChanges = [];
+  for (const pkg of packages) {
+    for (const change of pkg.changes) {
+      if (seenShas.has(change.sha)) {
+        continue;
+      }
+      if (["chore", "build", "ci", "style", "test"].includes(change.type)) {
+        continue;
+      }
+      seenShas.add(change.sha);
+      allChanges.push({ change, packageName: pkg.name });
+    }
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of allChanges) {
+    const type = item.change.type;
+    if (!grouped.has(type)) {
+      grouped.set(type, []);
+    }
+    grouped.get(type).push(item);
+  }
+  const typeOrder = ["feat", "fix", "perf", "refactor", "docs", "revert"];
+  for (const type of typeOrder) {
+    const items = grouped.get(type);
+    if (!items || items.length === 0) {
+      continue;
+    }
+    lines.push(`### ${formatSectionTitle(type, locale)}`);
+    lines.push("");
+    for (const { change, packageName } of items) {
+      const scopePart = change.scope ? `**${change.scope}**` : "**global**";
+      const pkgHint = change.scope === packageName || allChanges.filter((i) => i.change.sha === change.sha).length === 1 ? "" : ` *(${packageName})*`;
+      lines.push(`- ${scopePart}: ${change.subject}${pkgHint}`);
+    }
+    lines.push("");
+  }
+  if (allChanges.length === 0) {
+    const noChanges = locale === "ru" ? "\u0411\u0435\u0437 \u0444\u0443\u043D\u043A\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u044B\u0445 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439." : "No functional changes.";
+    lines.push(`*${noChanges}*`);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function deduplicateBySummary(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (seen.has(item.summary)) {
+      return false;
+    }
+    seen.add(item.summary);
+    return true;
+  });
+}
+
+// src/formatters/llm-markdown.ts
+async function formatPackageWithLLM(platform, pkg, locale = "en") {
+  const llmAvailable = !!platform?.llm;
+  if (!llmAvailable) {
+    return formatPackageAsMarkdown(pkg, "standard", locale);
+  }
+  try {
+    const llm = platform.llm;
+    const substantialChanges = pkg.changes.filter(
+      (c) => !["chore", "build", "ci", "style", "test"].includes(c.type)
+    );
+    if (substantialChanges.length === 0) {
+      return "";
+    }
+    const grouped = groupByType(substantialChanges);
+    const changesContext = Object.entries(grouped).map(([type, changes]) => {
+      const items = changes.map((c) => `  - ${c.scope ? c.scope + ": " : ""}${c.subject}`).join("\n");
+      return `${type}:
+${items}`;
+    }).join("\n\n");
+    const prompt = buildCorporatePrompt(pkg, changesContext, locale);
+    const systemPrompt = locale === "ru" ? "\u0422\u044B \u0442\u0435\u0445\u043D\u0438\u0447\u0435\u0441\u043A\u0438\u0439 \u043F\u0438\u0441\u0430\u0442\u0435\u043B\u044C, \u0441\u043E\u0437\u0434\u0430\u044E\u0449\u0438\u0439 changelog \u0434\u043B\u044F \u043A\u0440\u0443\u043F\u043D\u043E\u0439 \u043A\u043E\u043C\u043F\u0430\u043D\u0438\u0438. \u041F\u0438\u0448\u0438 \u043F\u0440\u043E\u0444\u0435\u0441\u0441\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u043E, \u0441\u0442\u0440\u0443\u043A\u0442\u0443\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043E \u0438 \u043F\u043E\u043D\u044F\u0442\u043D\u043E." : "You are a technical writer creating changelogs for a major company. Write professionally, structured, and clearly.";
+    const response = await llm.complete(prompt, {
+      systemPrompt,
+      temperature: 0.7,
+      maxTokens: 1500
+    });
+    const formatted = formatLLMResponse(pkg, response.content, locale);
+    const validationResult = validateLLMChangelog(formatted, substantialChanges);
+    if (!validationResult.valid) {
+      console.warn(`LLM changelog validation failed: ${validationResult.errors.join(", ")}. Falling back to conventional format.`);
+      return formatPackageAsMarkdown(pkg, "standard", locale);
+    }
+    return formatted;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`LLM changelog failed, falling back to conventional: ${errorMessage}`);
+    return formatPackageAsMarkdown(pkg, "standard", locale);
+  }
+}
+function buildCorporatePrompt(pkg, changes, locale) {
+  const lang = locale === "ru" ? "Russian" : "English";
+  return `Generate a professional changelog entry for package "${pkg.name}" version ${pkg.prev} \u2192 ${pkg.next}.
+
+Changes made:
+${changes}
+
+Requirements:
+- Write in ${lang}
+- Professional corporate tone (like OpenAI, GitHub, Microsoft releases)
+- Start with a brief summary paragraph explaining WHAT changed and WHY it matters to users
+- Group changes by category (Features, Improvements, Bug Fixes, etc)
+- Focus on USER IMPACT, not technical details
+- Explain WHY changes matter, not just WHAT changed
+- Use clear, non-technical language when possible
+- Include emoji for readability: \u2728 Features, \u{1F41B} Fixes, \u26A1 Performance, \u{1F4DD} Documentation
+
+Format:
+## ${pkg.name} ${pkg.next}
+
+[1-2 sentence summary paragraph]
+
+### \u2728 New Features
+- Clear description of feature and why it's useful
+
+### \u{1F41B} Bug Fixes
+- What was fixed and how it helps users
+
+### \u26A1 Performance Improvements
+- What's faster and by how much
+
+DO NOT:
+- List commit SHAs or PR numbers
+- Use technical jargon unnecessarily
+- Mention internal refactoring unless user-facing
+- Include chore/build/ci changes
+
+Output ONLY the markdown changelog, no explanations.`;
+}
+function formatLLMResponse(pkg, llmContent, locale) {
+  let formatted = llmContent;
+  if (!formatted.includes(`## ${pkg.name}`)) {
+    const header = `## ${pkg.name} ${pkg.next}
+
+`;
+    formatted = header + formatted;
+  }
+  const footer = buildChangelogFooter(locale);
+  formatted = formatted.trimEnd() + "\n\n" + footer;
+  return formatted;
+}
+function buildChangelogFooter(locale) {
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  if (locale === "ru") {
+    return `---
+
+*\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043E \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u0441 \u043F\u043E\u043C\u043E\u0449\u044C\u044E [**@kb-labs/release-manager**](https://github.com/kb-labs/kb-labs)*
+*\u0427\u0430\u0441\u0442\u044C \u044D\u043A\u043E\u0441\u0438\u0441\u0442\u0435\u043C\u044B **KB Labs Platform** \u2014 \u043F\u0440\u043E\u0444\u0435\u0441\u0441\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u044B\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0434\u043B\u044F \u0440\u0430\u0437\u0440\u0430\u0431\u043E\u0442\u043A\u0438*
+
+<sub>\xA9 ${year} KB Labs. Released under KB Public License v1.1</sub>`;
+  }
+  return `---
+
+*Generated automatically by [**@kb-labs/release-manager**](https://github.com/kb-labs/kb-labs)*
+*Part of the **KB Labs Platform** \u2014 Professional developer tools ecosystem*
+
+<sub>\xA9 ${year} KB Labs. Released under KB Public License v1.1</sub>`;
+}
+function groupByType(changes) {
+  const grouped = {};
+  for (const change of changes) {
+    if (!grouped[change.type]) {
+      grouped[change.type] = [];
+    }
+    grouped[change.type].push(change);
+  }
+  return grouped;
+}
+function validateLLMChangelog(llmOutput, sourceChanges) {
+  const errors = [];
+  if (!llmOutput || llmOutput.trim().length === 0) {
+    errors.push("Empty output");
+    return { valid: false, errors };
+  }
+  if (!llmOutput.includes("#")) {
+    errors.push("No markdown headers found");
+  }
+  new Set(sourceChanges.map((c) => c.subject.toLowerCase().trim()));
+  new Set(sourceChanges.map((c) => c.scope?.toLowerCase().trim()).filter(Boolean));
+  const shaPattern = /\b[0-9a-f]{7,40}\b/gi;
+  const mentionedShas = llmOutput.match(shaPattern) || [];
+  const sourceShas = new Set(sourceChanges.map((c) => c.sha.toLowerCase()));
+  for (const sha of mentionedShas) {
+    const lowerSha = sha.toLowerCase();
+    const isValid = Array.from(sourceShas).some((sourceSha) => sourceSha.startsWith(lowerSha));
+    if (!isValid) {
+      errors.push(`Hallucinated SHA: ${sha}`);
+    }
+  }
+  const prPattern = /#(\d+)/g;
+  const mentionedPRs = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = prPattern.exec(llmOutput)) !== null) {
+    mentionedPRs.add(match[1]);
+  }
+  const sourceRefs = new Set(sourceChanges.flatMap((c) => c.refs.map((r) => r.id)));
+  for (const pr of mentionedPRs) {
+    if (!sourceRefs.has(pr)) {
+      errors.push(`Hallucinated PR/issue: #${pr}`);
+    }
+  }
+  const lineCount = llmOutput.split("\n").length;
+  if (lineCount < 3) {
+    errors.push("Output too short (< 3 lines)");
+  }
+  if (lineCount > 200) {
+    errors.push("Output too verbose (> 200 lines)");
+  }
+  const forbiddenPatterns = [
+    /\[REDACTED\]/i,
+    /\[PLACEHOLDER\]/i,
+    /\[TODO\]/i,
+    /\[EXAMPLE\]/i
+  ];
+  for (const pattern of forbiddenPatterns) {
+    if (pattern.test(llmOutput)) {
+      errors.push(`Forbidden pattern found: ${pattern.source}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/templates/types.ts
+function groupChangesByType2(changes) {
+  const grouped = {};
+  for (const change of changes) {
+    const type = change.type;
+    if (!grouped[type]) {
+      grouped[type] = [];
+    }
+    grouped[type].push(change);
+  }
+  return grouped;
+}
+function packageToTemplateData(pkg, locale = "en", metadata) {
+  return {
+    package: {
+      name: pkg.name,
+      prev: pkg.prev,
+      next: pkg.next,
+      bump: pkg.bump,
+      reason: pkg.reason,
+      rippleFrom: pkg.rippleFrom
+    },
+    breaking: pkg.breaking,
+    changes: groupChangesByType2(pkg.changes),
+    locale,
+    metadata
+  };
+}
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+var BUILTIN_TEMPLATES = ["corporate", "corporate-ai", "technical", "compact"];
+async function loadTemplate(templateName, cwd) {
+  if (isBuiltinTemplate(templateName)) {
+    return loadBuiltinTemplate(templateName);
+  }
+  return loadCustomTemplate(templateName, cwd);
+}
+function isBuiltinTemplate(name) {
+  return BUILTIN_TEMPLATES.includes(name);
+}
+async function loadBuiltinTemplate(name) {
+  try {
+    const templatePath = join(__dirname$1, "templates", "builtin", `${name}.js`);
+    const templateUrl = pathToFileURL(templatePath).href;
+    const module = await import(templateUrl);
+    return validateTemplate(module, name);
+  } catch (error) {
+    throw new Error(
+      `Failed to load built-in template "${name}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadCustomTemplate(templatePath, cwd) {
+  const fullPath = isAbsolute(templatePath) ? templatePath : join(cwd, templatePath);
+  try {
+    await access(fullPath);
+  } catch {
+    throw new Error(`Template file not found: ${fullPath}`);
+  }
+  try {
+    const fileUrl = pathToFileURL(fullPath).href;
+    const module = await import(fileUrl);
+    return validateTemplate(module, templatePath);
+  } catch (error) {
+    throw new Error(
+      `Failed to load custom template "${templatePath}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateTemplate(module, templateName) {
+  if (!module.version || module.version !== "1.0") {
+    throw new Error(
+      `Template "${templateName}" has invalid version (expected "1.0", got "${module.version || "undefined"}")`
+    );
+  }
+  if (typeof module.render !== "function") {
+    throw new Error(`Template "${templateName}" must export a render() function`);
+  }
+  return module;
+}
+function listBuiltinTemplates() {
+  return [
+    {
+      name: "corporate",
+      description: "Professional changelog with emoji and grouped sections (sync, fast)"
+    },
+    {
+      name: "corporate-ai",
+      description: "Corporate format with AI-enhanced descriptions (async, smart)"
+    },
+    {
+      name: "technical",
+      description: "Developer-focused with commit SHAs, authors, and all commit types"
+    },
+    {
+      name: "compact",
+      description: "Minimal one-line format for quick release notes"
+    }
+  ];
+}
+
+// src/changelog-generator.ts
+async function generateChangelog(options) {
+  const {
+    repoRoot,
+    gitCwd = repoRoot,
+    packages,
+    range: rangeOptions,
+    changelog: changelogConfig,
+    git: gitConfig,
+    platform,
+    onProgress
+  } = options;
+  const locale = changelogConfig?.locale || "en";
+  onProgress?.("Resolving git range...");
+  const range = await resolveGitRange({
+    cwd: gitCwd,
+    from: rangeOptions?.from,
+    to: rangeOptions?.to || "HEAD",
+    sinceTag: rangeOptions?.sinceTag,
+    autoUnshallow: gitConfig?.autoUnshallow,
+    requireSignedTags: gitConfig?.requireSignedTags
+  });
+  onProgress?.("Detecting git provider...");
+  const provider = await detectProvider(gitCwd, gitConfig?.baseUrl);
+  onProgress?.("Parsing commits...");
+  const changes = await parseCommits({
+    cwd: gitCwd,
+    from: range.from,
+    to: range.to,
+    ignoreAuthors: changelogConfig?.ignoreAuthors || [],
+    includeTypes: changelogConfig?.includeTypes,
+    excludeTypes: changelogConfig?.excludeTypes,
+    collapseMerges: changelogConfig?.collapseMerges,
+    collapseReverts: changelogConfig?.collapseReverts,
+    preferMergeSummary: changelogConfig?.preferMergeSummary
+  });
+  onProgress?.("Enhancing changes with links...");
+  const enhancedChanges = changes.map((change) => enhanceChangeWithLinks(change, provider));
+  onProgress?.("Building package releases...");
+  function normalizePkgPath(pkgPath) {
+    let rel;
+    if (pkgPath.startsWith(gitCwd)) {
+      rel = pkgPath.slice(gitCwd.length).replace(/^\/+/, "");
+    } else if (pkgPath.startsWith(repoRoot)) {
+      rel = pkgPath.slice(repoRoot.length).replace(/^\/+/, "");
+    } else {
+      rel = pkgPath.replace(/^\/+/, "");
+    }
+    return rel.endsWith("/") ? rel : rel + "/";
+  }
+  const packageReleases = packages.map((pkg) => {
+    const pkgPrefix = normalizePkgPath(pkg.path);
+    const isRoot = pkgPrefix === "/" || pkgPrefix === "" || pkgPrefix === "./";
+    const pkgChanges = isRoot ? enhancedChanges : enhancedChanges.filter(
+      (c) => !c.filesChanged || c.filesChanged.length === 0 ? true : c.filesChanged.some((f) => f.startsWith(pkgPrefix))
+    );
+    const hasBreaking = pkgChanges.some((c) => c.breaking && c.breaking.length > 0);
+    const hasFeat = pkgChanges.some((c) => c.type === "feat");
+    const hasFix = pkgChanges.some((c) => c.type === "fix");
+    const hasPerf = pkgChanges.some((c) => c.type === "perf");
+    let reason = "manual";
+    if (hasBreaking) {
+      reason = "breaking";
+    } else if (hasFeat) {
+      reason = "feat";
+    } else if (hasFix) {
+      reason = "fix";
+    } else if (hasPerf) {
+      reason = "perf";
+    }
+    return {
+      name: pkg.name,
+      prev: pkg.currentVersion,
+      next: pkg.nextVersion,
+      bump: pkg.bump,
+      reason,
+      breaking: pkgChanges.filter((c) => c.breaking && c.breaking.length > 0).flatMap((c) => c.breaking),
+      changes: pkgChanges
+    };
+  });
+  const manifest = createReleaseManifest(range, packageReleases);
+  const uniqueNextVersions = new Set(packageReleases.map((p) => p.next));
+  const isLockstep = packageReleases.length > 1 && uniqueNextVersions.size === 1;
+  let markdown;
+  const templateName = changelogConfig?.template || "corporate-ai";
+  onProgress?.(`Loading template "${templateName}"...`);
+  const template = await loadTemplate(templateName, repoRoot);
+  if (isLockstep) {
+    onProgress?.("Formatting consolidated lockstep changelog...");
+    const sharedVersion = packageReleases[0].next;
+    const sharedPrev = packageReleases[0].prev;
+    const mergedChanges = enhancedChanges;
+    const seenBreaking = /* @__PURE__ */ new Set();
+    const mergedBreaking = enhancedChanges.filter((c) => c.breaking && c.breaking.length > 0).flatMap((c) => c.breaking).filter((b) => {
+      if (seenBreaking.has(b.summary)) {
+        return false;
+      }
+      seenBreaking.add(b.summary);
+      return true;
+    });
+    const hasBreaking = mergedBreaking.length > 0;
+    const hasFeat = mergedChanges.some((c) => c.type === "feat");
+    const hasFix = mergedChanges.some((c) => c.type === "fix");
+    const hasPerf = mergedChanges.some((c) => c.type === "perf");
+    let reason = "manual";
+    if (hasBreaking) {
+      reason = "breaking";
+    } else if (hasFeat) {
+      reason = "feat";
+    } else if (hasFix) {
+      reason = "fix";
+    } else if (hasPerf) {
+      reason = "perf";
+    }
+    const scopeName = packages.length > 0 ? packages[0].name.replace(/\/[^/]+$/, "") : "monorepo";
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const pkgWord = locale === "ru" ? "\u043F\u0430\u043A\u0435\u0442\u043E\u0432" : packages.length === 1 ? "package" : "packages";
+    const headerLines = [
+      `## [${sharedVersion}] - ${date}`,
+      "",
+      `**${packageReleases.length} ${pkgWord}** bumped to v${sharedVersion}`,
+      "",
+      `| ${locale === "ru" ? "\u041F\u0430\u043A\u0435\u0442" : "Package"} | ${locale === "ru" ? "\u041F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0430\u044F" : "Previous"} | ${locale === "ru" ? "\u0422\u0438\u043F" : "Bump"} |`,
+      `|---------|----------|------|`,
+      ...packageReleases.filter((p) => p.bump !== "none").map((p) => `| \`${p.name}\` | ${p.prev} | ${p.bump} |`),
+      ""
+    ];
+    const mergedRelease = {
+      name: scopeName,
+      prev: sharedPrev,
+      next: sharedVersion,
+      bump: packageReleases[0].bump,
+      reason,
+      breaking: mergedBreaking,
+      changes: mergedChanges
+    };
+    onProgress?.("Enhancing lockstep changelog with template...");
+    const templateData = packageToTemplateData(mergedRelease, locale, changelogConfig?.metadata);
+    const result = template.render(templateData, platform);
+    const rendered = typeof result === "string" ? result : await result;
+    const renderedLines = rendered.split("\n");
+    let contentStartIdx = 0;
+    for (let i = 0; i < renderedLines.length; i++) {
+      const line = renderedLines[i];
+      if (line.startsWith("## [") || line.startsWith("> **") || line.trim() === "") {
+        contentStartIdx = i + 1;
+      } else {
+        break;
+      }
+    }
+    const contentBody = renderedLines.slice(contentStartIdx).join("\n").trim();
+    markdown = headerLines.join("\n") + (contentBody ? "\n" + contentBody : `
+*${locale === "ru" ? "\u0411\u0435\u0437 \u0444\u0443\u043D\u043A\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u044B\u0445 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439." : "No functional changes."}*`);
+  } else {
+    const formattedPackages = [];
+    for (let i = 0; i < packageReleases.length; i++) {
+      const pkg = packageReleases[i];
+      if (!pkg) {
+        continue;
+      }
+      onProgress?.(`Formatting changelog for ${pkg.name} (${i + 1}/${packageReleases.length})...`);
+      const templateData = packageToTemplateData(pkg, locale, changelogConfig?.metadata);
+      const result = template.render(templateData, platform);
+      const formatted = typeof result === "string" ? result : await result;
+      formattedPackages.push(formatted);
+    }
+    markdown = formattedPackages.join("\n\n");
+  }
+  return {
+    markdown,
+    manifest: JSON.parse(formatAsJson(manifest)),
+    changes: enhancedChanges,
+    range,
+    packages: packageReleases
+  };
+}
+function generateSimpleChangelog(packages, locale = "en") {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const uniqueVersions = new Set(packages.map((p) => p.nextVersion));
+  const isLockstep = packages.length > 1 && uniqueVersions.size === 1;
+  if (isLockstep) {
+    const version = packages[0].nextVersion;
+    const pkgWord = locale === "ru" ? "\u043F\u0430\u043A\u0435\u0442\u043E\u0432" : packages.length === 1 ? "package" : "packages";
+    const lines2 = [
+      `## [${version}] - ${date}`,
+      "",
+      `**${packages.length} ${pkgWord}** bumped to v${version}`,
+      "",
+      `| Package | Previous | Bump |`,
+      `|---------|----------|------|`,
+      ...packages.map((p) => `| \`${p.name}\` | ${p.currentVersion} | ${p.bump} |`)
+    ];
+    return lines2.join("\n");
+  }
+  const title = locale === "ru" ? "\u0420\u0435\u043B\u0438\u0437" : "Release";
+  const lines = [`## [${date}] ${title}
+
+`];
+  for (const pkg of packages) {
+    lines.push(`- **${pkg.name}**: ${pkg.currentVersion} \u2192 ${pkg.nextVersion}`);
+  }
+  return lines.join("\n");
+}
+
+export { BUILTIN_TEMPLATES, acquireLock, applyVersionPolicy, computeBump, computeNextVersion, createReleaseManifest, detectProvider, enhanceChangeWithLinks, findLastTag, findPackageTag, formatAsJson, formatCommitLink, formatIssueLink, formatLockstepChangelog, formatPackageAsMarkdown, formatPackageWithLLM, formatPrLink, generateChangelog, generateSimpleChangelog, getAffectedPackages, getCachedChange, getImpactReason, getLastTag, getRipplePackages, groupChangesByType2 as groupChangesByType, isCacheValid, listBuiltinTemplates, loadCache, loadTemplate, packageToTemplateData, parseCommits, parseGitUrl, resolveGitRange, saveCache, saveGraphSnapshot, updateCache, updateHead, updateLastTag };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map