infernoflow 0.18.0 → 0.20.0

package/dist/lib/commands/health.mjs

@@ -0,0 +1,309 @@
+/**
+ * infernoflow health
+ *
+ * Computes a weighted 0–100 health score for the capability contract.
+ * Breaks it down across five dimensions so you know exactly where to improve.
+ *
+ * Dimensions:
+ *   Coverage      % of capabilities that have descriptions      (weight 25)
+ *   Documentation % with at least one scenario/test             (weight 20)
+ *   Freshness     How recently the contract was updated          (weight 20)
+ *   Completeness  Version field, owner, tags present            (weight 15)
+ *   Drift risk    Open issues from `infernoflow check`           (weight 20)
+ *
+ * Usage:
+ *   infernoflow health                  Print score + breakdown
+ *   infernoflow health --json           Machine-readable
+ *   infernoflow health --fail-below 70  Exit 1 if score < 70 (CI gate)
+ *   infernoflow health --watch          Re-run every 30s (for terminals)
+ */
+
+import * as fs          from "node:fs";
+import * as path        from "node:path";
+import { execSync }     from "node:child_process";
+import { done, warn, info, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+const WEIGHTS = {
+  coverage:      25,
+  documentation: 20,
+  freshness:     20,
+  completeness:  15,
+  drift:         20,
+};
+
+// ── Readers ───────────────────────────────────────────────────────────────────
+
+function readContract(infernoDir) {
+  for (const f of ["contract.json", "capabilities.json"]) {
+    const p = path.join(infernoDir, f);
+    if (!fs.existsSync(p)) continue;
+    try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch {}
+  }
+  return null;
+}
+
+function readScenarios(infernoDir) {
+  const scenDir = path.join(infernoDir, "scenarios");
+  if (!fs.existsSync(scenDir)) return [];
+  return fs.readdirSync(scenDir)
+    .filter(f => f.endsWith(".json"))
+    .flatMap(f => {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(scenDir, f), "utf8"));
+        return data.capability ? [data.capability] : (data.capabilities || []);
+      } catch { return []; }
+    });
+}
+
+function runCheck(cwd) {
+  try {
+    const out = execSync("npx infernoflow check --json", {
+      cwd, encoding: "utf8", timeout: 15_000, stdio: ["ignore", "pipe", "pipe"],
+    });
+    return JSON.parse(out);
+  } catch (err) {
+    try { return JSON.parse(err.stdout || "{}"); } catch { return {}; }
+  }
+}
+
+function lastModifiedDaysAgo(infernoDir) {
+  const files = ["contract.json", "capabilities.json"]
+    .map(f => path.join(infernoDir, f))
+    .filter(fs.existsSync);
+  if (!files.length) return 999;
+  const mtime = Math.max(...files.map(f => fs.statSync(f).mtimeMs));
+  return (Date.now() - mtime) / (1000 * 60 * 60 * 24);
+}
+
+// ── Scorers ───────────────────────────────────────────────────────────────────
+
+function scoreCoverage(caps) {
+  if (!caps.length) return { score: 0, detail: "No capabilities" };
+  const withDesc = caps.filter(c => c.description && c.description.length > 5).length;
+  const pct = Math.round((withDesc / caps.length) * 100);
+  return {
+    score:  pct,
+    detail: `${withDesc}/${caps.length} capabilities have descriptions`,
+    pct,
+  };
+}
+
+function scoreDocumentation(caps, scenarioCaps) {
+  if (!caps.length) return { score: 0, detail: "No capabilities" };
+  const scenSet = new Set(scenarioCaps.map(s => String(s).toLowerCase()));
+  const withScen = caps.filter(c => scenSet.has(c.id.toLowerCase())).length;
+  const pct = Math.round((withScen / caps.length) * 100);
+  return {
+    score:  Math.min(100, pct + (scenSet.size === 0 ? 0 : 10)), // bonus for having any scenarios
+    detail: `${withScen}/${caps.length} capabilities have test scenarios`,
+    pct,
+  };
+}
+
+function scoreFreshness(daysAgo) {
+  let score;
+  let label;
+  if (daysAgo <= 1)   { score = 100; label = "updated today"; }
+  else if (daysAgo <= 3)  { score = 95;  label = `updated ${Math.round(daysAgo)}d ago`; }
+  else if (daysAgo <= 7)  { score = 85;  label = `updated ${Math.round(daysAgo)}d ago`; }
+  else if (daysAgo <= 14) { score = 70;  label = `updated ${Math.round(daysAgo)}d ago`; }
+  else if (daysAgo <= 30) { score = 50;  label = `updated ${Math.round(daysAgo)}d ago`; }
+  else if (daysAgo <= 60) { score = 30;  label = `updated ${Math.round(daysAgo)}d ago — stale`; }
+  else                    { score = 10;  label = `not updated in ${Math.round(daysAgo)}d — very stale`; }
+  return { score, detail: label };
+}
+
+function scoreCompleteness(caps, contract) {
+  if (!caps.length) return { score: 0, detail: "No capabilities" };
+  const hasVersion = !!(contract?.version || contract?.contractVersion);
+  const withTags   = caps.filter(c => c.tags?.length).length;
+  const withOwner  = caps.filter(c => c.owner).length;
+  const withSince  = caps.filter(c => c.since).length;
+
+  const tagPct   = Math.round((withTags  / caps.length) * 100);
+  const ownerPct = Math.round((withOwner / caps.length) * 100);
+  const sincePct = Math.round((withSince / caps.length) * 100);
+
+  const score = Math.round(
+    (hasVersion ? 20 : 0) +
+    tagPct   * 0.3 +
+    ownerPct * 0.3 +
+    sincePct * 0.2
+  );
+
+  return {
+    score: Math.min(100, score),
+    detail: `version: ${hasVersion ? "✓" : "✗"}, tags: ${tagPct}%, owner: ${ownerPct}%, since: ${sincePct}%`,
+  };
+}
+
+function scoreDrift(checkResult) {
+  const issues   = checkResult?.issues || [];
+  const warnings = issues.filter(i => (i.severity || i.level || "error") === "warning").length;
+  const errors   = issues.filter(i => (i.severity || i.level || "error") === "error").length;
+  const status   = checkResult?.status;
+
+  if (status === "ok" || (!errors && !warnings)) return { score: 100, detail: "No issues found" };
+
+  const score = Math.max(0, 100 - (errors * 20) - (warnings * 8));
+  return {
+    score,
+    detail: `${errors} error${errors !== 1 ? "s" : ""}, ${warnings} warning${warnings !== 1 ? "s" : ""}`,
+  };
+}
+
+// ── Aggregate ─────────────────────────────────────────────────────────────────
+
+function computeHealth(infernoDir, cwd) {
+  const contract     = readContract(infernoDir);
+  const caps         = (contract?.capabilities || []).map(c =>
+    typeof c === "string" ? { id: c, description: "", tags: [], owner: "", since: "" } : c
+  );
+  const scenarioCaps = readScenarios(infernoDir);
+  const daysAgo      = lastModifiedDaysAgo(infernoDir);
+  const checkResult  = runCheck(cwd);
+
+  const dimensions = {
+    coverage:      scoreCoverage(caps),
+    documentation: scoreDocumentation(caps, scenarioCaps),
+    freshness:     scoreFreshness(daysAgo),
+    completeness:  scoreCompleteness(caps, contract),
+    drift:         scoreDrift(checkResult),
+  };
+
+  const totalScore = Math.round(
+    Object.entries(dimensions).reduce((sum, [key, dim]) => {
+      return sum + (dim.score * WEIGHTS[key]) / 100;
+    }, 0)
+  );
+
+  return { totalScore, dimensions, caps, daysAgo, checkResult };
+}
+
+// ── Renderer ──────────────────────────────────────────────────────────────────
+
+function scoreColor(score) {
+  if (score >= 80) return green;
+  if (score >= 60) return yellow;
+  return red;
+}
+
+function scoreGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+
+function barOf(score, width = 30) {
+  const filled = Math.round((score / 100) * width);
+  const empty  = width - filled;
+  return "█".repeat(filled) + "░".repeat(empty);
+}
+
+function printReport(totalScore, dimensions) {
+  const col   = scoreColor(totalScore);
+  const grade = scoreGrade(totalScore);
+
+  console.log();
+  console.log(`  ${bold("🔥 infernoflow health score")}`);
+  console.log();
+  console.log(`  ${col(bold(String(totalScore)))} / 100   ${col(bold(grade))}   ${col(barOf(totalScore))}`);
+  console.log();
+
+  const dimNames = {
+    coverage:      "Coverage     ",
+    documentation: "Docs/Tests   ",
+    freshness:     "Freshness    ",
+    completeness:  "Completeness ",
+    drift:         "Drift risk   ",
+  };
+
+  for (const [key, dim] of Object.entries(dimensions)) {
+    const w  = WEIGHTS[key];
+    const sc = dim.score;
+    const c  = scoreColor(sc);
+    const bar = barOf(sc, 20);
+    const weighted = Math.round((sc * w) / 100);
+    console.log(
+      `  ${bold(dimNames[key])} ${c(String(sc).padStart(3))}   ${c(bar)}  ${gray(`×${w}% = ${weighted}pts  ${dim.detail}`)}`
+    );
+  }
+  console.log();
+}
+
+function printTips(totalScore, dimensions) {
+  const tips = [];
+
+  if (dimensions.coverage.score < 70)
+    tips.push("Add descriptions to your capabilities in contract.json");
+  if (dimensions.documentation.score < 60)
+    tips.push("Create scenario files in inferno/scenarios/ for each capability");
+  if (dimensions.freshness.score < 70)
+    tips.push("Run `infernoflow suggest` to sync recent changes to the contract");
+  if (dimensions.completeness.score < 60)
+    tips.push("Add version, tags, owner, and since fields to your capabilities");
+  if (dimensions.drift.score < 80)
+    tips.push("Run `infernoflow check` and fix the reported issues");
+
+  if (tips.length) {
+    console.log(`  ${bold("Tips to improve:")}`);
+    tips.forEach(t => console.log(`  ${yellow("·")} ${t}`));
+    console.log();
+  }
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function healthCommand(rawArgs) {
+  const args      = rawArgs.slice(1);
+  const jsonMode  = args.includes("--json");
+  const watchMode = args.includes("--watch");
+  const cwd       = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found. Run: infernoflow init";
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: msg }));
+    else warn(msg);
+    process.exit(1);
+  }
+
+  const failBelowIdx = args.indexOf("--fail-below");
+  const failBelow    = failBelowIdx !== -1 ? parseInt(args[failBelowIdx + 1], 10) : null;
+
+  const intervalIdx  = args.indexOf("--interval");
+  const intervalSecs = intervalIdx !== -1 ? parseInt(args[intervalIdx + 1], 10) : 30;
+
+  const runOnce = () => {
+    const { totalScore, dimensions } = computeHealth(infernoDir, cwd);
+
+    if (jsonMode) {
+      const dimFlat = Object.fromEntries(
+        Object.entries(dimensions).map(([k, v]) => [k, { score: v.score, detail: v.detail, weight: WEIGHTS[k] }])
+      );
+      console.log(JSON.stringify({ ok: true, score: totalScore, grade: scoreGrade(totalScore), dimensions: dimFlat }));
+    } else {
+      if (watchMode) process.stdout.write("\x1Bc"); // clear screen
+      printReport(totalScore, dimensions);
+      if (!watchMode) printTips(totalScore, dimensions);
+    }
+
+    if (failBelow !== null && totalScore < failBelow) {
+      if (!jsonMode) console.error(red(`  ✗  Score ${totalScore} is below threshold ${failBelow} — failing.\n`));
+      process.exit(1);
+    }
+
+    return totalScore;
+  };
+
+  if (watchMode) {
+    if (!jsonMode) info(`Watching health score every ${intervalSecs}s — press Ctrl+C to stop`);
+    runOnce();
+    setInterval(runOnce, intervalSecs * 1000);
+    await new Promise(() => {});
+  } else {
+    runOnce();
+  }
+}

