@gpc-cli/core 0.9.50 → 0.9.52

package/dist/index.js

@@ -3723,10 +3723,10 @@ ${bullets}`);
   }
   return { text, truncated };
 }
-async function gitExec(args) {
+async function gitExec(args, opts) {
   try {
-    const { stdout } = await execFile("git", args);
-    return stdout.trim();
+    const result = opts?.cwd ? await execFile("git", args, { encoding: "utf8", cwd: opts.cwd }) : await execFile("git", args);
+    return result.stdout.trim();
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") {
@@ -7361,6 +7361,753 @@ function formatChangelogEntry(entry) {
   return lines.join("\n");
 }
 
+// src/commands/changelog-generate.ts
+var KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "feat",
+  "fix",
+  "perf",
+  "breaking",
+  "docs",
+  "ci",
+  "chore",
+  "refactor",
+  "test",
+  "build",
+  "style",
+  "release"
+]);
+var FILTERED_TYPES = /* @__PURE__ */ new Set(["chore", "refactor", "test", "build", "style", "merge"]);
+var SECTION_ORDER = ["breaking", "feat", "fix", "perf", "docs", "ci", "release", "other"];
+var FIXUP_PATTERNS = [
+  /^wip\b/i,
+  /^fix\s+typo\b/i,
+  /^fix\s+typos\b/i,
+  /^address\s+review\b/i,
+  /^review\s+fixes\b/i,
+  /^fixup!/i,
+  /^squash!/i
+];
+var REVERT_PATTERN = /^Revert\s+"(.+?)"\s*$/i;
+var VERB_CANONICALIZATIONS = [
+  [/^Added\b/, "add"],
+  [/^Adds\b/, "add"],
+  [/^Add\b/, "add"],
+  [/^Fixed\b/, "fix"],
+  [/^Fixes\b/, "fix"],
+  [/^Fix\b/, "fix"],
+  [/^Updated\b/, "update"],
+  [/^Updates\b/, "update"],
+  [/^Update\b/, "update"],
+  [/^Removed\b/, "remove"],
+  [/^Removes\b/, "remove"],
+  [/^Remove\b/, "remove"]
+];
+var EMOJI_PREFIX = /^(?:[\p{Emoji_Presentation}\p{Extended_Pictographic}]\s*)+/u;
+var INTERNAL_JARGON = [
+  "mutex",
+  "token bucket",
+  "barrel export",
+  "barrel exports",
+  "homedir",
+  "at module level",
+  "ESM",
+  "tsup",
+  "vi.stubGlobal",
+  "execFile",
+  "lazy-import"
+];
+var RECORD_START = "";
+var FIELD_SEP = "";
+var COMMIT_FORMAT = `${RECORD_START}%H${FIELD_SEP}%s${FIELD_SEP}%aI${FIELD_SEP}%b`;
+function parseRawCommits(stdout) {
+  if (!stdout.trim()) return [];
+  const blocks = stdout.split(RECORD_START).filter((b) => b.trim());
+  const commits = [];
+  for (const block of blocks) {
+    const headerEnd = block.indexOf("\n");
+    const header = headerEnd === -1 ? block : block.slice(0, headerEnd);
+    const rest = headerEnd === -1 ? "" : block.slice(headerEnd + 1);
+    const parts = header.split(FIELD_SEP);
+    const sha = parts[0]?.trim() ?? "";
+    const subject = parts[1]?.trim() ?? "";
+    const authorDate = parts[2]?.trim() ?? "";
+    const body = (parts[3] ?? "").trim();
+    if (!sha) continue;
+    const files = [];
+    let additions = 0;
+    let deletions = 0;
+    for (const line of rest.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const match = trimmed.match(/^(\d+|-)\s+(\d+|-)\s+(.+)$/);
+      if (match) {
+        const a = match[1] === "-" ? 0 : Number(match[1]);
+        const d = match[2] === "-" ? 0 : Number(match[2]);
+        additions += a;
+        deletions += d;
+        files.push(match[3] ?? "");
+      }
+    }
+    commits.push({ sha, subject, body, files, additions, deletions, authorDate });
+  }
+  return commits;
+}
+var defaultGitRunner = {
+  async log({ from, to, cwd }) {
+    const stdout = await gitExec(
+      [
+        "log",
+        "--no-merges",
+        `--format=${COMMIT_FORMAT}`,
+        "--numstat",
+        "--end-of-options",
+        `${from}..${to}`
+      ],
+      { cwd }
+    );
+    return parseRawCommits(stdout);
+  },
+  async describeLatestTag(cwd) {
+    try {
+      const out = await gitExec(["describe", "--tags", "--match", "v*", "--abbrev=0"], { cwd });
+      return out.trim() || null;
+    } catch {
+      return null;
+    }
+  },
+  async verifyRef(ref, cwd) {
+    try {
+      await gitExec(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], { cwd });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async remoteUrl(cwd) {
+    try {
+      const out = await gitExec(["remote", "get-url", "origin"], { cwd });
+      return out.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+};
+function parseRemoteUrl(url) {
+  if (!url) return null;
+  const https = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?\/?$/i);
+  if (https) return `${https[1]}/${https[2]}`;
+  const ssh = url.match(/^git@github\.com:([^/]+)\/([^/.]+?)(?:\.git)?$/i);
+  if (ssh) return `${ssh[1]}/${ssh[2]}`;
+  return null;
+}
+function stripEmojiAndCanonicalize(subject) {
+  let s = subject.replace(EMOJI_PREFIX, "");
+  for (const [pattern, replacement] of VERB_CANONICALIZATIONS) {
+    if (pattern.test(s)) {
+      s = s.replace(pattern, replacement);
+      break;
+    }
+  }
+  return s.trim();
+}
+function isFixupSubject(subject) {
+  return FIXUP_PATTERNS.some((p) => p.test(subject));
+}
+var CONVENTIONAL_RE = /^(?<type>\w+)(?:\((?<scope>[^)]+)\))?(?<bang>!?):\s*(?<rest>.+)$/;
+var PR_REF_RE = /\s*\(#(\d+)\)\s*$/;
+function parseCommit(raw) {
+  const subject = raw.subject;
+  const revertMatch = subject.match(REVERT_PATTERN);
+  const isRevert = !!revertMatch;
+  const effectiveSubject = revertMatch?.[1] ?? subject;
+  const match = effectiveSubject.match(CONVENTIONAL_RE);
+  let type = "other";
+  let scope;
+  let rest = effectiveSubject;
+  if (match?.groups) {
+    const rawType = match.groups["type"]?.toLowerCase() ?? "other";
+    type = KNOWN_TYPES.has(rawType) ? rawType : "other";
+    scope = match.groups["scope"];
+    rest = match.groups["rest"] ?? effectiveSubject;
+    if (match.groups["bang"]) type = "breaking";
+  }
+  let prRef;
+  const prMatch = rest.match(PR_REF_RE);
+  if (prMatch) {
+    prRef = `#${prMatch[1]}`;
+    rest = rest.replace(PR_REF_RE, "").trim();
+  }
+  const cleaned = stripEmojiAndCanonicalize(rest);
+  const finalSubject = prRef ? `${cleaned} (${prRef})` : cleaned;
+  return {
+    sha: raw.sha,
+    type,
+    scope,
+    subject: finalSubject,
+    prRef,
+    files: raw.files,
+    weight: raw.additions + raw.deletions,
+    isRevert,
+    isFixup: isFixupSubject(rest) || isFixupSubject(subject),
+    authorDate: raw.authorDate
+  };
+}
+function dedupRevertPairs(commits) {
+  const reverted = /* @__PURE__ */ new Set();
+  for (const c of commits) {
+    if (c.isRevert) reverted.add(c.subject);
+  }
+  return commits.filter((c) => {
+    if (c.isRevert) return false;
+    if (reverted.has(c.subject)) return false;
+    return true;
+  });
+}
+function topPathPrefix(file, depth = 2) {
+  return file.split("/").slice(0, depth).join("/");
+}
+function tokenize2(subject) {
+  const STOP = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "and",
+    "or",
+    "of",
+    "to",
+    "in",
+    "on",
+    "for",
+    "with",
+    "is",
+    "be",
+    "by",
+    "at"
+  ]);
+  return new Set(
+    subject.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP.has(w))
+  );
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+function shouldCluster(a, b, ta, tb) {
+  const aPrefixes = new Set(a.files.map((f) => topPathPrefix(f)));
+  for (const f of b.files) {
+    if (aPrefixes.has(topPathPrefix(f))) return true;
+  }
+  if (jaccard(ta, tb) > 0.4) return true;
+  const aDate = Date.parse(a.authorDate);
+  const bDate = Date.parse(b.authorDate);
+  if (!Number.isNaN(aDate) && !Number.isNaN(bDate)) {
+    const dayDiff = Math.abs(aDate - bDate) / 864e5;
+    if (dayDiff <= 2) {
+      const aFiles = new Set(a.files);
+      for (const f of b.files) if (aFiles.has(f)) return true;
+    }
+  }
+  return false;
+}
+var TYPE_PRIORITY = {
+  breaking: 0,
+  feat: 1,
+  fix: 2,
+  perf: 3,
+  docs: 4,
+  ci: 5,
+  release: 6,
+  other: 7
+};
+function clusterCommits(commits) {
+  const n = commits.length;
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const union = (i, j) => {
+    const ri = find(i);
+    const rj = find(j);
+    if (ri !== rj) parent[ri] = rj;
+  };
+  const tokens = commits.map((c) => tokenize2(c.subject));
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (shouldCluster(commits[i], commits[j], tokens[i], tokens[j])) union(i, j);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const root = find(i);
+    if (!groups.has(root)) groups.set(root, []);
+    groups.get(root).push(commits[i]);
+  }
+  const clusters = [];
+  for (const [, members] of groups) {
+    const weight = members.reduce((s, m) => s + m.weight, 0);
+    const primaryType = members.map((m) => m.type).sort((a, b) => (TYPE_PRIORITY[a] ?? 99) - (TYPE_PRIORITY[b] ?? 99))[0];
+    const label = clusterLabel(members);
+    clusters.push({
+      id: label.toLowerCase().replace(/\s+/g, "-"),
+      label,
+      commits: members,
+      weight,
+      primaryType
+    });
+  }
+  return clusters;
+}
+function clusterLabel(members) {
+  const pathCounts = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    for (const f of m.files) {
+      const top = topPathPrefix(f, 2);
+      pathCounts.set(top, (pathCounts.get(top) ?? 0) + 1);
+    }
+  }
+  let bestPath = null;
+  let bestPathCount = 0;
+  for (const [p, c] of pathCounts) {
+    if (c > bestPathCount) {
+      bestPath = p;
+      bestPathCount = c;
+    }
+  }
+  if (bestPath) return bestPath;
+  const tokenCounts = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    for (const t of tokenize2(m.subject)) {
+      tokenCounts.set(t, (tokenCounts.get(t) ?? 0) + 1);
+    }
+  }
+  let bestToken = null;
+  let bestTokenCount = 0;
+  for (const [t, c] of tokenCounts) {
+    if (c > bestTokenCount) {
+      bestToken = t;
+      bestTokenCount = c;
+    }
+  }
+  return bestToken ?? members[0].subject.slice(0, 30);
+}
+function scoreHeadlines(clusters) {
+  return [...clusters].sort((a, b) => {
+    if (b.weight !== a.weight) return b.weight - a.weight;
+    return (TYPE_PRIORITY[a.primaryType] ?? 99) - (TYPE_PRIORITY[b.primaryType] ?? 99);
+  }).slice(0, 3);
+}
+function lintJargon(commits) {
+  const warnings = [];
+  for (const c of commits) {
+    const lower = c.subject.toLowerCase();
+    for (const word of INTERNAL_JARGON) {
+      if (lower.includes(word.toLowerCase())) {
+        warnings.push(`jargon: "${word}" in subject "${c.subject}" (${c.sha.slice(0, 7)})`);
+      }
+    }
+  }
+  return warnings;
+}
+async function generateChangelog(opts = {}, runner = defaultGitRunner) {
+  const cwd = opts.cwd ?? process.cwd();
+  let from = opts.from;
+  if (!from) {
+    from = await runner.describeLatestTag(cwd) ?? void 0;
+    if (!from) {
+      throw new GpcError(
+        "No git tags found and --from was not provided",
+        "CHANGELOG_NO_TAG",
+        1,
+        "Pass --from <ref> explicitly, or create an initial tag (e.g., git tag v0.0.1)."
+      );
+    }
+  }
+  const to = opts.to ?? "HEAD";
+  if (!await runner.verifyRef(from, cwd)) {
+    throw new GpcError(
+      `Invalid --from ref: "${from}"`,
+      "CHANGELOG_BAD_REF",
+      1,
+      "Verify the ref exists with: git rev-parse --verify <ref>"
+    );
+  }
+  if (!await runner.verifyRef(to, cwd)) {
+    throw new GpcError(
+      `Invalid --to ref: "${to}"`,
+      "CHANGELOG_BAD_REF",
+      1,
+      "Verify the ref exists with: git rev-parse --verify <ref>"
+    );
+  }
+  const repo = opts.repo ?? parseRemoteUrl(await runner.remoteUrl(cwd));
+  const raw = await runner.log({ from, to, cwd });
+  const rawCommitCount = raw.length;
+  const parsed = raw.map(parseCommit);
+  const warnings = [];
+  const scopeLeak = parsed.find((c) => c.scope);
+  if (scopeLeak) {
+    warnings.push(
+      `scope: dropped per project convention (e.g., "${scopeLeak.scope}" in ${scopeLeak.sha.slice(0, 7)})`
+    );
+  }
+  const afterRevert = dedupRevertPairs(parsed);
+  const nonFixup = afterRevert.filter((c) => !c.isFixup);
+  const visible = nonFixup.filter((c) => !FILTERED_TYPES.has(c.type));
+  const clusters = clusterCommits(visible);
+  const headlineCandidates = scoreHeadlines(clusters);
+  const grouped = {};
+  for (const c of visible) {
+    if (!grouped[c.type]) grouped[c.type] = [];
+    grouped[c.type].push(c);
+  }
+  warnings.push(...lintJargon(visible));
+  return {
+    from,
+    to,
+    repo,
+    rawCommitCount,
+    commits: parsed,
+    clusters,
+    grouped,
+    headlineCandidates,
+    warnings
+  };
+}
+
+// src/commands/changelog-renderers/markdown.ts
+function safeSubject(s) {
+  return s.replace(/[\r\n]+/g, " ").trim();
+}
+function renderMarkdown(g) {
+  if (g.commits.length === 0) {
+    const compare2 = g.repo ? `
+**Full Changelog**: https://github.com/${g.repo}/compare/${g.from}...${g.to}` : "";
+    return `## What's Changed
+
+_No notable changes._
+${compare2}`.trim();
+  }
+  const lines = ["## What's Changed", ""];
+  let emittedAny = false;
+  for (const type of SECTION_ORDER) {
+    const commits = g.grouped[type] ?? [];
+    if (commits.length === 0) continue;
+    for (const commit of commits) {
+      lines.push(`- ${type}: ${safeSubject(commit.subject)}`);
+      emittedAny = true;
+    }
+  }
+  if (!emittedAny) {
+    lines.push("_No notable changes._");
+  }
+  if (g.repo) {
+    lines.push("");
+    lines.push(`**Full Changelog**: https://github.com/${g.repo}/compare/${g.from}...${g.to}`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/changelog-renderers/json.ts
+function renderJson(g) {
+  return JSON.stringify(g, null, 2);
+}
+
+// src/commands/changelog-renderers/prompt.ts
+function safeLine(s) {
+  return s.replace(/[\r\n]+/g, " ").trim();
+}
+function renderPrompt(g) {
+  const lines = [];
+  lines.push("You are writing a draft of GitHub Release notes from clustered git commits.");
+  lines.push("");
+  lines.push("VOICE RULES (from project conventions):");
+  lines.push("- Terse, present tense, user-facing language");
+  lines.push('- No internal jargon (no "mutex", "token bucket", "barrel exports", "homedir")');
+  lines.push("- One bullet per feature/fix, not one per commit");
+  lines.push("- Drop conventional-commit scopes (e.g., feat(cli) \u2192 feat:)");
+  lines.push("- Open with a single-sentence highlight describing the release theme");
+  lines.push("");
+  lines.push(`RANGE: ${g.from}..${g.to}`);
+  if (g.repo) lines.push(`REPO:  ${g.repo}`);
+  lines.push(`COMMITS: ${g.rawCommitCount} raw, ${g.clusters.length} clusters after dedup`);
+  lines.push("");
+  if (g.headlineCandidates.length > 0) {
+    lines.push("HEADLINE CANDIDATES (largest first):");
+    for (const c of g.headlineCandidates) {
+      lines.push(`  ${c.label} (weight ${c.weight}, ${c.commits.length} commits, primary ${c.primaryType})`);
+    }
+    lines.push("");
+  }
+  lines.push("CLUSTERED COMMITS:");
+  lines.push("");
+  for (const cluster of g.clusters) {
+    lines.push(`[cluster: ${cluster.label}, weight ${cluster.weight}, ${cluster.commits.length} commits, primary ${cluster.primaryType}]`);
+    for (const commit of cluster.commits) {
+      lines.push(`- ${commit.type}: ${safeLine(commit.subject)} (${commit.sha.slice(0, 7)})`);
+      if (commit.files.length > 0) {
+        const fileSummary = commit.files.slice(0, 3).join(", ");
+        const more = commit.files.length > 3 ? ` (+${commit.files.length - 3} more)` : "";
+        lines.push(`  files: ${fileSummary}${more}`);
+      }
+    }
+    lines.push("");
+  }
+  if (g.warnings.length > 0) {
+    lines.push("LINTER WARNINGS (review before publishing):");
+    for (const w of g.warnings) lines.push(`  - ${w}`);
+    lines.push("");
+  }
+  const compare2 = g.repo ? `https://github.com/${g.repo}/compare/${g.from}...${g.to}` : `${g.from}..${g.to}`;
+  lines.push("OUTPUT FORMAT (match exactly):");
+  lines.push("```markdown");
+  lines.push("<one-sentence highlight>");
+  lines.push("");
+  lines.push("## What's Changed");
+  lines.push("");
+  lines.push("- breaking: ...");
+  lines.push("- feat: ...");
+  lines.push("- fix: ...");
+  lines.push("- perf: ...");
+  lines.push("");
+  lines.push(`**Full Changelog**: ${compare2}`);
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/commands/changelog-renderers/play-store.ts
+var PLAY_STORE_LIMIT = 500;
+var PLACEHOLDER_TEXT = "[needs translation \u2014 pass --ai once v0.9.63 ships, or paste the prompt emitted by --format prompt]";
+function safeLine2(s) {
+  return s.replace(/[\r\n]+/g, " ").trim();
+}
+function countChars(s) {
+  return [...s].length;
+}
+function truncateToLimit(text, limit) {
+  if (countChars(text) <= limit) return text;
+  const chars = [...text];
+  return chars.slice(0, limit - 1).join("") + "\u2026";
+}
+function renderEnglishBullets(g) {
+  const lines = [];
+  for (const type of SECTION_ORDER) {
+    const commits = g.grouped[type] ?? [];
+    for (const commit of commits) {
+      lines.push(`- ${type}: ${safeLine2(commit.subject)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildLocaleBundle(g, opts) {
+  const sourceLanguage = opts.sourceLanguage ?? "en-US";
+  const sourceText = renderEnglishBullets(g);
+  const isEmpty = sourceText.length === 0;
+  const overflows = [];
+  const entries = opts.locales.map((language) => {
+    if (language === sourceLanguage) {
+      if (isEmpty) {
+        const emptyText = "No notable changes.";
+        return {
+          language,
+          text: emptyText,
+          chars: countChars(emptyText),
+          limit: PLAY_STORE_LIMIT,
+          status: "empty"
+        };
+      }
+      const chars = countChars(sourceText);
+      const status = chars > PLAY_STORE_LIMIT ? "over" : "ok";
+      if (status === "over") overflows.push(language);
+      const text = status === "over" ? truncateToLimit(sourceText, PLAY_STORE_LIMIT) : sourceText;
+      return {
+        language,
+        text,
+        chars,
+        limit: PLAY_STORE_LIMIT,
+        status
+      };
+    }
+    return {
+      language,
+      text: PLACEHOLDER_TEXT,
+      chars: countChars(PLACEHOLDER_TEXT),
+      limit: PLAY_STORE_LIMIT,
+      status: "placeholder"
+    };
+  });
+  return {
+    from: g.from,
+    to: g.to,
+    limit: PLAY_STORE_LIMIT,
+    sourceLanguage,
+    locales: entries,
+    overflows
+  };
+}
+function renderPlayStoreMd(bundle) {
+  const lines = [];
+  lines.push(`# Play Store release notes (${bundle.from} \u2192 ${bundle.to})`);
+  lines.push("");
+  for (const entry of bundle.locales) {
+    let heading;
+    if (entry.status === "placeholder") {
+      heading = `## ${entry.language} (needs translation)`;
+    } else if (entry.status === "empty") {
+      heading = `## ${entry.language} (empty)`;
+    } else {
+      const suffix = entry.status === "over" ? ` \u26A0 truncated` : "";
+      heading = `## ${entry.language} (${entry.chars}/${entry.limit})${suffix}`;
+    }
+    lines.push(heading);
+    lines.push(entry.text);
+    lines.push("");
+  }
+  lines.push("## Summary");
+  for (const entry of bundle.locales) {
+    if (entry.status === "placeholder") {
+      lines.push(`- ${entry.language}: placeholder`);
+    } else if (entry.status === "empty") {
+      lines.push(`- ${entry.language}: empty`);
+    } else {
+      const mark = entry.status === "over" ? "\u2717 over limit" : "\u2713";
+      lines.push(`- ${entry.language}: ${entry.chars}/${entry.limit} ${mark}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderPlayStoreJson(bundle) {
+  return JSON.stringify(bundle, null, 2);
+}
+function renderPlayStorePrompt(bundle, g) {
+  const source = bundle.locales.find((e) => e.language === bundle.sourceLanguage);
+  const targets = bundle.locales.filter((e) => e.language !== bundle.sourceLanguage);
+  const lines = [];
+  lines.push(`You are translating Play Store "What's new" release notes from ${bundle.sourceLanguage}.`);
+  lines.push("");
+  lines.push("TARGETS:");
+  for (const t of targets) lines.push(`  - ${t.language}`);
+  if (targets.length === 0) lines.push("  (none \u2014 source-only bundle)");
+  lines.push("");
+  lines.push("CONSTRAINTS:");
+  lines.push(`- Each translation MUST be \u2264 ${bundle.limit} Unicode code points`);
+  lines.push('- Preserve the bullet format (one item per line, starts with "- ")');
+  lines.push("- Keep a user-facing tone (no internal jargon)");
+  lines.push('- Do not translate technical names (package names, CLI flags, "GPC")');
+  lines.push("- Drop the conventional-commit prefix (feat:/fix:) if it feels unnatural in the target language");
+  lines.push("");
+  lines.push(`SOURCE (${bundle.sourceLanguage}, ${source?.chars ?? 0}/${bundle.limit} chars):`);
+  lines.push("```");
+  lines.push(source?.text ?? "(empty)");
+  lines.push("```");
+  lines.push("");
+  if (g.headlineCandidates.length > 0) {
+    lines.push("CONTEXT (clusters, for theme awareness):");
+    for (const c of g.headlineCandidates) {
+      lines.push(`  - ${c.label} (${c.commits.length} commits, primary ${c.primaryType})`);
+    }
+    lines.push("");
+  }
+  lines.push("OUTPUT FORMAT (one heading + body per target language):");
+  lines.push("```markdown");
+  for (const t of targets) {
+    lines.push(`## ${t.language}`);
+    lines.push("<translation>");
+    lines.push("");
+  }
+  if (targets.length === 0) {
+    lines.push("(no target locales \u2014 nothing to translate)");
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function renderPlayStore(g, opts) {
+  const bundle = buildLocaleBundle(g, opts);
+  switch (opts.format) {
+    case "md":
+      return { output: renderPlayStoreMd(bundle), bundle };
+    case "json":
+      return { output: renderPlayStoreJson(bundle), bundle };
+    case "prompt":
+      return { output: renderPlayStorePrompt(bundle, g), bundle };
+  }
+}
+
+// src/commands/changelog-renderers/index.ts
+var RENDERERS = {
+  md: renderMarkdown,
+  json: renderJson,
+  prompt: renderPrompt
+};
+
+// src/commands/changelog-locales.ts
+async function resolveLocales(input, options = {}) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new GpcError(
+      "--locales is empty",
+      "CHANGELOG_LOCALES_REQUIRED",
+      2,
+      "Pass a comma-separated list (e.g., --locales en-US,fr-FR) or --locales auto."
+    );
+  }
+  if (trimmed === "auto") {
+    const { client, packageName } = options;
+    if (!client || !packageName) {
+      throw new GpcError(
+        "--locales auto requires an authenticated API client and --app",
+        "CHANGELOG_LOCALES_AUTO_NO_APP",
+        2,
+        "Pass --app <package> or set config.app, and ensure credentials are configured."
+      );
+    }
+    const edit = await client.edits.insert(packageName);
+    try {
+      const listings = await client.listings.list(packageName, edit.id);
+      await client.edits.delete(packageName, edit.id);
+      const langs = listings.map((l) => l.language);
+      if (langs.length === 0) {
+        throw new GpcError(
+          `No Play Store listings found for ${packageName}`,
+          "CHANGELOG_LOCALES_EMPTY",
+          1,
+          "Create at least one listing in Play Console, or pass --locales explicitly."
+        );
+      }
+      return langs;
+    } catch (error) {
+      await client.edits.delete(packageName, edit.id).catch(() => {
+      });
+      throw error;
+    }
+  }
+  const locales = trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (locales.length === 0) {
+    throw new GpcError(
+      "--locales parsed to an empty list",
+      "CHANGELOG_LOCALES_REQUIRED",
+      2,
+      "Pass a comma-separated list (e.g., --locales en-US,fr-FR) or --locales auto."
+    );
+  }
+  const invalid = locales.filter((l) => !isValidBcp47(l));
+  if (invalid.length > 0) {
+    throw new GpcError(
+      `Invalid locale(s): ${invalid.join(", ")}`,
+      "CHANGELOG_LOCALES_INVALID",
+      2,
+      "Use BCP 47 codes recognized by Google Play (e.g., en-US, fr-FR, de-DE)."
+    );
+  }
+  return locales;
+}
+
 // src/commands/rtdn.ts
 var SUBSCRIPTION_NOTIFICATION_TYPES = {
   1: "SUBSCRIPTION_RECOVERED",
@@ -7462,7 +8209,11 @@ export {
   GpcError,
   NetworkError,
   PERMISSION_PROPAGATION_WARNING,
+  PLACEHOLDER_TEXT,
+  PLAY_STORE_LIMIT,
   PluginManager,
+  RENDERERS,
+  SECTION_ORDER,
   SENSITIVE_ARG_KEYS,
   SENSITIVE_KEYS,
   SEVERITY_ORDER,
@@ -7478,6 +8229,7 @@ export {
   analyzeReviews2 as analyzeReviews,
   batchGetOrders,
   batchSyncInAppProducts,
+  buildLocaleBundle,
   cancelRecoveryAction,
   cancelSubscriptionPurchase,
   cancelSubscriptionV2,
@@ -7506,6 +8258,7 @@ export {
   deactivateBasePlan,
   deactivateOffer,
   decodeNotification,
+  defaultGitRunner,
   deferSubscriptionPurchase,
   deferSubscriptionV2,
   deleteBasePlan,
@@ -7544,6 +8297,7 @@ export {
   formatStatusSummary,
   formatStatusTable,
   formatWordDiff,
+  generateChangelog,
   generateMigrationPlan,
   generateNotesFromGit,
   getAllScannerNames,
@@ -7617,9 +8371,11 @@ export {
   maybePaginate,
   migratePrices,
   parseAppfile,
+  parseCommit,
   parseFastfile,
   parseGrantArg,
   parseMonth,
+  parseRemoteUrl,
   pauseTrain,
   promoteRelease,
   publish,
@@ -7635,7 +8391,15 @@ export {
   relativeTime,
   removeTesters,
   removeUser,
+  renderJson,
+  renderMarkdown,
+  renderPlayStore,
+  renderPlayStoreJson,
+  renderPlayStoreMd,
+  renderPlayStorePrompt,
+  renderPrompt,
   replyToReview,
+  resolveLocales,
   revokeSubscriptionPurchase,
   runPreflight,
   runWatchLoop,