infernoflow 0.20.0 → 0.22.0

package/dist/lib/commands/adoptWizard.mjs

@@ -0,0 +1,320 @@
+/**
+ * infernoflow adopt
+ *
+ * Interactive adoption wizard for existing projects.
+ * Takes a project from zero to fully wired in one guided flow.
+ *
+ * Steps:
+ *   1. Detect project type, framework, language
+ *   2. Scout capabilities in source files
+ *   3. Interactive approve / rename / skip each candidate
+ *   4. Write capabilities.json + contract.json
+ *   5. Generate starter scenarios
+ *   6. Install git hooks
+ *   7. Regenerate CONTEXT.md
+ *   8. Show health score and next steps
+ *
+ * Usage:
+ *   infernoflow adopt              Full interactive wizard
+ *   infernoflow adopt --yes        Auto-approve all (non-interactive)
+ *   infernoflow adopt --dir src    Custom source directory
+ *   infernoflow adopt --json       Machine-readable, implies --yes
+ */
+
+import * as fs        from "node:fs";
+import * as path      from "node:path";
+import * as readline  from "node:readline";
+import { spawnSync }  from "node:child_process";
+import { done, warn, info, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ── Detection ─────────────────────────────────────────────────────────────────
+
+function detectProject(cwd) {
+  const has  = (...files) => files.some(f => fs.existsSync(path.join(cwd, f)));
+  const read = (f)        => { try { return JSON.parse(fs.readFileSync(path.join(cwd, f), "utf8")); } catch { return {}; } };
+
+  const pkg   = has("package.json") ? read("package.json") : {};
+  const deps  = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  let framework = "unknown", lang = "javascript", type = "backend";
+
+  if (has("tsconfig.json"))                            lang = "typescript";
+  if (has("Pipfile","pyproject.toml","requirements.txt")) lang = "python";
+  if (has("Gemfile"))                                  lang = "ruby";
+  if (has("go.mod"))                                   lang = "go";
+  if (has("Cargo.toml"))                               lang = "rust";
+
+  if      (deps["next"])              { framework = "nextjs";   type = "fullstack"; }
+  else if (deps["nuxt"])              { framework = "nuxt";     type = "fullstack"; }
+  else if (deps["react"])             { framework = "react";    type = "frontend"; }
+  else if (deps["vue"])               { framework = "vue";      type = "frontend"; }
+  else if (deps["@angular/core"])     { framework = "angular";  type = "frontend"; }
+  else if (deps["express"])           { framework = "express";  type = "backend"; }
+  else if (deps["fastify"])           { framework = "fastify";  type = "backend"; }
+  else if (deps["hono"])              { framework = "hono";     type = "backend"; }
+  else if (deps["@nestjs/core"])      { framework = "nestjs";   type = "backend"; }
+  else if (deps["graphql"])           { framework = "graphql";  type = "backend"; }
+  else if (has("config/routes.rb"))   { framework = "rails";    type = "fullstack"; }
+  else if (has("manage.py"))          { framework = "django";   type = "backend"; }
+
+  if (pkg.bin || has("bin/"))         type = "cli";
+  if (has("nx.json","turbo.json","pnpm-workspace.yaml")) type = "monorepo";
+
+  return {
+    name:        pkg.name        || path.basename(cwd),
+    version:     pkg.version     || "0.1.0",
+    description: pkg.description || "",
+    lang, framework, type,
+  };
+}
+
+// ── Scout ─────────────────────────────────────────────────────────────────────
+
+const SRC_EXTS   = new Set([".js",".mjs",".cjs",".ts",".tsx",".jsx",".py",".rb"]);
+const SKIP_DIRS  = new Set(["node_modules",".git","dist","build",".next","__pycache__","vendor","coverage","inferno"]);
+
+const PATTERNS = [
+  {
+    regex: /(?:app|router|server)\s*\.\s*(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+    extract: m => ({ id: routeId(m[2], m[1]), hint: `${m[1].toUpperCase()} ${m[2]}`, confidence: 0.85 }),
+  },
+  {
+    filePattern: /[/\\](pages[/\\]api|app[/\\]api)[/\\](.+)\.(js|ts|mjs)$/,
+    extract: fp => {
+      const m = fp.match(/[/\\](pages[/\\]api|app[/\\]api)[/\\](.+)\.(js|ts|mjs)$/);
+      if (!m) return null;
+      const r = m[2].replace(/[/\\]index$/, "").replace(/\[([^\]]+)\]/g, ":$1");
+      return { id: routeId("/" + r, "api"), hint: `Next.js API: /${r}`, confidence: 0.9 };
+    },
+  },
+  {
+    regex: /export\s+(?:async\s+)?(?:function|class|const)\s+([A-Z][A-Za-z0-9]+)/g,
+    extract: m => ({ id: camelId(m[1]), hint: `export ${m[1]}`, confidence: 0.65 }),
+  },
+];
+
+function routeId(r, method) {
+  const id = r.replace(/^\//, "").replace(/\/:?[^/]+/g, "").replace(/\//g, "-")
+    .replace(/[^a-zA-Z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  return id || method.toLowerCase() + "-root";
+}
+function camelId(name) {
+  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "").replace(/-+/g, "-");
+}
+
+function* walk(dir) {
+  if (!fs.existsSync(dir)) return;
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (SKIP_DIRS.has(e.name)) continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) yield* walk(full);
+    else if (e.isFile() && SRC_EXTS.has(path.extname(e.name))) yield full;
+  }
+}
+
+function scout(dirs, cwd) {
+  const seen = new Map();
+  const add  = (id, r, file) => {
+    if (!seen.has(id) || r.confidence > seen.get(id).confidence)
+      seen.set(id, { ...r, source: path.relative(cwd, file) });
+  };
+
+  for (const dir of dirs) {
+    for (const file of walk(dir)) {
+      for (const pat of PATTERNS) {
+        if (pat.filePattern && pat.filePattern.test(file)) {
+          const r = pat.extract(file);
+          if (r && r.id.length >= 3) add(r.id, r, file);
+        }
+      }
+      let content;
+      try { content = fs.readFileSync(file, "utf8"); } catch { continue; }
+      for (const pat of PATTERNS) {
+        if (!pat.regex) continue;
+        pat.regex.lastIndex = 0;
+        let m;
+        while ((m = pat.regex.exec(content)) !== null) {
+          const r = pat.extract(m);
+          if (r && r.id.length >= 3 && !["index","app","main","root","default","handler"].includes(r.id))
+            add(r.id, r, file);
+        }
+      }
+    }
+  }
+  return [...seen.values()].filter(c => c.confidence >= 0.5).sort((a, b) => b.confidence - a.confidence);
+}
+
+// ── Interactive review ────────────────────────────────────────────────────────
+
+function ask(rl, q) { return new Promise(r => rl.question(q, r)); }
+
+async function review(candidates, autoYes) {
+  if (autoYes) return candidates.filter(c => c.confidence >= 0.6);
+
+  const approved = [];
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log();
+  console.log(`  ${bold("Review candidates")}  ${cyan("y")} approve · ${yellow("e")} edit · ${red("n")} skip · ${gray("a")} approve all · ${gray("q")} stop`);
+  console.log();
+
+  for (let i = 0; i < candidates.length; i++) {
+    const c    = candidates[i];
+    const conf = `${Math.round(c.confidence * 100)}%`;
+    const col  = c.confidence >= 0.8 ? green : c.confidence >= 0.65 ? yellow : gray;
+    process.stdout.write(
+      `  [${i + 1}/${candidates.length}] ${bold(c.id.padEnd(30))} ${col(conf)}  ${gray(c.hint)}\n` +
+      `  ${gray(c.source)}\n  > `
+    );
+
+    const ans = (await ask(rl, "")).trim().toLowerCase();
+    if (ans === "q") break;
+    if (ans === "a") {
+      for (let j = i; j < candidates.length; j++) approved.push(candidates[j]);
+      break;
+    }
+    if (ans === "n") { console.log(`  ${gray("skipped")}\n`); continue; }
+
+    let id = c.id;
+    if (ans === "e") {
+      const newId = (await ask(rl, `  New id (${c.id}): `)).trim();
+      if (newId && /^[a-z0-9-_]+$/.test(newId)) id = newId;
+    }
+    approved.push({ ...c, id });
+    console.log(`  ${green("✔")} ${bold(id)}\n`);
+  }
+
+  rl.close();
+  return approved;
+}
+
+// ── Writers ───────────────────────────────────────────────────────────────────
+
+function writeFiles(infernoDir, approved, project) {
+  // contract.json
+  const cp = path.join(infernoDir, "contract.json");
+  const existing = fs.existsSync(cp) ? JSON.parse(fs.readFileSync(cp, "utf8")) : {};
+  fs.writeFileSync(cp, JSON.stringify({
+    ...existing,
+    policyId:      existing.policyId || project.name.replace(/[^a-zA-Z0-9-]/g, "-"),
+    policyVersion: existing.policyVersion || 1,
+    capabilities:  approved.map(c => c.id),
+  }, null, 2) + "\n");
+
+  // capabilities.json
+  fs.writeFileSync(path.join(infernoDir, "capabilities.json"), JSON.stringify({
+    capabilities: approved.map(c => ({
+      id: c.id, description: c.hint,
+      since: new Date().toISOString().slice(0, 10), source: "adopt",
+    })),
+  }, null, 2) + "\n");
+
+  // Starter scenarios
+  const scenDir = path.join(infernoDir, "scenarios");
+  if (!fs.existsSync(scenDir)) fs.mkdirSync(scenDir, { recursive: true });
+  for (const c of approved) {
+    const sp = path.join(scenDir, `${c.id}.json`);
+    if (fs.existsSync(sp)) continue;
+    fs.writeFileSync(sp, JSON.stringify({
+      id: `${c.id}-happy-path`, capability: c.id,
+      description: `Happy path for ${c.description || c.id}`,
+      steps: [{ action: "invoke", target: c.id, input: {} }, { action: "assert", field: "status", value: "success" }],
+      capabilitiesCovered: [c.id],
+    }, null, 2) + "\n");
+  }
+}
+
+function runCli(args, cwd) {
+  return spawnSync("infernoflow", args, {
+    cwd, encoding: "utf8", timeout: 30_000,
+    stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, NO_COLOR: "1" },
+  });
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function adoptWizardCommand(rawArgs) {
+  const args     = rawArgs.slice(1);
+  const autoYes  = args.includes("--yes") || args.includes("-y") || args.includes("--json");
+  const jsonMode = args.includes("--json");
+  const cwd      = process.cwd();
+
+  const dirIdx   = args.indexOf("--dir");
+  const dirs     = dirIdx !== -1
+    ? args[dirIdx + 1].split(",").map(d => path.resolve(cwd, d.trim()))
+    : ["src","lib","app","api","pages","routes","controllers","services","handlers"]
+        .map(d => path.join(cwd, d)).filter(d => fs.existsSync(d));
+  if (!dirs.length) dirs.push(cwd);
+
+  const project    = detectProject(cwd);
+  const infernoDir = path.join(cwd, "inferno");
+  if (!fs.existsSync(infernoDir)) {
+    fs.mkdirSync(infernoDir, { recursive: true });
+    fs.mkdirSync(path.join(infernoDir, "scenarios"), { recursive: true });
+  }
+
+  if (!jsonMode) {
+    console.log();
+    console.log(`  ${bold("🔥 infernoflow adopt")} ${gray("— existing project wizard")}`);
+    console.log();
+    console.log(`  ${bold("Project:")}   ${cyan(project.name)} v${project.version}`);
+    console.log(`  ${bold("Language:")}  ${project.lang}   ${bold("Framework:")} ${project.framework}   ${bold("Type:")} ${project.type}`);
+    console.log();
+    info(`Scanning ${dirs.map(d => path.relative(cwd, d) || ".").join(", ")} …`);
+  }
+
+  const candidates = scout(dirs, cwd);
+
+  if (!candidates.length) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "No capabilities detected." })); return; }
+    warn("No capabilities detected. Use --dir src,lib,api");
+    return;
+  }
+
+  if (!jsonMode) {
+    console.log();
+    console.log(`  ${bold(`${candidates.length} capability candidates detected`)}`);
+  }
+
+  const approved = await review(candidates, autoYes);
+
+  if (!approved.length) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "No capabilities approved." })); return; }
+    warn("Nothing approved — exiting.");
+    return;
+  }
+
+  writeFiles(infernoDir, approved, project);
+  runCli(["context"], cwd);
+
+  // Offer hooks in interactive mode
+  let hooksInstalled = false;
+  if (!autoYes) {
+    const rl3 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ans  = (await ask(rl3, `\n  Install git hooks for auto-sync? ${gray("[Y/n]")} `)).trim().toLowerCase();
+    rl3.close();
+    if (ans !== "n") { runCli(["setup", "--yes"], cwd); hooksInstalled = true; }
+  } else {
+    runCli(["setup", "--yes"], cwd); hooksInstalled = true;
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, project, detected: candidates.length, approved: approved.length, capabilities: approved.map(c => c.id), hooksInstalled }));
+    return;
+  }
+
+  console.log();
+  done(`${bold(String(approved.length))} capabilities adopted`);
+  console.log();
+  console.log(`  ${green("✔")} ${bold("inferno/contract.json")} written`);
+  console.log(`  ${green("✔")} ${bold("inferno/capabilities.json")} written`);
+  console.log(`  ${green("✔")} ${bold("inferno/scenarios/")} scaffolded`);
+  console.log(`  ${green("✔")} ${bold("inferno/CONTEXT.md")} generated`);
+  if (hooksInstalled) console.log(`  ${green("✔")} Git hooks installed`);
+  console.log();
+  console.log(`  ${bold("Next steps:")}`);
+  console.log(`  ${cyan("1.")} Paste ${bold("inferno/CONTEXT.md")} into Claude or Cursor`);
+  console.log(`  ${cyan("2.")} Run ${bold("infernoflow vibe")} to keep everything in sync automatically`);
+  console.log(`  ${cyan("3.")} Run ${bold("infernoflow health")} to see your starting score`);
+  console.log();
+}