package/dist/lib/commands/link.mjs

@@ -0,0 +1,342 @@
+/**
+ * infernoflow link
+ *
+ * Link capabilities to tickets in Jira, Linear, or GitHub Issues.
+ * Stored in inferno/links.json — travels with the repo.
+ *
+ * Usage:
+ *   infernoflow link --jira PROJ-123 --capability CreateTask
+ *   infernoflow link --linear LIN-456 --capability FilterByTag
+ *   infernoflow link --github 78 --capability ExportToCsv
+ *   infernoflow link list                    Show all links
+ *   infernoflow link status                  Show which caps have open tickets
+ *   infernoflow link remove --capability CreateTask
+ *   infernoflow link --json                  Machine-readable
+ *
+ * Config (inferno/integrations.json):
+ *   {
+ *     "jira":   { "baseUrl": "https://myorg.atlassian.net", "token": "...", "email": "..." },
+ *     "linear": { "apiKey": "lin_api_..." },
+ *     "github": { "repo": "owner/repo", "token": "ghp_..." }
+ *   }
+ *
+ * Env vars (override config):
+ *   JIRA_BASE_URL, JIRA_TOKEN, JIRA_EMAIL
+ *   LINEAR_API_KEY
+ *   GITHUB_TOKEN, GITHUB_REPOSITORY
+ */
+
+import * as fs    from "node:fs";
+import * as path  from "node:path";
+import * as https from "node:https";
+import { done, warn, info, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+const LINKS_FILE = "links.json";
+const CONFIG_FILE = "integrations.json";
+
+// ── Storage ───────────────────────────────────────────────────────────────────
+
+function readLinks(infernoDir) {
+  const p = path.join(infernoDir, LINKS_FILE);
+  if (!fs.existsSync(p)) return [];
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return []; }
+}
+
+function writeLinks(infernoDir, links) {
+  fs.writeFileSync(path.join(infernoDir, LINKS_FILE), JSON.stringify(links, null, 2) + "\n");
+}
+
+function readIntegrationConfig(infernoDir) {
+  const p = path.join(infernoDir, CONFIG_FILE);
+  if (!fs.existsSync(p)) return {};
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return {}; }
+}
+
+// ── HTTP helper ───────────────────────────────────────────────────────────────
+
+function httpsGet(url, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    https.get({
+      hostname: parsed.hostname,
+      path:     parsed.pathname + (parsed.search || ""),
+      headers:  { "User-Agent": "infernoflow-cli", "Accept": "application/json", ...headers },
+    }, (res) => {
+      let data = "";
+      res.on("data", d => (data += d));
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode, body: data }); }
+      });
+    }).on("error", reject);
+  });
+}
+
+// ── Ticket fetchers ───────────────────────────────────────────────────────────
+
+async function fetchJiraTicket(ticketId, config) {
+  const base  = process.env.JIRA_BASE_URL || config.jira?.baseUrl;
+  const token = process.env.JIRA_TOKEN    || config.jira?.token;
+  const email = process.env.JIRA_EMAIL    || config.jira?.email;
+  if (!base || !token) return null;
+
+  try {
+    const creds = Buffer.from(`${email}:${token}`).toString("base64");
+    const resp  = await httpsGet(`${base}/rest/api/3/issue/${ticketId}`, {
+      "Authorization": `Basic ${creds}`,
+    });
+    if (resp.status === 200) {
+      return {
+        id:     ticketId,
+        title:  resp.body.fields?.summary || ticketId,
+        status: resp.body.fields?.status?.name || "unknown",
+        url:    `${base}/browse/${ticketId}`,
+      };
+    }
+  } catch {}
+  return { id: ticketId, title: ticketId, status: "unknown", url: null };
+}
+
+async function fetchLinearTicket(ticketId, config) {
+  const apiKey = process.env.LINEAR_API_KEY || config.linear?.apiKey;
+  if (!apiKey) return null;
+
+  try {
+    const query = JSON.stringify({
+      query: `{ issue(id: "${ticketId}") { title state { name } url } }`
+    });
+    const resp = await new Promise((resolve, reject) => {
+      const body = query;
+      const req  = https.request({
+        hostname: "api.linear.app",
+        path:     "/graphql",
+        method:   "POST",
+        headers:  { "Content-Type": "application/json", "Authorization": apiKey, "Content-Length": Buffer.byteLength(body) },
+      }, (res) => {
+        let data = "";
+        res.on("data", d => (data += d));
+        res.on("end", () => resolve(JSON.parse(data)));
+      });
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+    const issue = resp.data?.issue;
+    if (issue) return { id: ticketId, title: issue.title, status: issue.state?.name || "unknown", url: issue.url };
+  } catch {}
+  return { id: ticketId, title: ticketId, status: "unknown", url: null };
+}
+
+async function fetchGithubIssue(issueNum, config) {
+  const token = process.env.GITHUB_TOKEN     || config.github?.token;
+  const repo  = process.env.GITHUB_REPOSITORY || config.github?.repo;
+  if (!repo) return null;
+
+  try {
+    const headers = { "Authorization": token ? `Bearer ${token}` : undefined };
+    const resp    = await httpsGet(`https://api.github.com/repos/${repo}/issues/${issueNum}`, headers);
+    if (resp.status === 200) {
+      return {
+        id:     `#${issueNum}`,
+        title:  resp.body.title || `Issue #${issueNum}`,
+        status: resp.body.state || "unknown",
+        url:    resp.body.html_url,
+      };
+    }
+  } catch {}
+  return { id: `#${issueNum}`, title: `Issue #${issueNum}`, status: "unknown", url: null };
+}
+
+// ── Sub-commands ──────────────────────────────────────────────────────────────
+
+async function subcmdAdd(args, infernoDir, config) {
+  const jsonMode    = args.includes("--json");
+  const capIdx      = args.indexOf("--capability");
+  const jiraIdx     = args.indexOf("--jira");
+  const linearIdx   = args.indexOf("--linear");
+  const githubIdx   = args.indexOf("--github");
+
+  const capability  = capIdx !== -1  ? args[capIdx + 1]   : null;
+  const jiraId      = jiraIdx !== -1  ? args[jiraIdx + 1]  : null;
+  const linearId    = linearIdx !== -1 ? args[linearIdx + 1] : null;
+  const githubNum   = githubIdx !== -1 ? args[githubIdx + 1] : null;
+
+  if (!capability) {
+    const msg = "Usage: infernoflow link --capability <id> --jira <TICKET> | --linear <ID> | --github <NUM>";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    return;
+  }
+
+  let ticket = null;
+  let platform = null;
+
+  if (jiraId) {
+    if (!jsonMode) process.stdout.write(`  Fetching Jira ${jiraId}… `);
+    ticket   = await fetchJiraTicket(jiraId, config);
+    platform = "jira";
+  } else if (linearId) {
+    if (!jsonMode) process.stdout.write(`  Fetching Linear ${linearId}… `);
+    ticket   = await fetchLinearTicket(linearId, config);
+    platform = "linear";
+  } else if (githubNum) {
+    if (!jsonMode) process.stdout.write(`  Fetching GitHub #${githubNum}… `);
+    ticket   = await fetchGithubIssue(githubNum, config);
+    platform = "github";
+  } else {
+    const msg = "Specify --jira, --linear, or --github";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    return;
+  }
+
+  const links = readLinks(infernoDir);
+  const existing = links.findIndex(l => l.capability === capability);
+
+  const link = {
+    capability,
+    platform,
+    ticketId:   ticket?.id   || jiraId || linearId || `#${githubNum}`,
+    title:      ticket?.title || "",
+    status:     ticket?.status || "unknown",
+    url:        ticket?.url   || null,
+    linkedAt:   new Date().toISOString(),
+  };
+
+  if (existing !== -1) {
+    links[existing] = link;
+  } else {
+    links.push(link);
+  }
+
+  writeLinks(infernoDir, links);
+
+  if (!jsonMode) console.log(green("done"));
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, link }));
+  } else {
+    done(`Linked: ${bold(capability)} → ${cyan(link.ticketId)} (${link.status})`);
+    if (link.url) console.log(`  ${gray(link.url)}`);
+    console.log();
+  }
+}
+
+async function subcmdList(args, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const links    = readLinks(infernoDir);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, links }));
+    return;
+  }
+
+  if (!links.length) {
+    info("No links yet. Use: infernoflow link --capability <id> --jira <TICKET>");
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold(`${links.length} capability link${links.length !== 1 ? "s" : ""}`)}`);
+  console.log();
+
+  const w = Math.max(...links.map(l => l.capability.length), 10) + 2;
+  for (const l of links) {
+    const statusColor = l.status?.toLowerCase() === "done" || l.status?.toLowerCase() === "closed"
+      ? green : l.status?.toLowerCase() === "in progress" ? yellow : gray;
+    console.log(`  ${bold(l.capability.padEnd(w))} ${cyan(l.ticketId.padEnd(14))} ${statusColor(l.status || "unknown")}`);
+    if (l.title && l.title !== l.ticketId) console.log(`  ${" ".repeat(w + 2)}${gray(l.title)}`);
+  }
+  console.log();
+}
+
+async function subcmdStatus(args, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const links    = readLinks(infernoDir);
+
+  // Load contract to find unlinked capabilities
+  let contract = null;
+  for (const f of ["contract.json", "capabilities.json"]) {
+    const p = path.join(infernoDir, f);
+    if (fs.existsSync(p)) { try { contract = JSON.parse(fs.readFileSync(p, "utf8")); break; } catch {} }
+  }
+  const allCaps   = (contract?.capabilities || []).map(c => typeof c === "string" ? c : c.id);
+  const linkedIds = new Set(links.map(l => l.capability));
+  const unlinked  = allCaps.filter(id => !linkedIds.has(id));
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, linked: links.length, unlinked: unlinked.length, links, unlinkedCapabilities: unlinked }));
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold("Capability link status")}`);
+  console.log();
+
+  if (links.length) {
+    console.log(`  ${gray("Linked:")}`);
+    for (const l of links) {
+      const icon = l.status?.toLowerCase() === "done" ? green("✔") : l.status?.toLowerCase() === "in progress" ? yellow("⟳") : gray("○");
+      console.log(`  ${icon}  ${bold(l.capability)}  ${cyan(l.ticketId)}  ${gray(l.status || "")}`);
+    }
+    console.log();
+  }
+
+  if (unlinked.length) {
+    console.log(`  ${gray("Unlinked capabilities:")}`);
+    unlinked.forEach(id => console.log(`  ${gray("·")}  ${id}`));
+    console.log();
+  }
+
+  console.log(`  ${green(String(links.length))} linked · ${gray(String(unlinked.length))} unlinked`);
+  console.log();
+}
+
+async function subcmdRemove(args, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const capIdx   = args.indexOf("--capability");
+  const capId    = capIdx !== -1 ? args[capIdx + 1] : null;
+
+  if (!capId) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "Usage: infernoflow link remove --capability <id>" })); }
+    else { warn("Usage: infernoflow link remove --capability <id>"); }
+    return;
+  }
+
+  const links   = readLinks(infernoDir);
+  const before  = links.length;
+  const updated = links.filter(l => l.capability !== capId);
+
+  if (updated.length === before) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: `No link found for: ${capId}` })); }
+    else { warn(`No link found for: ${capId}`); }
+    return;
+  }
+
+  writeLinks(infernoDir, updated);
+  if (jsonMode) { console.log(JSON.stringify({ ok: true, removed: capId })); }
+  else { done(`Removed link for ${bold(capId)}`); console.log(); }
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function linkCommand(rawArgs) {
+  const args       = rawArgs.slice(1);
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found. Run: infernoflow init";
+    if (args.includes("--json")) { console.log(JSON.stringify({ ok: false, error: msg })); }
+    else { warn(msg); }
+    process.exit(1);
+  }
+
+  const config = readIntegrationConfig(infernoDir);
+  const subcmd = args[0];
+
+  if (subcmd === "list")   return subcmdList(args.slice(1), infernoDir);
+  if (subcmd === "status") return subcmdStatus(args.slice(1), infernoDir);
+  if (subcmd === "remove") return subcmdRemove(args.slice(1), infernoDir);
+
+  // Default: add a link
+  return subcmdAdd(args, infernoDir, config);
+}