infernoflow 0.20.0 → 0.22.0

package/dist/lib/commands/doctor.mjs

@@ -0,0 +1,284 @@
+/**
+ * infernoflow doctor
+ *
+ * Comprehensive setup diagnostic — like `brew doctor`.
+ * Checks every component of the infernoflow setup and tells you
+ * exactly what's wrong and how to fix it.
+ *
+ * Usage:
+ *   infernoflow doctor         Print full diagnostic report
+ *   infernoflow doctor --fix   Auto-fix common issues
+ *   infernoflow doctor --json  Machine-readable output
+ */
+
+import * as fs        from "node:fs";
+import * as path      from "node:path";
+import * as os        from "node:os";
+import * as http      from "node:http";
+import { execSync, spawnSync } from "node:child_process";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+import { detectAvailableProviders } from "../ai/providerRouter.mjs";
+
+// ── Check runners ─────────────────────────────────────────────────────────────
+
+function check(label, fn) {
+  try {
+    const result = fn();
+    return { label, ...result };
+  } catch (err) {
+    return { label, status: "error", message: err.message, fix: null };
+  }
+}
+
+function pass(message, detail)  { return { status: "pass",  message, detail: detail || null, fix: null }; }
+function warn(message, fix)     { return { status: "warn",  message, detail: null, fix: fix || null }; }
+function fail(message, fix)     { return { status: "fail",  message, detail: null, fix: fix || null }; }
+
+// ── Individual checks ─────────────────────────────────────────────────────────
+
+function checkNodeVersion() {
+  const v     = process.version;
+  const major = parseInt(v.slice(1).split(".")[0], 10);
+  if (major >= 20) return pass(`Node.js ${v}`, "Node 20+ recommended");
+  if (major >= 18) return pass(`Node.js ${v}`);
+  return fail(`Node.js ${v} — infernoflow requires Node 18+`, "Install Node 20 from nodejs.org");
+}
+
+function checkCli() {
+  try {
+    const r = spawnSync("infernoflow", ["--version"], { encoding: "utf8", timeout: 5000 });
+    if (r.status === 0) return pass(`infernoflow v${r.stdout.trim()} installed`);
+    return fail("infernoflow CLI not found on PATH", "npm install -g infernoflow");
+  } catch {
+    return fail("infernoflow CLI not found on PATH", "npm install -g infernoflow");
+  }
+}
+
+function checkGitRepo(cwd) {
+  try {
+    execSync("git rev-parse --git-dir", { cwd, stdio: "ignore" });
+    return pass("Git repository detected");
+  } catch {
+    return fail("Not a git repository", "git init && git add . && git commit -m 'init'");
+  }
+}
+
+function checkInfernoDir(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  if (!fs.existsSync(infernoDir)) return fail("inferno/ not found", "infernoflow init");
+  return pass("inferno/ directory exists");
+}
+
+function checkContract(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  for (const f of ["contract.json", "capabilities.json"]) {
+    const p = path.join(infernoDir, f);
+    if (!fs.existsSync(p)) continue;
+    try {
+      const data = JSON.parse(fs.readFileSync(p, "utf8"));
+      const caps = (data.capabilities || []).length;
+      return pass(`${f} valid — ${caps} capabilities`);
+    } catch {
+      return fail(`${f} contains invalid JSON`, `Fix the JSON syntax in inferno/${f}`);
+    }
+  }
+  return fail("No contract.json or capabilities.json", "infernoflow init");
+}
+
+function checkScenarios(cwd) {
+  const scenDir = path.join(cwd, "inferno", "scenarios");
+  if (!fs.existsSync(scenDir)) return warn("No scenarios/ directory", "infernoflow init");
+  const files = fs.readdirSync(scenDir).filter(f => f.endsWith(".json"));
+  if (!files.length) return warn("scenarios/ is empty", "Add scenario files or run infernoflow suggest");
+  return pass(`${files.length} scenario file${files.length !== 1 ? "s" : ""} found`);
+}
+
+function checkChangelog(cwd) {
+  const p = path.join(cwd, "inferno", "CHANGELOG.md");
+  if (!fs.existsSync(p)) return warn("No inferno/CHANGELOG.md", "infernoflow init");
+  return pass("inferno/CHANGELOG.md exists");
+}
+
+function checkContextMd(cwd) {
+  const p = path.join(cwd, "inferno", "CONTEXT.md");
+  if (!fs.existsSync(p)) return warn("No CONTEXT.md generated", "infernoflow context");
+  const age = (Date.now() - fs.statSync(p).mtimeMs) / (1000 * 60 * 60 * 24);
+  if (age > 7) return warn(`CONTEXT.md is ${Math.round(age)} days old — may be stale`, "infernoflow context");
+  return pass(`CONTEXT.md present (${Math.round(age)}d old)`);
+}
+
+function checkGitHooks(cwd) {
+  const hooksDir  = path.join(cwd, ".git", "hooks");
+  const postCommit = path.join(hooksDir, "post-commit");
+  const prePush    = path.join(hooksDir, "pre-push");
+  const hasPost    = fs.existsSync(postCommit) && fs.readFileSync(postCommit, "utf8").includes("infernoflow");
+  const hasPre     = fs.existsSync(prePush)    && fs.readFileSync(prePush, "utf8").includes("infernoflow");
+  if (hasPost && hasPre) return pass("Git hooks installed (post-commit + pre-push)");
+  if (hasPost || hasPre) return warn("Partial git hooks installed", "infernoflow setup --yes");
+  return warn("Git hooks not installed", "infernoflow setup --yes");
+}
+
+function checkMcp(cwd) {
+  // Check for MCP server in cursor config or .mcp.json
+  const checks = [
+    path.join(cwd, ".cursor", "mcp.json"),
+    path.join(cwd, ".mcp.json"),
+    path.join(os.homedir(), ".cursor", "mcp.json"),
+    path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+    path.join(os.homedir(), "AppData", "Roaming", "Claude", "claude_desktop_config.json"),
+  ];
+  for (const p of checks) {
+    if (!fs.existsSync(p)) continue;
+    try {
+      const data = JSON.parse(fs.readFileSync(p, "utf8"));
+      const servers = data.mcpServers || data.mcp_servers || {};
+      if (Object.keys(servers).some(k => k.toLowerCase().includes("inferno"))) {
+        return pass(`MCP server configured in ${path.basename(p)}`);
+      }
+    } catch {}
+  }
+  return warn("MCP server not configured", "infernoflow setup --yes   (adds to Cursor/Claude config)");
+}
+
+function checkAiProviders(cwd) {
+  const providers = detectAvailableProviders(cwd);
+  const available = Object.entries(providers).filter(([, v]) => v).map(([k]) => k);
+
+  if (available.length) return pass(`AI provider${available.length !== 1 ? "s" : ""}: ${available.join(", ")}`);
+
+  return warn(
+    "No AI provider configured",
+    "Set ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_AI_API_KEY, or OPENROUTER_API_KEY\n" +
+    "     Or install Ollama (ollama.com) for free local AI\n" +
+    "     Or use VS Code with GitHub Copilot (zero config)"
+  );
+}
+
+async function checkOllama() {
+  return new Promise(resolve => {
+    const req = http.get({ hostname: "localhost", port: 11434, path: "/api/tags", timeout: 1500 }, res => {
+      resolve(pass("Ollama running on localhost:11434"));
+    });
+    req.on("error", () => resolve({ status: "info", message: "Ollama not running (optional)", fix: "ollama serve", detail: null }));
+    req.on("timeout", () => { req.destroy(); resolve({ status: "info", message: "Ollama not running (optional)", fix: null, detail: null }); });
+  });
+}
+
+function checkCloudToken(cwd) {
+  const p = path.join(cwd, "inferno", "integrations.json");
+  if (!fs.existsSync(p)) return { status: "info", message: "Cloud sync not configured (optional)", fix: "infernoflow cloud init", detail: null };
+  try {
+    const data = JSON.parse(fs.readFileSync(p, "utf8"));
+    if (data.cloud?.token) return pass("Cloud sync configured");
+    return { status: "info", message: "Cloud sync not configured (optional)", fix: "infernoflow cloud init", detail: null };
+  } catch {
+    return { status: "info", message: "Cloud sync not configured (optional)", fix: null, detail: null };
+  }
+}
+
+// ── Auto-fix ──────────────────────────────────────────────────────────────────
+
+function autoFix(results, cwd) {
+  const fixable = results.filter(r => r.status === "warn" && r.fix);
+  const fixed   = [];
+
+  for (const r of fixable) {
+    const fix = r.fix;
+    if (fix.startsWith("infernoflow ")) {
+      const args = fix.slice("infernoflow ".length).split(" ");
+      const res  = spawnSync("infernoflow", args, { cwd, encoding: "utf8", timeout: 30_000 });
+      if (res.status === 0) fixed.push(r.label);
+    }
+  }
+  return fixed;
+}
+
+// ── Renderer ──────────────────────────────────────────────────────────────────
+
+function icon(status) {
+  if (status === "pass") return green("✔");
+  if (status === "warn") return yellow("⚠");
+  if (status === "fail") return red("✗");
+  return gray("·");
+}
+
+function printReport(results, elapsed) {
+  const counts = { pass: 0, warn: 0, fail: 0, info: 0, error: 0 };
+  for (const r of results) counts[r.status] = (counts[r.status] || 0) + 1;
+
+  console.log();
+  console.log(`  ${bold("🔥 infernoflow doctor")}`);
+  console.log();
+
+  const w = Math.max(...results.map(r => r.label.length)) + 2;
+  for (const r of results) {
+    console.log(`  ${icon(r.status)}  ${bold(r.label.padEnd(w))} ${r.message}`);
+    if (r.detail) console.log(`     ${" ".repeat(w)} ${gray(r.detail)}`);
+    if (r.fix && (r.status === "warn" || r.status === "fail")) {
+      console.log(`     ${" ".repeat(w)} ${cyan("fix:")} ${gray(r.fix)}`);
+    }
+  }
+
+  console.log();
+  const overall = counts.fail > 0 ? red("issues found") : counts.warn > 0 ? yellow("warnings") : green("all good");
+  console.log(`  ${overall}  —  ${green(String(counts.pass))} pass · ${yellow(String(counts.warn))} warn · ${red(String(counts.fail))} fail  (${elapsed}ms)`);
+  console.log();
+
+  if (counts.warn > 0 || counts.fail > 0) {
+    console.log(`  Run ${cyan("infernoflow doctor --fix")} to auto-fix warnings`);
+    console.log();
+  }
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function doctorCommand(rawArgs) {
+  const args     = rawArgs.slice(1);
+  const jsonMode = args.includes("--json");
+  const fixMode  = args.includes("--fix");
+  const cwd      = process.cwd();
+  const start    = Date.now();
+
+  const results = [
+    check("Node.js version",   () => checkNodeVersion()),
+    check("infernoflow CLI",   () => checkCli()),
+    check("Git repository",    () => checkGitRepo(cwd)),
+    check("inferno/ directory",() => checkInfernoDir(cwd)),
+    check("Contract file",     () => checkContract(cwd)),
+    check("Scenarios",         () => checkScenarios(cwd)),
+    check("Changelog",         () => checkChangelog(cwd)),
+    check("CONTEXT.md",        () => checkContextMd(cwd)),
+    check("Git hooks",         () => checkGitHooks(cwd)),
+    check("MCP server",        () => checkMcp(cwd)),
+    check("AI providers",      () => checkAiProviders(cwd)),
+    check("Cloud sync",        () => checkCloudToken(cwd)),
+    await checkOllama().then(r => ({ label: "Ollama (local AI)", ...r })),
+  ];
+
+  const elapsed = Date.now() - start;
+
+  if (fixMode) {
+    const fixed = autoFix(results, cwd);
+    if (fixed.length) {
+      if (!jsonMode) {
+        console.log();
+        fixed.forEach(f => console.log(`  ${green("✔")} Fixed: ${f}`));
+        console.log();
+      }
+      // Re-run checks after fixing
+      return doctorCommand(["doctor", "--json"]);
+    }
+  }
+
+  if (jsonMode) {
+    const counts = { pass: 0, warn: 0, fail: 0, info: 0 };
+    results.forEach(r => counts[r.status] = (counts[r.status] || 0) + 1);
+    console.log(JSON.stringify({ ok: counts.fail === 0, counts, results, elapsed }));
+    return;
+  }
+
+  printReport(results, elapsed);
+
+  const hasFail = results.some(r => r.status === "fail");
+  if (hasFail) process.exit(1);
+}

package/dist/lib/commands/init.mjs

@@ -155,6 +155,76 @@ export async function initCommand(args) {
   const force = args.includes("--force") || args.includes("-f");
   const yes = args.includes("--yes") || args.includes("-y");
   const adopt = args.includes("--adopt");
+
+  // ── Template shortcut ──────────────────────────────────────────────────────
+  const templateIdx  = args.indexOf("--template");
+  const templateName = templateIdx !== -1 ? args[templateIdx + 1] : null;
+
+  if (templateName) {
+    let tmplMod;
+    try { tmplMod = await import("../templates/index.mjs"); } catch {}
+    const tmpl = tmplMod?.getTemplate(templateName);
+    if (!tmpl) {
+      const available = tmplMod ? tmplMod.listTemplates().map(t => t.name).join(", ") : "rest-api, nextjs, cli, graphql, monorepo";
+      warn(`Unknown template: ${templateName}. Available: ${available}`);
+      process.exit(1);
+    }
+
+    const infernoDir = path.join(cwd, "inferno");
+    const scenDir    = path.join(infernoDir, "scenarios");
+    if (!fs.existsSync(infernoDir)) fs.mkdirSync(infernoDir, { recursive: true });
+    if (!fs.existsSync(scenDir))    fs.mkdirSync(scenDir,    { recursive: true });
+
+    const policyId = detectProjectName(cwd);
+    const caps     = tmpl.capabilities;
+
+    // Write contract.json
+    fs.writeFileSync(path.join(infernoDir, "contract.json"), JSON.stringify({
+      policyId, policyVersion: 1,
+      capabilities: caps.map(c => c.id),
+    }, null, 2) + "\n");
+
+    // Write capabilities.json
+    fs.writeFileSync(path.join(infernoDir, "capabilities.json"), JSON.stringify({
+      capabilities: caps.map(c => ({
+        id: c.id, description: c.description,
+        since: new Date().toISOString().slice(0, 10), source: `template:${templateName}`,
+      })),
+    }, null, 2) + "\n");
+
+    // Write one scenario per capability
+    for (const cap of caps) {
+      fs.writeFileSync(path.join(scenDir, `${cap.id}.json`), JSON.stringify({
+        id: `${cap.id}-happy-path`, capability: cap.id,
+        description: `Happy path for ${cap.description || cap.id}`,
+        steps: [
+          { action: "invoke", target: cap.id, input: {} },
+          { action: "assert", field: "status", value: "success" },
+        ],
+        capabilitiesCovered: [cap.id],
+      }, null, 2) + "\n");
+    }
+
+    // Write CHANGELOG.md
+    writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
+
+    // Write CONTEXT.md hint
+    fs.writeFileSync(path.join(infernoDir, "CONTEXT.md"),
+      `# ${policyId} — infernoflow context\n\n> Template: ${templateName} — ${tmpl.description}\n\n## Hint\n${tmpl.contextHint}\n\n## Capabilities (${caps.length})\n${caps.map(c => `- \`${c.id}\`: ${c.description}`).join("\n")}\n`
+    );
+
+    if (tmpl.scripts) {
+      info(`Suggested package.json scripts for this template:`);
+      Object.entries(tmpl.scripts).forEach(([k, v]) => console.log(`  ${bold(k)}: ${gray(v)}`));
+      console.log();
+    }
+
+    done(`Initialised from template ${bold(cyan(templateName))} — ${bold(String(caps.length))} capabilities`);
+    console.log();
+    info(`Run ${cyan("infernoflow vibe")} to start vibe coding mode`);
+    console.log();
+    return;
+  }
   const cursorHooks = args.includes("--cursor-hooks");
   const vscodeCopilotHooks = args.includes("--vscode-copilot-hooks");
   const reportJson = args.includes("--report-json");

package/dist/lib/commands/review.mjs

@@ -0,0 +1,238 @@
+/**
+ * infernoflow review
+ *
+ * AI-powered capability impact review for staged (or recent) git changes.
+ * Reads git diff, identifies which capabilities are affected, then asks
+ * your configured AI provider to write a capability impact summary.
+ *
+ * Usage:
+ *   infernoflow review              Review staged changes (git diff --staged)
+ *   infernoflow review --unstaged   Review all working-tree changes
+ *   infernoflow review --last       Review last commit (git diff HEAD~1)
+ *   infernoflow review --dry-run    Print the AI prompt only — no API call
+ *   infernoflow review --json       Machine-readable output
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function runGit(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function loadJson(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, "utf8")); }
+  catch { return null; }
+}
+
+/** Tokenise a string into lowercase words */
+function tokenise(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .split(/[\s_\-/.]+/)
+    .filter(t => t.length > 2);
+}
+
+/** Return capability IDs mentioned in or matched by the diff text */
+function findAffectedCaps(diff, capabilities) {
+  const diffLower = diff.toLowerCase();
+  const affected  = new Set();
+
+  for (const cap of capabilities) {
+    const tokens = [
+      ...tokenise(cap.id   || ""),
+      ...tokenise(cap.name || ""),
+      ...(cap.tags || []).flatMap(tokenise),
+    ];
+    // Direct ID mention (e.g. "auth-login" appears in diff)
+    if (diffLower.includes((cap.id || "").toLowerCase())) {
+      affected.add(cap.id);
+      continue;
+    }
+    // Token overlap — need ≥2 matching tokens to avoid false positives
+    const matches = tokens.filter(t => t.length > 3 && diffLower.includes(t));
+    if (matches.length >= 2) affected.add(cap.id);
+  }
+
+  return [...affected];
+}
+
+/** Trim diff to a reasonable size for the prompt */
+function trimDiff(diff, maxChars = 8000) {
+  if (diff.length <= maxChars) return diff;
+  const half = Math.floor(maxChars / 2);
+  return diff.slice(0, half) + "\n\n[… diff truncated …]\n\n" + diff.slice(-half);
+}
+
+// ─── prompt builder ───────────────────────────────────────────────────────────
+
+function buildPrompt(diff, affectedCaps, capabilities) {
+  const capDetails = capabilities
+    .filter(c => affectedCaps.includes(c.id))
+    .map(c => `  • ${c.id}: ${c.name}${c.description ? " — " + c.description : ""}`)
+    .join("\n");
+
+  const capList = affectedCaps.length > 0
+    ? `Affected capabilities detected:\n${capDetails}`
+    : "No specific capabilities were matched — review the entire contract.";
+
+  return `You are a senior software architect reviewing a code change for capability drift.
+
+${capList}
+
+Git diff:
+\`\`\`diff
+${trimDiff(diff)}
+\`\`\`
+
+Write a concise capability impact summary covering:
+1. Which capabilities are changed, added, or removed
+2. Whether the contract (capabilities.json) needs updating
+3. Any risks or side-effects (breaking changes, auth/security concerns, API contract violations)
+4. Recommended follow-up actions (one sentence each)
+
+Keep the tone professional and brief. Use bullet points only where genuinely helpful.
+Do NOT repeat the diff back.`;
+}
+
+// ─── reporters ────────────────────────────────────────────────────────────────
+
+function printReport(affectedCaps, summary, capabilities, source) {
+  console.log();
+  console.log(bold(cyan("  ✦ Capability Impact Review")));
+  console.log(gray(`  Source: ${source}`));
+  console.log();
+
+  if (affectedCaps.length === 0) {
+    console.log(yellow("  No capabilities directly matched — reviewing full diff."));
+  } else {
+    console.log(bold("  Affected capabilities:"));
+    for (const id of affectedCaps) {
+      const cap = capabilities.find(c => c.id === id);
+      console.log(`    ${green("▸")} ${id}${cap ? gray(" — " + cap.name) : ""}`);
+    }
+  }
+
+  console.log();
+  console.log(bold("  AI Impact Summary"));
+  console.log(gray("  ─────────────────────────────────────────────────────────────"));
+  // Indent each line
+  for (const line of summary.split("\n")) {
+    console.log("  " + line);
+  }
+  console.log();
+}
+
+// ─── entry point ─────────────────────────────────────────────────────────────
+
+export async function reviewCommand(rawArgs) {
+  const args      = rawArgs || [];
+  const dryRun    = args.includes("--dry-run");
+  const jsonMode  = args.includes("--json");
+  const unstaged  = args.includes("--unstaged");
+  const lastCommit = args.includes("--last");
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  // Load capabilities
+  const capsPath = path.join(infernoDir, "capabilities.json");
+  if (!fs.existsSync(capsPath)) {
+    console.error(red("✗ inferno/capabilities.json not found — run `infernoflow init` first."));
+    process.exit(1);
+  }
+  const capabilities = loadJson(capsPath);
+  if (!Array.isArray(capabilities) || capabilities.length === 0) {
+    console.log(yellow("No capabilities found — nothing to review."));
+    process.exit(0);
+  }
+
+  // Get diff
+  let diffCmd, diffSource;
+  if (lastCommit) {
+    diffCmd    = "git diff HEAD~1";
+    diffSource = "last commit (HEAD~1)";
+  } else if (unstaged) {
+    diffCmd    = "git diff";
+    diffSource = "unstaged changes";
+  } else {
+    diffCmd    = "git diff --staged";
+    diffSource = "staged changes";
+  }
+
+  let diff = runGit(diffCmd, cwd);
+
+  // Fallback: if staged is empty, try unstaged
+  if (!diff && !lastCommit && !unstaged) {
+    diff       = runGit("git diff", cwd);
+    diffSource = "unstaged changes (no staged changes found)";
+  }
+
+  if (!diff) {
+    console.log(yellow("No changes found to review."));
+    console.log(gray("  Tip: stage some files first (`git add -p`) or use --last / --unstaged"));
+    process.exit(0);
+  }
+
+  // Identify affected capabilities
+  const affectedCaps = findAffectedCaps(diff, capabilities);
+
+  // Build prompt
+  const prompt = buildPrompt(diff, affectedCaps, capabilities);
+
+  if (dryRun) {
+    console.log(gray("── Prompt (--dry-run) ────────────────────────────────────────────────"));
+    console.log(prompt);
+    process.exit(0);
+  }
+
+  // Call AI
+  if (!jsonMode) process.stdout.write(gray("  Calling AI provider…"));
+
+  let aiResult = null;
+  try {
+    const { callAI } = await import("../ai/providerRouter.mjs");
+    aiResult = await callAI(prompt, { cwd, maxTokens: 600 });
+  } catch (e) {
+    // provider router import failure is non-fatal — we degrade gracefully
+  }
+
+  if (!jsonMode) process.stdout.write("\r" + " ".repeat(30) + "\r");
+
+  if (!aiResult) {
+    console.log();
+    console.log(yellow("  ⚠  No AI provider available."));
+    console.log(gray("  Set ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, or OPENROUTER_API_KEY,"));
+    console.log(gray("  or run Ollama locally. See `infernoflow doctor` for details."));
+    console.log();
+    console.log(bold("  Affected capabilities (unanswered):"));
+    for (const id of affectedCaps) console.log(`    ▸ ${id}`);
+    console.log();
+    process.exit(0);
+  }
+
+  const summary = aiResult.text || "(empty response)";
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      source: diffSource,
+      provider: aiResult.provider,
+      model: aiResult.model,
+      affectedCapabilities: affectedCaps,
+      summary,
+    }, null, 2));
+  } else {
+    printReport(affectedCaps, summary, capabilities, diffSource);
+    console.log(gray(`  Provider: ${aiResult.provider}  Model: ${aiResult.model}`));
+    console.log();
+  }
+}