infernoflow 0.13.0 → 0.16.0

package/dist/lib/commands/onboard.mjs

@@ -0,0 +1,296 @@
+/**
+ * infernoflow onboard
+ *
+ * Interactive step-by-step onboarding wizard for new developers.
+ * Walks through: what infernoflow is, detecting the stack, running init,
+ * showing the first contract, explaining each file, and a test suggest.
+ *
+ * Designed for teams adding a new member — run once, understand everything.
+ *
+ * Usage:
+ *   infernoflow onboard
+ *   infernoflow onboard --yes    # non-interactive (auto-accept all steps)
+ */
+
+import * as fs      from "node:fs";
+import * as path    from "node:path";
+import * as readline from "node:readline";
+import { execSync }  from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { header, ok, warn, info, done, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ── readline helpers ──────────────────────────────────────────────────────────
+
+function createRl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+async function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+async function confirm(rl, question, defaultYes = true) {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await ask(rl, `  ${question} ${gray(hint)} `);
+  if (!answer.trim()) return defaultYes;
+  return answer.trim().toLowerCase().startsWith("y");
+}
+
+// ── step renderer ─────────────────────────────────────────────────────────────
+
+function step(n, total, title) {
+  console.log();
+  console.log(`  ${bold(cyan(`Step ${n}/${total}`))}  ${bold(title)}`);
+  console.log(`  ${gray("─".repeat(50))}`);
+}
+
+function explain(lines) {
+  for (const line of lines) {
+    console.log(`  ${gray(line)}`);
+  }
+  console.log();
+}
+
+// ── project detection ─────────────────────────────────────────────────────────
+
+function detectStack(cwd) {
+  const has = (f) => fs.existsSync(path.join(cwd, f));
+  const pkg = has("package.json") ? JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8")) : {};
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  const framework = deps.react    ? "React"
+                  : deps.next     ? "Next.js"
+                  : deps.vue      ? "Vue"
+                  : deps.angular  ? "Angular"
+                  : deps.express  ? "Express"
+                  : deps.fastify  ? "Fastify"
+                  : has("requirements.txt") ? "Python"
+                  : has("go.mod")           ? "Go"
+                  : has("Cargo.toml")       ? "Rust"
+                  : "unknown";
+
+  const language = has("tsconfig.json") ? "TypeScript"
+                 : has("package.json")  ? "JavaScript"
+                 : has("requirements.txt") ? "Python"
+                 : has("go.mod")           ? "Go"
+                 : "unknown";
+
+  return { framework, language, name: pkg.name || path.basename(cwd) };
+}
+
+function capture(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch { return null; }
+}
+
+// ── main wizard ───────────────────────────────────────────────────────────────
+
+export async function onboardCommand(rawArgs) {
+  const args       = rawArgs.slice(1);
+  const autoYes    = args.includes("--yes") || args.includes("-y");
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+  const TOTAL      = 7;
+
+  const rl = autoYes ? null : createRl();
+
+  const ask_confirm = autoYes
+    ? async () => true
+    : (q, def) => confirm(rl, q, def);
+
+  console.clear();
+  console.log();
+  console.log(`  ${bold("🔥 Welcome to infernoflow")}`);
+  console.log(`  ${gray("This wizard walks you through everything in about 5 minutes.")}`);
+  console.log(`  ${gray("You'll understand what infernoflow does and how it fits your workflow.")}`);
+  console.log();
+
+  if (!autoYes) {
+    const ready = await ask_confirm("Ready to start?", true);
+    if (!ready) { console.log("\n  See you next time!\n"); rl.close(); return; }
+  }
+
+  // ── Step 1: What is infernoflow? ───────────────────────────────────────────
+  step(1, TOTAL, "What is infernoflow?");
+  explain([
+    "infernoflow keeps a living record of your project's capabilities",
+    "— the features your code actually provides — and makes sure that",
+    "record never drifts out of sync as you build.",
+    "",
+    "It works invisibly in the background:",
+    "  • Claude auto-tracks capability changes as you code",
+    "  • Git hooks update the changelog on every commit",
+    "  • PRs get automatic capability drift analysis",
+    "  • Version bumps are recommended automatically (major/minor/patch)",
+    "",
+    "You write code. infernoflow handles the bookkeeping.",
+  ]);
+
+  await ask_confirm("Got it — continue?", true);
+
+  // ── Step 2: Detect your project ────────────────────────────────────────────
+  step(2, TOTAL, "Detecting your project");
+  const stack = detectStack(cwd);
+  const isGitRepo = !!capture("git rev-parse --git-dir", cwd);
+  const alreadySetup = fs.existsSync(infernoDir);
+
+  console.log(`  Project:    ${bold(stack.name)}`);
+  console.log(`  Framework:  ${bold(stack.framework)}`);
+  console.log(`  Language:   ${bold(stack.language)}`);
+  console.log(`  Git repo:   ${isGitRepo ? green("yes") : red("no — git init first")}`);
+  console.log(`  infernoflow: ${alreadySetup ? green("already set up") : yellow("not set up yet")}`);
+  console.log();
+
+  if (!isGitRepo) {
+    warn("This directory is not a git repository.");
+    warn("Run: git init && git add . && git commit -m 'init'");
+    warn("Then run: infernoflow onboard");
+    if (rl) rl.close();
+    process.exit(1);
+  }
+
+  await ask_confirm("Continue?", true);
+
+  // ── Step 3: Run infernoflow setup ──────────────────────────────────────────
+  step(3, TOTAL, "Setting up infernoflow");
+  if (alreadySetup) {
+    ok("infernoflow is already set up in this project");
+    explain(["The inferno/ folder exists — skipping init."]);
+  } else {
+    explain([
+      "infernoflow setup will:",
+      "  1. Scan your codebase and infer capabilities automatically",
+      "  2. Create the inferno/ folder with contract.json",
+      "  3. Install the MCP server (for Claude Code integration)",
+      "  4. Write CLAUDE.md (makes Claude auto-track capabilities)",
+      "  5. Install git hooks (auto changelog + drift check)",
+    ]);
+
+    const go = await ask_confirm("Run infernoflow setup now?", true);
+    if (go) {
+      console.log();
+      try {
+        execSync("npx infernoflow setup --yes", {
+          cwd,
+          stdio: "inherit",
+          timeout: 120_000,
+        });
+      } catch (err) {
+        warn("Setup encountered an issue — you can re-run it manually:");
+        warn("  infernoflow setup");
+      }
+    } else {
+      info("Skipped — run: infernoflow setup");
+    }
+  }
+
+  await ask_confirm("Continue?", true);
+
+  // ── Step 4: Your capability contract ──────────────────────────────────────
+  step(4, TOTAL, "Your capability contract");
+  explain([
+    "The inferno/contract.json is the heart of infernoflow.",
+    "It lists every capability your project has — the things users can DO.",
+    "",
+    "Think of it as a living API contract, but for features, not endpoints.",
+  ]);
+
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (fs.existsSync(contractPath)) {
+    try {
+      const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
+      const caps = contract.capabilities || [];
+      console.log(`  ${bold(String(caps.length))} capabilities tracked:\n`);
+      for (const c of caps.slice(0, 8)) {
+        const cap = typeof c === "string" ? { id: c, title: c } : c;
+        console.log(`    ${green("✔")} ${bold(cap.id)}  ${gray(cap.title || "")}`);
+      }
+      if (caps.length > 8) console.log(`    ${gray(`… and ${caps.length - 8} more`)}`);
+      console.log();
+    } catch {
+      warn("Could not read contract.json");
+    }
+  } else {
+    warn("No contract.json yet — run: infernoflow setup");
+  }
+
+  await ask_confirm("Continue?", true);
+
+  // ── Step 5: Your daily workflow ────────────────────────────────────────────
+  step(5, TOTAL, "Your daily workflow");
+  explain([
+    "Here's exactly how infernoflow fits into your git workflow:",
+    "",
+    "  1. git checkout -b feature/my-feature",
+    "     (branch from main as usual)",
+    "",
+    "  2. Write code in Claude / Cursor / VS Code",
+    "     infernoflow tracks capability changes automatically via CLAUDE.md",
+    "",
+    "  3. git commit -m 'add my feature'",
+    "     post-commit hook silently updates the changelog",
+    "",
+    "  4. git push && open PR",
+    "     GitHub Actions posts a capability drift analysis comment on the PR",
+    "     pre-push hook warns if drift is HIGH",
+    "",
+    "  5. infernoflow version",
+    "     see what semver bump is recommended (major/minor/patch)",
+    "",
+    "You never run infernoflow manually in day-to-day work.",
+    "It runs itself.",
+  ]);
+
+  await ask_confirm("Got it — continue?", true);
+
+  // ── Step 6: Key commands to know ──────────────────────────────────────────
+  step(6, TOTAL, "Key commands");
+  const commands = [
+    ["infernoflow status",          "Quick health check of the contract"],
+    ["infernoflow diff",            "What changed since the last release"],
+    ["infernoflow version",         "What semver bump to use"],
+    ["infernoflow version --apply", "Write the bump to package.json"],
+    ["infernoflow changelog ai",    "Generate a human-readable changelog"],
+    ["infernoflow dashboard",       "Open the live web dashboard"],
+    ["infernoflow team-sync status","See if your team is in sync"],
+    ["infernoflow suggest 'what I built'", "Manually update the contract"],
+  ];
+
+  const maxLen = Math.max(...commands.map(([c]) => c.length));
+  for (const [cmd, desc] of commands) {
+    console.log(`  ${cyan(cmd.padEnd(maxLen + 2))}${gray(desc)}`);
+  }
+  console.log();
+
+  await ask_confirm("Continue?", true);
+
+  // ── Step 7: Live test ─────────────────────────────────────────────────────
+  step(7, TOTAL, "Quick live test");
+  explain(["Let's run infernoflow status to confirm everything is working."]);
+
+  const runTest = await ask_confirm("Run infernoflow status now?", true);
+  if (runTest) {
+    console.log();
+    try {
+      execSync("npx infernoflow status", { cwd, stdio: "inherit", timeout: 30_000 });
+    } catch {
+      warn("Status check failed — try: infernoflow setup");
+    }
+  }
+
+  // ── Done ──────────────────────────────────────────────────────────────────
+  console.log();
+  console.log(`  ${bold("🎉 You're all set!")}`);
+  console.log();
+  console.log(`  ${green("✔")} infernoflow is installed and running`);
+  console.log(`  ${green("✔")} Claude will auto-track capabilities as you code`);
+  console.log(`  ${green("✔")} Git hooks handle changelog and drift automatically`);
+  console.log(`  ${green("✔")} PRs will get automatic capability analysis`);
+  console.log();
+  console.log(`  ${gray("Share this with teammates:")}  ${cyan("infernoflow onboard")}`);
+  console.log(`  ${gray("Questions?")}  ${cyan("infernoflow --help")}`);
+  console.log();
+
+  if (rl) rl.close();
+}

package/dist/lib/commands/prComment.mjs

@@ -0,0 +1,361 @@
+/**
+ * infernoflow pr-comment
+ *
+ * Posts a capability drift analysis as a GitHub PR comment.
+ * Designed to run in CI (GitHub Actions) on pull_request events.
+ *
+ * Auto-reads context from GitHub Actions environment variables:
+ *   GITHUB_TOKEN        — required for posting comments
+ *   GITHUB_REPOSITORY   — e.g. "owner/repo"
+ *   GITHUB_EVENT_PATH   — path to the event JSON (contains PR number)
+ *   GITHUB_SHA          — current commit SHA
+ *   GITHUB_BASE_REF     — base branch name (e.g. "main")
+ *
+ * Usage:
+ *   infernoflow pr-comment                  # auto-detect from CI env
+ *   infernoflow pr-comment --pr 42          # explicit PR number
+ *   infernoflow pr-comment --repo owner/r   # explicit repo
+ *   infernoflow pr-comment --token ghp_...  # explicit token
+ *   infernoflow pr-comment --dry-run        # print comment without posting
+ *   infernoflow pr-comment --json           # machine-readable result
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+import { execSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, gray, green, red, yellow } from "../ui/output.mjs";
+
+// ── git helpers ───────────────────────────────────────────────────────────────
+
+function capture(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch { return null; }
+}
+
+function lastTag(cwd) {
+  return capture("git describe --tags --abbrev=0", cwd) || null;
+}
+
+function fileAtRef(ref, relPath, cwd) {
+  return capture(`git show "${ref}:${relPath}"`, cwd);
+}
+
+// ── capability helpers ────────────────────────────────────────────────────────
+
+function parseCaps(jsonText) {
+  if (!jsonText) return null;
+  try {
+    const obj = JSON.parse(jsonText);
+    const raw = obj.capabilities || [];
+    return raw.map(c => {
+      if (typeof c === "string") return { id: c, title: c };
+      return { id: c.id || c, title: c.title || c.id || String(c), status: c.status };
+    });
+  } catch { return null; }
+}
+
+function loadCapsFromDisk(infernoDir) {
+  for (const name of ["capabilities.json", "contract.json"]) {
+    const p = path.join(infernoDir, name);
+    if (fs.existsSync(p)) return parseCaps(fs.readFileSync(p, "utf8"));
+  }
+  return null;
+}
+
+function loadCapsAtRef(ref, cwd) {
+  for (const name of ["capabilities.json", "contract.json"]) {
+    const content = fileAtRef(ref, `inferno/${name}`, cwd);
+    if (content) return parseCaps(content);
+  }
+  return null;
+}
+
+function diffCaps(before, after) {
+  const beforeMap = new Map(before.map(c => [c.id, c]));
+  const afterMap  = new Map(after.map(c  => [c.id, c]));
+  const added   = after.filter(c  => !beforeMap.has(c.id));
+  const removed = before.filter(c => !afterMap.has(c.id));
+  const changed = [];
+  for (const c of after) {
+    const old = beforeMap.get(c.id);
+    if (!old) continue;
+    const changes = [];
+    if (old.title !== c.title) changes.push({ field: "title", from: old.title, to: c.title });
+    if ((old.status || "") !== (c.status || "")) changes.push({ field: "status", from: old.status || "—", to: c.status || "—" });
+    if (changes.length) changed.push({ id: c.id, changes });
+  }
+  return { added, removed, changed };
+}
+
+function classifyBump(diff) {
+  if (diff.removed.length > 0) return "major";
+  if (diff.added.length   > 0) return "minor";
+  if (diff.changed.length > 0) return "patch";
+  return "none";
+}
+
+// ── comment builder ───────────────────────────────────────────────────────────
+
+function buildComment(diff, bump, ref, currentVersion, nextVersion) {
+  const lines = [];
+
+  // Header
+  const bumpEmoji = bump === "major" ? "🔴" : bump === "minor" ? "🟡" : bump === "patch" ? "🟢" : "✅";
+  const bumpLabel = bump === "none" ? "No capability changes" : `${bump.toUpperCase()} bump recommended`;
+  lines.push(`## 🔥 infernoflow — Capability Analysis`);
+  lines.push(``);
+  lines.push(`${bumpEmoji} **${bumpLabel}**${bump !== "none" ? ` · \`${currentVersion}\` → \`${nextVersion}\`` : ""}`);
+  lines.push(``);
+
+  // Summary table
+  const hasChanges = diff.added.length || diff.removed.length || diff.changed.length;
+  if (!hasChanges) {
+    lines.push(`> No capability changes detected since \`${ref}\`. Contract is in sync.`);
+  } else {
+    lines.push(`| Change | Count |`);
+    lines.push(`|--------|-------|`);
+    if (diff.added.length)   lines.push(`| ➕ Added    | ${diff.added.length} |`);
+    if (diff.removed.length) lines.push(`| ❌ Removed  | ${diff.removed.length} |`);
+    if (diff.changed.length) lines.push(`| ✏️ Modified | ${diff.changed.length} |`);
+    lines.push(``);
+
+    // Detail sections
+    if (diff.added.length) {
+      lines.push(`<details><summary>➕ Added capabilities (${diff.added.length})</summary>`);
+      lines.push(``);
+      for (const c of diff.added) lines.push(`- \`${c.id}\` — ${c.title}`);
+      lines.push(``);
+      lines.push(`</details>`);
+      lines.push(``);
+    }
+
+    if (diff.removed.length) {
+      lines.push(`<details><summary>❌ Removed capabilities (${diff.removed.length}) — breaking change</summary>`);
+      lines.push(``);
+      for (const c of diff.removed) lines.push(`- \`${c.id}\` — ${c.title}`);
+      lines.push(``);
+      lines.push(`</details>`);
+      lines.push(``);
+    }
+
+    if (diff.changed.length) {
+      lines.push(`<details><summary>✏️ Modified capabilities (${diff.changed.length})</summary>`);
+      lines.push(``);
+      for (const item of diff.changed) {
+        lines.push(`- \`${item.id}\``);
+        for (const ch of item.changes) lines.push(`  - ${ch.field}: \`${ch.from}\` → \`${ch.to}\``);
+      }
+      lines.push(``);
+      lines.push(`</details>`);
+      lines.push(``);
+    }
+  }
+
+  // Bump recommendation
+  if (bump === "major") {
+    lines.push(`> ⚠️ **Breaking change detected.** Capabilities were removed. Consider a major version bump.`);
+    lines.push(`> Run \`infernoflow version --apply\` to update \`package.json\`.`);
+  } else if (bump === "minor") {
+    lines.push(`> ℹ️ New capabilities added. A minor version bump is recommended.`);
+    lines.push(`> Run \`infernoflow version --apply\` to update \`package.json\`.`);
+  }
+
+  lines.push(``);
+  lines.push(`---`);
+  lines.push(`<sub>Generated by [infernoflow](https://github.com/ronmiz/infernoflow) · compared against \`${ref}\`</sub>`);
+
+  return lines.join("\n");
+}
+
+// ── GitHub API ────────────────────────────────────────────────────────────────
+
+function githubRequest(method, pathname, body, token) {
+  return new Promise((resolve, reject) => {
+    const data = body ? JSON.stringify(body) : null;
+    const req = https.request({
+      hostname: "api.github.com",
+      path: pathname,
+      method,
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Accept": "application/vnd.github+json",
+        "Content-Type": "application/json",
+        "User-Agent": "infernoflow-cli",
+        ...(data ? { "Content-Length": Buffer.byteLength(data) } : {}),
+      },
+    }, (res) => {
+      let raw = "";
+      res.on("data", chunk => raw += chunk);
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(raw) }); }
+        catch { resolve({ status: res.statusCode, body: raw }); }
+      });
+    });
+    req.on("error", reject);
+    if (data) req.write(data);
+    req.end();
+  });
+}
+
+async function findExistingComment(repo, prNumber, token) {
+  // Look for a previous infernoflow comment to update instead of creating a new one
+  const res = await githubRequest("GET", `/repos/${repo}/issues/${prNumber}/comments?per_page=100`, null, token);
+  if (res.status !== 200 || !Array.isArray(res.body)) return null;
+  return res.body.find(c => c.body && c.body.includes("🔥 infernoflow — Capability Analysis")) || null;
+}
+
+async function postComment(repo, prNumber, body, token) {
+  // Update existing comment if found (avoids spam on multiple pushes)
+  const existing = await findExistingComment(repo, prNumber, token);
+  if (existing) {
+    return githubRequest("PATCH", `/repos/${repo}/issues/comments/${existing.id}`, { body }, token);
+  }
+  return githubRequest("POST", `/repos/${repo}/issues/${prNumber}/comments`, { body }, token);
+}
+
+// ── env helpers ───────────────────────────────────────────────────────────────
+
+function readGithubEventPr() {
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath || !fs.existsSync(eventPath)) return null;
+  try {
+    const event = JSON.parse(fs.readFileSync(eventPath, "utf8"));
+    return event.pull_request?.number || event.number || null;
+  } catch { return null; }
+}
+
+function applyBump(version, type) {
+  const parts = (version || "0.0.0").split(".").map(Number);
+  if (type === "major") { parts[0]++; parts[1] = 0; parts[2] = 0; }
+  else if (type === "minor") { parts[1]++; parts[2] = 0; }
+  else if (type === "patch") { parts[2]++; }
+  return parts.join(".");
+}
+
+function readPackageVersion(cwd) {
+  const p = path.join(cwd, "package.json");
+  if (!fs.existsSync(p)) return "0.0.0";
+  try { return JSON.parse(fs.readFileSync(p, "utf8")).version || "0.0.0"; } catch { return "0.0.0"; }
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+export async function prCommentCommand(rawArgs) {
+  const args   = rawArgs.slice(1);
+  const dryRun = args.includes("--dry-run");
+  const asJson = args.includes("--json");
+
+  const prIdx    = args.indexOf("--pr");
+  const repoIdx  = args.indexOf("--repo");
+  const tokenIdx = args.indexOf("--token");
+  const refIdx   = args.indexOf("--ref");
+
+  const cwd = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!asJson) header("infernoflow pr-comment");
+
+  // ── Resolve inputs ────────────────────────────────────────────────────────
+  const token    = tokenIdx !== -1 ? args[tokenIdx + 1] : process.env.GITHUB_TOKEN;
+  const repo     = repoIdx  !== -1 ? args[repoIdx  + 1] : process.env.GITHUB_REPOSITORY;
+  const prNumber = prIdx    !== -1 ? parseInt(args[prIdx + 1], 10)
+                                   : readGithubEventPr();
+
+  let ref = refIdx !== -1 ? args[refIdx + 1] : null;
+  if (!ref) ref = process.env.GITHUB_BASE_REF ? `origin/${process.env.GITHUB_BASE_REF}` : null;
+  if (!ref) ref = lastTag(cwd);
+  if (!ref) {
+    const parentExists = capture("git rev-parse HEAD~1", cwd);
+    ref = parentExists ? "HEAD~1" : null;
+  }
+
+  // ── Validate ──────────────────────────────────────────────────────────────
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found — run: infernoflow init";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (!dryRun && !token) {
+    const msg = "No GitHub token found. Set GITHUB_TOKEN env var or use --token";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (!dryRun && !repo) {
+    const msg = "No repository found. Set GITHUB_REPOSITORY env var or use --repo owner/repo";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (!dryRun && !prNumber) {
+    const msg = "No PR number found. Use --pr <number> or run in GitHub Actions on pull_request event";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  // ── Load capabilities and compute diff ───────────────────────────────────
+  const current  = loadCapsFromDisk(infernoDir);
+  const previous = ref ? loadCapsAtRef(ref, cwd) : null;
+
+  if (!current) {
+    const msg = "No capabilities.json or contract.json found in inferno/";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const diff = diffCaps(previous || [], current);
+  const bump = classifyBump(diff);
+  const currentVersion = readPackageVersion(cwd);
+  const nextVersion    = bump !== "none" ? applyBump(currentVersion, bump) : currentVersion;
+
+  // ── Build comment ─────────────────────────────────────────────────────────
+  const commentBody = buildComment(diff, bump, ref || "HEAD", currentVersion, nextVersion);
+
+  // ── Dry run ───────────────────────────────────────────────────────────────
+  if (dryRun) {
+    if (asJson) {
+      console.log(JSON.stringify({ ok: true, dryRun: true, bump, currentVersion, nextVersion, comment: commentBody }));
+    } else {
+      console.log();
+      info("DRY RUN — comment that would be posted:");
+      console.log();
+      console.log(commentBody);
+      console.log();
+    }
+    return;
+  }
+
+  // ── Post comment ──────────────────────────────────────────────────────────
+  if (!asJson) info(`Posting to ${bold(repo)} PR #${prNumber}...`);
+
+  try {
+    const result = await postComment(repo, prNumber, commentBody, token);
+
+    if (result.status === 200 || result.status === 201) {
+      const commentUrl = result.body?.html_url || "";
+      if (asJson) {
+        console.log(JSON.stringify({ ok: true, bump, currentVersion, nextVersion, prNumber, repo, commentUrl }));
+      } else {
+        ok(`Comment posted → ${cyan(commentUrl || `PR #${prNumber}`)}`);
+        if (bump !== "none") {
+          console.log();
+          info(`Recommended bump: ${bold(bump.toUpperCase())}  ${currentVersion} → ${nextVersion}`);
+        }
+        console.log();
+      }
+    } else {
+      const msg = `GitHub API error ${result.status}: ${JSON.stringify(result.body)}`;
+      if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); }
+      else { warn(msg); }
+      process.exit(1);
+    }
+  } catch (err) {
+    const msg = `Failed to post comment: ${err.message}`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); }
+    else { warn(msg); }
+    process.exit(1);
+  }
+}