package/dist/lib/commands/coverage.mjs

@@ -0,0 +1,282 @@
+/**
+ * infernoflow coverage
+ *
+ * Maps test files to capabilities via fuzzy name matching.
+ * Shows which capabilities have test coverage and which don't.
+ *
+ * Usage:
+ *   infernoflow coverage               Print coverage table
+ *   infernoflow coverage --json        Machine-readable output
+ *   infernoflow coverage --dir src/    Extra dirs to scan (default: project root)
+ *   infernoflow coverage --fail-below 50  Exit 1 if coverage < N%
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ─── test pattern extractors ─────────────────────────────────────────────────
+
+const TEST_PATTERNS = [
+  // Jest / Vitest  — it("...", …)  test("...", …)  describe("...", …)
+  { regex: /(?:it|test|describe)\s*\(\s*["'`]([^"'`]+)["'`]/g, lang: "js" },
+  // Pytest         — def test_something
+  { regex: /def\s+(test_[\w_]+)\s*\(/g, lang: "py" },
+  // RSpec          — describe/it "..."
+  { regex: /(?:describe|it)\s+["']([^"']+)["']/g, lang: "rb" },
+  // Go             — func TestXxx(
+  { regex: /func\s+(Test\w+)\s*\(/g, lang: "go" },
+  // Rust           — #[test] fn xxx
+  { regex: /#\[test\]\s*\n\s*(?:async\s+)?fn\s+(\w+)/g, lang: "rs" },
+];
+
+const TEST_FILE_GLOBS = [
+  /\.(test|spec)\.[jt]sx?$/,   // foo.test.ts
+  /__tests__/,                  // __tests__/foo.js
+  /\.test\.py$/,                // test_foo.py
+  /^test_.*\.py$/,              // test_foo.py (basename)
+  /_spec\.rb$/,                 // foo_spec.rb
+  /\/spec\//,                   // spec/ directory
+  /_test\.go$/,                 // foo_test.go
+  /_test\.rs$/,                 // foo_test.rs
+];
+
+const SKIP_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", "out", ".next",
+  "coverage", ".nyc_output", "__pycache__", ".pytest_cache",
+  "vendor", "tmp", ".turbo",
+]);
+
+// ─── file walker ─────────────────────────────────────────────────────────────
+
+function* walkFiles(dir) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+  catch { return; }
+
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      if (!SKIP_DIRS.has(e.name)) yield* walkFiles(path.join(dir, e.name));
+    } else if (e.isFile()) {
+      yield path.join(dir, e.name);
+    }
+  }
+}
+
+function isTestFile(filePath) {
+  const basename = path.basename(filePath);
+  return TEST_FILE_GLOBS.some(re => re.test(filePath) || re.test(basename));
+}
+
+// ─── test name extractor ─────────────────────────────────────────────────────
+
+function extractTestNames(filePath) {
+  let src;
+  try { src = fs.readFileSync(filePath, "utf8"); }
+  catch { return []; }
+
+  const names = new Set();
+  for (const { regex } of TEST_PATTERNS) {
+    const r = new RegExp(regex.source, regex.flags);
+    let m;
+    while ((m = r.exec(src)) !== null) {
+      names.add(m[1].trim());
+    }
+  }
+  return [...names];
+}
+
+// ─── fuzzy matcher ───────────────────────────────────────────────────────────
+
+/**
+ * Tokenise a string: split on spaces, hyphens, underscores, camelCase.
+ * Returns an array of lowercase tokens.
+ */
+function tokenise(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1 $2")   // camelCase split
+    .toLowerCase()
+    .split(/[\s_\-/]+/)
+    .filter(Boolean);
+}
+
+/**
+ * Jaccard-like overlap score between two token sets.
+ * Returns a value in [0, 1].
+ */
+function overlapScore(a, b) {
+  const setA = new Set(a);
+  const setB = new Set(b);
+  let common = 0;
+  for (const t of setA) if (setB.has(t)) common++;
+  const union = setA.size + setB.size - common;
+  return union === 0 ? 0 : common / union;
+}
+
+/**
+ * Best match score between a test name and a capability (id + name).
+ */
+function matchScore(testName, cap) {
+  const testTokens = tokenise(testName);
+  const idTokens   = tokenise(cap.id   || "");
+  const nameTokens = tokenise(cap.name || "");
+  return Math.max(
+    overlapScore(testTokens, idTokens),
+    overlapScore(testTokens, nameTokens),
+  );
+}
+
+// ─── main scanner ─────────────────────────────────────────────────────────────
+
+function scanTestFiles(dirs) {
+  const testFiles = [];
+  for (const dir of dirs) {
+    for (const f of walkFiles(dir)) {
+      if (isTestFile(f)) testFiles.push(f);
+    }
+  }
+  return testFiles;
+}
+
+function buildTestIndex(testFiles) {
+  // Returns: Map<testName, filePath>
+  const index = new Map();
+  for (const f of testFiles) {
+    for (const name of extractTestNames(f)) {
+      if (!index.has(name)) index.set(name, f);
+    }
+  }
+  return index;
+}
+
+/** Returns: Map<capId, { matched: [{testName, file, score}], score: number }> */
+function mapTestsToCaps(capabilities, testIndex, threshold = 0.25) {
+  const result = new Map();
+
+  for (const cap of capabilities) {
+    const hits = [];
+    for (const [testName, file] of testIndex) {
+      const score = matchScore(testName, cap);
+      if (score >= threshold) {
+        hits.push({ testName, file: path.relative(process.cwd(), file), score });
+      }
+    }
+    hits.sort((a, b) => b.score - a.score);
+    result.set(cap.id, { cap, hits });
+  }
+  return result;
+}
+
+// ─── reporters ────────────────────────────────────────────────────────────────
+
+function bar(pct, width = 20) {
+  const filled = Math.round((pct / 100) * width);
+  const colour = pct >= 75 ? green : pct >= 40 ? yellow : red;
+  return colour("█".repeat(filled)) + gray("░".repeat(width - filled));
+}
+
+function printTable(coverageMap) {
+  const covered   = [...coverageMap.values()].filter(v => v.hits.length > 0).length;
+  const total     = coverageMap.size;
+  const pct       = total === 0 ? 0 : Math.round((covered / total) * 100);
+
+  console.log();
+  console.log(bold("  Capability Coverage"));
+  console.log(gray("  ─────────────────────────────────────────────────────────────"));
+  console.log(
+    gray("  ") +
+    bold(cyan("Capability".padEnd(32))) +
+    bold(cyan("Tests".padEnd(8))) +
+    bold(cyan("Top match"))
+  );
+  console.log(gray("  ─────────────────────────────────────────────────────────────"));
+
+  for (const [, { cap, hits }] of coverageMap) {
+    const status  = hits.length > 0 ? green("✔") : red("✗");
+    const topName = hits[0] ? gray(`  ${hits[0].testName.slice(0, 42)}`) : "";
+    const count   = hits.length === 0 ? red("0") : green(String(hits.length));
+    console.log(
+      `  ${status} ${cap.id.padEnd(30)} ${count.padEnd(6)} ${topName}`
+    );
+  }
+
+  console.log(gray("  ─────────────────────────────────────────────────────────────"));
+  console.log();
+  console.log(`  ${bar(pct)} ${bold(pct + "%")} (${covered}/${total} capabilities covered)`);
+  console.log();
+
+  if (total > 0 && covered < total) {
+    const uncovered = [...coverageMap.values()]
+      .filter(v => v.hits.length === 0)
+      .map(v => v.cap.id);
+    console.log(yellow(`  ⚠  Uncovered: ${uncovered.join(", ")}`));
+    console.log();
+  }
+}
+
+// ─── entry point ─────────────────────────────────────────────────────────────
+
+export async function coverageCommand(rawArgs) {
+  const args       = rawArgs || [];
+  const jsonMode   = args.includes("--json");
+  const dirIdx     = args.indexOf("--dir");
+  const extraDirs  = dirIdx !== -1 ? [args[dirIdx + 1]] : [];
+  const failIdx    = args.indexOf("--fail-below");
+  const failBelow  = failIdx !== -1 ? Number(args[failIdx + 1]) : null;
+  const threshold  = (() => {
+    const i = args.indexOf("--threshold");
+    return i !== -1 ? Number(args[i + 1]) : 0.25;
+  })();
+
+  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);
+  }
+  let capabilities;
+  try { capabilities = JSON.parse(fs.readFileSync(capsPath, "utf8")); }
+  catch (e) { console.error(red("✗ Failed to parse capabilities.json: " + e.message)); process.exit(1); }
+
+  if (!Array.isArray(capabilities) || capabilities.length === 0) {
+    console.log(yellow("No capabilities found."));
+    process.exit(0);
+  }
+
+  // Scan test files
+  const scanDirs = [cwd, ...extraDirs];
+  if (!jsonMode) process.stdout.write(gray("  Scanning test files…"));
+  const testFiles = scanTestFiles(scanDirs);
+  if (!jsonMode) process.stdout.write(`\r  Found ${testFiles.length} test file(s).    \n`);
+
+  const testIndex   = buildTestIndex(testFiles);
+  const coverageMap = mapTestsToCaps(capabilities, testIndex, threshold);
+
+  const covered = [...coverageMap.values()].filter(v => v.hits.length > 0).length;
+  const total   = coverageMap.size;
+  const pct     = total === 0 ? 0 : Math.round((covered / total) * 100);
+
+  if (jsonMode) {
+    const out = {
+      summary: { covered, total, pct, testFiles: testFiles.length },
+      capabilities: [...coverageMap.entries()].map(([id, { cap, hits }]) => ({
+        id,
+        name: cap.name,
+        covered: hits.length > 0,
+        testCount: hits.length,
+        topTests: hits.slice(0, 3).map(h => ({ name: h.testName, file: h.file, score: +h.score.toFixed(3) })),
+      })),
+    };
+    console.log(JSON.stringify(out, null, 2));
+  } else {
+    printTable(coverageMap);
+  }
+
+  if (failBelow !== null && pct < failBelow) {
+    if (!jsonMode) console.error(red(`✗ Coverage ${pct}% is below threshold ${failBelow}%`));
+    process.exit(1);
+  }
+}