infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/why.mjs

@@ -1,4 +1,358 @@
-import*as F from"node:fs";import*as h from"node:path";import{execSync as W}from"node:child_process";import{bold as C,cyan as V,gray as n,green as x,yellow as I,red as L}from"../ui/output.mjs";function O(o){try{return JSON.parse(F.readFileSync(o,"utf8"))}catch{return null}}function D(o,t){try{return W(o,{cwd:t,encoding:"utf8",stdio:["pipe","pipe","pipe"]}).trim()}catch{return""}}const N={frozen:"\u{1F9CA}",stable:"\u3030\uFE0F ",experimental:"\u{1F30A}"},z={frozen:L,stable:I,experimental:x};function v(o){return o?.stability||"experimental"}function B(o,t,p,i){const c=[],l=o.includes("/")||o.includes("\\")||o.includes("."),r=l?h.relative(i,h.resolve(i,o)):null;for(const e of t){const d=e.codeAnalysis;if(!d)continue;const f=p.find(y=>y.id===e.id)||{};if(l&&(d.sourceFiles||[]).some(u=>u===r||u.endsWith(r)||r?.endsWith(u))){c.push({capId:e.id,capEntry:e,capFull:f,matchedVia:"file",score:1});continue}if(!l&&(d.functions||[]).some(u=>u.toLowerCase()===o.toLowerCase()||u.toLowerCase().includes(o.toLowerCase())||o.toLowerCase().includes(u.toLowerCase()))){c.push({capId:e.id,capEntry:e,capFull:f,matchedVia:"function",score:1});continue}}return c}function J(o,t){const p=h.join(t,"scenarios");if(!F.existsSync(p))return[];const i=[];for(const c of F.readdirSync(p))if(c.endsWith(".json"))try{const l=JSON.parse(F.readFileSync(h.join(p,c),"utf8")),r=l.capabilitiesCovered||l.capabilities||[];(r.includes(o)||r.some(e=>e.toLowerCase()===o.toLowerCase()))&&i.push({file:c,scenario:l})}catch{}return i}function M(o,t,p=5){if(!o)return[];const i=h.relative(t,h.resolve(t,o)),c=D(`git log --follow --format="%h|%aI|%ae|%s" -${p} -- ${JSON.stringify(i)}`,t);return c?c.split(`
-`).filter(Boolean).map(l=>{const[r,e,d,...f]=l.split("|");return{hash:r?.trim(),date:e?.trim()?new Date(e.trim()).toLocaleDateString():"",author:d?.trim(),subject:f.join("|").trim()}}):[]}function R(o,t){if(!o)return null;const p=h.relative(t,h.resolve(t,o)),i=D(`git log --follow --format="%h|%aI|%ae|%s" -- ${JSON.stringify(p)}`,t);if(!i)return null;const c=i.split(`
-`).filter(Boolean);if(!c.length)return null;const[l,r,e,...d]=c[c.length-1].split("|");return{hash:l?.trim(),date:r?.trim()?new Date(r.trim()).toLocaleDateString():"",author:e?.trim(),subject:d.join("|").trim()}}function G(o,t,p,i,c,l,r){const{capId:e,capEntry:d,capFull:f,matchedVia:y}=o,u=v(f),E=N[u]||"\u{1F30A}",m=z[u]||x;console.log(),console.log(C(`  ${E} ${m(e)}`)),(f.name||f.title)&&console.log(n(`     ${f.name||f.title}`)),f.description&&console.log(n(`     ${f.description}`)),console.log(),console.log(n("  matched via:   ")+y+n(" \u2192 ")+V(r)),console.log(n("  stability:     ")+m(u));const g=d.codeAnalysis?.sourceFiles||[];g.length&&console.log(n("  source files:  ")+g.join(", "));const s=d.codeAnalysis?.functions||[];s.length&&console.log(n("  functions:     ")+s.join(", "));const b=d.codeAnalysis?.services||[];b.length&&console.log(n("  uses:          ")+V(b.join(", ")));const w=d.codeAnalysis?.throws||[];if(w.length&&console.log(n("  throws:        ")+I(w.join(", "))),c){const a=c.deps?.[e]||[],$=c.dependents?.[e]||[];a.length&&console.log(n("  calls:         ")+a.map(j=>{const S=l.find(A=>A.id===j);return`${N[v(S)]||"\u{1F30A}"} ${j}`}).join("  ")),$.length&&console.log(n("  called by:     ")+$.map(j=>{const S=l.find(A=>A.id===j);return`${N[v(S)]||"\u{1F30A}"} ${j}`}).join("  "))}if(console.log(),t.length>0){console.log(C("  Scenarios that cover this capability:"));for(const{scenario:a}of t){const $=a.steps?.length||0;console.log(`    ${x("\u2714")} ${a.scenarioId||a.description||a.file}`),a.description&&console.log(n(`      ${a.description}`)),$&&console.log(n(`      ${$} step(s)`))}console.log()}else console.log(I("  \u26A0  No scenarios found for this capability.")),console.log(n(`     Run: infernoflow suggest "add scenario for ${e}"`)),console.log();if(i&&(console.log(C("  Origin:")),console.log(`    ${n("first commit:")} ${i.hash} \xB7 ${i.date} \xB7 ${i.author}`),console.log(`    ${n("subject:")}      ${i.subject}`),console.log()),p.length>0){console.log(C("  Recent changes:"));for(const a of p.slice(0,4))console.log(`    ${n(a.hash)} ${n(a.date.padEnd(12))} ${a.subject}`);console.log()}u==="frozen"&&(console.log(L("  \u{1F9CA} This capability is FROZEN \u2014 do not modify without explicit instruction.")),console.log())}async function _(o){const t=(o||[]).slice(1),p=t.includes("--json"),i=t.indexOf("--function"),c=i!==-1?t[i+1]:null,l=t.find((g,s)=>!g.startsWith("--")&&(i===-1||s!==i+1));l||(console.error(L("\u2717 Usage: infernoflow why <file-or-function> [--function <name>] [--json]")),console.error(n("  Examples:")),console.error(n("    infernoflow why src/auth.ts")),console.error(n("    infernoflow why loginUser")),process.exit(1));const r=process.cwd(),e=h.join(r,"inferno"),d=O(h.join(e,"scan.json"));d||(console.error(L("\u2717 inferno/scan.json not found \u2014 run `infernoflow scan` first.")),process.exit(1));let f=[];const y=O(h.join(e,"capabilities.json"));y&&(f=Array.isArray(y)?y:y.capabilities||[]);const u=O(h.join(e,"graph.json")),E=d.capabilities||[];let m=B(l,E,f,r);if(c&&m.length>1&&(m=m.filter(g=>(g.capEntry.codeAnalysis?.functions||[]).some(s=>s.toLowerCase().includes(c.toLowerCase())))),m.length===0&&(console.log(),console.log(I(`  No capability found matching: ${C(l)}`)),console.log(n("  Tip: run `infernoflow scan` to update code analysis, then try again.")),console.log(n("  Tip: use a function name or relative file path.")),console.log(),process.exit(0)),p){const g=m.map(s=>{const b=J(s.capId,e),w=s.capEntry.codeAnalysis?.sourceFiles||[],a=M(w[0],r),$=R(w[0],r);return{capId:s.capId,name:s.capFull.name||s.capFull.title,stability:v(s.capFull),matchedVia:s.matchedVia,sourceFiles:w,functions:s.capEntry.codeAnalysis?.functions||[],services:s.capEntry.codeAnalysis?.services||[],throws:s.capEntry.codeAnalysis?.throws||[],deps:u?.deps?.[s.capId]||[],dependents:u?.dependents?.[s.capId]||[],scenarios:b.map(j=>j.scenario?.scenarioId||j.file),firstCommit:$,recentHistory:a}});console.log(JSON.stringify(g,null,2));return}console.log(n(`
-  infernoflow why  \u2192  ${C(l)}`)),console.log(n("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));for(const g of m){const s=g.capEntry.codeAnalysis?.sourceFiles||[],b=J(g.capId,e),w=M(s[0],r),a=R(s[0],r);G(g,b,w,a,u,f,l)}}export{_ as whyCommand};
+/**
+ * infernoflow why
+ *
+ * Given a file path or function name — answer:
+ *   • Which capability does this serve?
+ *   • What is its stability level?
+ *   • What scenarios cover it?
+ *   • Who introduced it and when?
+ *   • What does it call / what calls it?
+ *
+ * Pure correlation — no AI needed. Uses scan.json + graph.json + scenarios/ + git log.
+ *
+ * Usage:
+ *   infernoflow why src/auth.ts
+ *   infernoflow why loginUser
+ *   infernoflow why src/auth.ts --function loginUser
+ *   infernoflow why --json src/auth.ts
+ */
+
+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 loadJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); }
+  catch { return null; }
+}
+
+function runGit(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch { return ""; }
+}
+
+const LEVEL_ICON  = { frozen: "🧊", stable: "〰️ ", experimental: "🌊" };
+const LEVEL_COLOR = { frozen: red, stable: yellow, experimental: green };
+
+function stability(cap) {
+  return cap?.stability || "experimental";
+}
+
+// ── matchers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Given a target (file path or function name), find all matching
+ * capabilities from scan.json.
+ * Returns: [{ capId, capEntry, matchedVia, score }]
+ */
+function findCapabilities(target, scanCaps, allCaps, cwd) {
+  const results = [];
+  const isFile  = target.includes("/") || target.includes("\\") || target.includes(".");
+  const relTarget = isFile ? path.relative(cwd, path.resolve(cwd, target)) : null;
+
+  for (const entry of scanCaps) {
+    const analysis = entry.codeAnalysis;
+    if (!analysis) continue;
+
+    const capFull = allCaps.find(c => c.id === entry.id) || {};
+
+    if (isFile) {
+      // Match by source file
+      const fileMatch = (analysis.sourceFiles || []).some(f =>
+        f === relTarget || f.endsWith(relTarget) || relTarget?.endsWith(f)
+      );
+      if (fileMatch) {
+        results.push({ capId: entry.id, capEntry: entry, capFull, matchedVia: "file", score: 1.0 });
+        continue;
+      }
+    }
+
+    if (!isFile) {
+      // Match by function name (exact or contains)
+      const fnMatch = (analysis.functions || []).some(fn =>
+        fn.toLowerCase() === target.toLowerCase() ||
+        fn.toLowerCase().includes(target.toLowerCase()) ||
+        target.toLowerCase().includes(fn.toLowerCase())
+      );
+      if (fnMatch) {
+        results.push({ capId: entry.id, capEntry: entry, capFull, matchedVia: "function", score: 1.0 });
+        continue;
+      }
+    }
+  }
+
+  return results;
+}
+
+// ── scenario finder ───────────────────────────────────────────────────────────
+
+function findScenarios(capId, infernoDir) {
+  const scenariosDir = path.join(infernoDir, "scenarios");
+  if (!fs.existsSync(scenariosDir)) return [];
+
+  const found = [];
+  for (const f of fs.readdirSync(scenariosDir)) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const s = JSON.parse(fs.readFileSync(path.join(scenariosDir, f), "utf8"));
+      const covered = s.capabilitiesCovered || s.capabilities || [];
+      if (covered.includes(capId) || covered.some(c =>
+        c.toLowerCase() === capId.toLowerCase()
+      )) {
+        found.push({ file: f, scenario: s });
+      }
+    } catch {}
+  }
+  return found;
+}
+
+// ── git history ───────────────────────────────────────────────────────────────
+
+function getGitHistory(filePath, cwd, limit = 5) {
+  if (!filePath) return [];
+  const rel = path.relative(cwd, path.resolve(cwd, filePath));
+  const log = runGit(
+    `git log --follow --format="%h|%aI|%ae|%s" -${limit} -- ${JSON.stringify(rel)}`,
+    cwd
+  );
+  if (!log) return [];
+
+  return log.split("\n").filter(Boolean).map(line => {
+    const [hash, date, author, ...subjectParts] = line.split("|");
+    return {
+      hash:    hash?.trim(),
+      date:    date?.trim() ? new Date(date.trim()).toLocaleDateString() : "",
+      author:  author?.trim(),
+      subject: subjectParts.join("|").trim(),
+    };
+  });
+}
+
+function getFirstCommit(filePath, cwd) {
+  if (!filePath) return null;
+  const rel = path.relative(cwd, path.resolve(cwd, filePath));
+  const log = runGit(
+    `git log --follow --format="%h|%aI|%ae|%s" -- ${JSON.stringify(rel)}`,
+    cwd
+  );
+  if (!log) return null;
+  const lines = log.split("\n").filter(Boolean);
+  if (!lines.length) return null;
+  const [hash, date, author, ...subjectParts] = lines[lines.length - 1].split("|");
+  return {
+    hash:    hash?.trim(),
+    date:    date?.trim() ? new Date(date.trim()).toLocaleDateString() : "",
+    author:  author?.trim(),
+    subject: subjectParts.join("|").trim(),
+  };
+}
+
+// ── printer ───────────────────────────────────────────────────────────────────
+
+function printResult(result, scenarios, history, firstCommit, graph, allCaps, target) {
+  const { capId, capEntry, capFull, matchedVia } = result;
+  const level = stability(capFull);
+  const icon  = LEVEL_ICON[level]  || "🌊";
+  const color = LEVEL_COLOR[level] || green;
+
+  console.log();
+  console.log(bold(`  ${icon} ${color(capId)}`));
+  if (capFull.name || capFull.title) {
+    console.log(gray(`     ${capFull.name || capFull.title}`));
+  }
+  if (capFull.description) {
+    console.log(gray(`     ${capFull.description}`));
+  }
+  console.log();
+
+  // Matched via
+  console.log(gray(`  matched via:   `) + matchedVia + gray(` → `) + cyan(target));
+
+  // Stability
+  console.log(gray(`  stability:     `) + color(level));
+
+  // Source files
+  const files = capEntry.codeAnalysis?.sourceFiles || [];
+  if (files.length) {
+    console.log(gray(`  source files:  `) + files.join(", "));
+  }
+
+  // Functions
+  const fns = capEntry.codeAnalysis?.functions || [];
+  if (fns.length) {
+    console.log(gray(`  functions:     `) + fns.join(", "));
+  }
+
+  // External services
+  const services = capEntry.codeAnalysis?.services || [];
+  if (services.length) {
+    console.log(gray(`  uses:          `) + cyan(services.join(", ")));
+  }
+
+  // Throws
+  const throws = capEntry.codeAnalysis?.throws || [];
+  if (throws.length) {
+    console.log(gray(`  throws:        `) + yellow(throws.join(", ")));
+  }
+
+  // Dependencies from graph
+  if (graph) {
+    const deps      = graph.deps?.[capId]       || [];
+    const dependents = graph.dependents?.[capId] || [];
+    if (deps.length) {
+      console.log(gray(`  calls:         `) + deps.map(d => {
+        const dCap = allCaps.find(c => c.id === d);
+        const dIcon = LEVEL_ICON[stability(dCap)] || "🌊";
+        return `${dIcon} ${d}`;
+      }).join("  "));
+    }
+    if (dependents.length) {
+      console.log(gray(`  called by:     `) + dependents.map(d => {
+        const dCap = allCaps.find(c => c.id === d);
+        const dIcon = LEVEL_ICON[stability(dCap)] || "🌊";
+        return `${dIcon} ${d}`;
+      }).join("  "));
+    }
+  }
+
+  console.log();
+
+  // Scenarios
+  if (scenarios.length > 0) {
+    console.log(bold("  Scenarios that cover this capability:"));
+    for (const { scenario } of scenarios) {
+      const steps = scenario.steps?.length || 0;
+      console.log(`    ${green("✔")} ${scenario.scenarioId || scenario.description || scenario.file}`);
+      if (scenario.description) console.log(gray(`      ${scenario.description}`));
+      if (steps) console.log(gray(`      ${steps} step(s)`));
+    }
+    console.log();
+  } else {
+    console.log(yellow("  ⚠  No scenarios found for this capability."));
+    console.log(gray(`     Run: infernoflow suggest "add scenario for ${capId}"`));
+    console.log();
+  }
+
+  // Git history
+  if (firstCommit) {
+    console.log(bold("  Origin:"));
+    console.log(`    ${gray("first commit:")} ${firstCommit.hash} · ${firstCommit.date} · ${firstCommit.author}`);
+    console.log(`    ${gray("subject:")}      ${firstCommit.subject}`);
+    console.log();
+  }
+
+  if (history.length > 0) {
+    console.log(bold("  Recent changes:"));
+    for (const h of history.slice(0, 4)) {
+      console.log(`    ${gray(h.hash)} ${gray(h.date.padEnd(12))} ${h.subject}`);
+    }
+    console.log();
+  }
+
+  // Frozen warning
+  if (level === "frozen") {
+    console.log(red("  🧊 This capability is FROZEN — do not modify without explicit instruction."));
+    console.log();
+  }
+}
+
+// ── entry point ───────────────────────────────────────────────────────────────
+
+export async function whyCommand(rawArgs) {
+  const args     = (rawArgs || []).slice(1); // skip command name
+  const jsonMode = args.includes("--json");
+  const fnFlag   = args.indexOf("--function");
+  const fnFilter = fnFlag !== -1 ? args[fnFlag + 1] : null;
+
+  // Target: first non-flag argument (skip the value after --function if present)
+  const target = args.find((a, i) => !a.startsWith("--") && (fnFlag === -1 || i !== fnFlag + 1));
+
+  if (!target) {
+    console.error(red("✗ Usage: infernoflow why <file-or-function> [--function <name>] [--json]"));
+    console.error(gray("  Examples:"));
+    console.error(gray("    infernoflow why src/auth.ts"));
+    console.error(gray("    infernoflow why loginUser"));
+    process.exit(1);
+  }
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  // Load scan.json
+  const scan = loadJson(path.join(infernoDir, "scan.json"));
+  if (!scan) {
+    console.error(red("✗ inferno/scan.json not found — run `infernoflow scan` first."));
+    process.exit(1);
+  }
+
+  // Load capabilities.json for stability + metadata
+  let allCaps = [];
+  const rawCaps = loadJson(path.join(infernoDir, "capabilities.json"));
+  if (rawCaps) allCaps = Array.isArray(rawCaps) ? rawCaps : (rawCaps.capabilities || []);
+
+  // Load graph.json
+  const graph = loadJson(path.join(infernoDir, "graph.json"));
+
+  // Find capabilities
+  const scanCaps = scan.capabilities || [];
+  let results    = findCapabilities(target, scanCaps, allCaps, cwd);
+
+  // Apply --function filter
+  if (fnFilter && results.length > 1) {
+    results = results.filter(r =>
+      (r.capEntry.codeAnalysis?.functions || []).some(fn =>
+        fn.toLowerCase().includes(fnFilter.toLowerCase())
+      )
+    );
+  }
+
+  if (results.length === 0) {
+    console.log();
+    console.log(yellow(`  No capability found matching: ${bold(target)}`));
+    console.log(gray("  Tip: run `infernoflow scan` to update code analysis, then try again."));
+    console.log(gray("  Tip: use a function name or relative file path."));
+    console.log();
+    process.exit(0);
+  }
+
+  if (jsonMode) {
+    const out = results.map(r => {
+      const scenarios = findScenarios(r.capId, infernoDir);
+      const files     = r.capEntry.codeAnalysis?.sourceFiles || [];
+      const history   = getGitHistory(files[0], cwd);
+      const first     = getFirstCommit(files[0], cwd);
+      return {
+        capId:       r.capId,
+        name:        r.capFull.name || r.capFull.title,
+        stability:   stability(r.capFull),
+        matchedVia:  r.matchedVia,
+        sourceFiles: files,
+        functions:   r.capEntry.codeAnalysis?.functions || [],
+        services:    r.capEntry.codeAnalysis?.services  || [],
+        throws:      r.capEntry.codeAnalysis?.throws    || [],
+        deps:        graph?.deps?.[r.capId]        || [],
+        dependents:  graph?.dependents?.[r.capId]  || [],
+        scenarios:   scenarios.map(s => s.scenario?.scenarioId || s.file),
+        firstCommit: first,
+        recentHistory: history,
+      };
+    });
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+
+  console.log(gray(`\n  infernoflow why  →  ${bold(target)}`));
+  console.log(gray("  ──────────────────────────────────────────────────────────────"));
+
+  for (const result of results) {
+    const files     = result.capEntry.codeAnalysis?.sourceFiles || [];
+    const scenarios = findScenarios(result.capId, infernoDir);
+    const history   = getGitHistory(files[0], cwd);
+    const first     = getFirstCommit(files[0], cwd);
+    printResult(result, scenarios, history, first, graph, allCaps, target);
+  }
+}

package/dist/lib/cursorHooksInstall.mjs

@@ -1 +1,60 @@
-import*as r from"node:fs";import*as o from"node:path";import{installInfernoDraftTooling as v}from"./draftToolingInstall.mjs";function h(f){const{cwd:s,templatesRoot:t,force:m,silent:e}=f,a=f.logOk||(()=>{}),l=f.logWarn||(()=>{});function p(n,c){return r.existsSync(c)&&!m?(e||l("Skipped (exists): "+o.relative(s,c)),!1):(r.mkdirSync(o.dirname(c),{recursive:!0}),r.copyFileSync(n,c),e||a("Created: "+o.relative(s,c)),!0)}v({cwd:s,templatesRoot:t,force:m,silent:e,logOk:a,logWarn:l});const u=o.join(t,"cursor","hooks.json"),j=o.join(s,".cursor","hooks.json"),k=o.join(t,"cursor","hooks","inferno-session-draft.mjs"),S=o.join(s,".cursor","hooks","inferno-session-draft.mjs");p(u,j),p(k,S);const d=o.join(t,"cursor","inferno-mcp-server.mjs"),y=o.join(s,"inferno-mcp-server.mjs");p(d,y);const i=o.join(s,".cursor","mcp.json");if(!r.existsSync(i)||m){let n={};if(r.existsSync(i))try{n=JSON.parse(r.readFileSync(i,"utf8"))}catch{}n.mcpServers||(n.mcpServers={}),n.mcpServers.infernoflow={command:"node",args:["./inferno-mcp-server.mjs"],env:{}},r.mkdirSync(o.dirname(i),{recursive:!0}),r.writeFileSync(i,JSON.stringify(n,null,2),"utf8"),e||a("Created: .cursor/mcp.json")}else e||l("Skipped (exists): .cursor/mcp.json")}export{h as installCursorHooksArtifacts};
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { installInfernoDraftTooling } from "./draftToolingInstall.mjs";
+
+/**
+ * @param {object} opts
+ * @param {string} opts.cwd
+ * @param {string} opts.templatesRoot
+ * @param {boolean} opts.force
+ * @param {boolean} opts.silent
+ * @param {(msg: string) => void} [opts.logOk]
+ * @param {(msg: string) => void} [opts.logWarn]
+ */
+export function installCursorHooksArtifacts(opts) {
+  const { cwd, templatesRoot, force, silent } = opts;
+  const logOk = opts.logOk || (() => {});
+  const logWarn = opts.logWarn || (() => {});
+
+  function copyFile(src, dst) {
+    if (fs.existsSync(dst) && !force) {
+      if (!silent) logWarn("Skipped (exists): " + path.relative(cwd, dst));
+      return false;
+    }
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.copyFileSync(src, dst);
+    if (!silent) logOk("Created: " + path.relative(cwd, dst));
+    return true;
+  }
+
+  installInfernoDraftTooling({ cwd, templatesRoot, force, silent, logOk, logWarn });
+
+  const srcHooksJson = path.join(templatesRoot, "cursor", "hooks.json");
+  const dstHooksJson = path.join(cwd, ".cursor", "hooks.json");
+  const srcHook = path.join(templatesRoot, "cursor", "hooks", "inferno-session-draft.mjs");
+  const dstHook = path.join(cwd, ".cursor", "hooks", "inferno-session-draft.mjs");
+
+  copyFile(srcHooksJson, dstHooksJson);
+  copyFile(srcHook, dstHook);
+
+  // MCP server
+  const srcMcp = path.join(templatesRoot, "cursor", "inferno-mcp-server.mjs");
+  const dstMcp = path.join(cwd, "inferno-mcp-server.mjs");
+  copyFile(srcMcp, dstMcp);
+
+  // .cursor/mcp.json
+  const mcpJsonPath = path.join(cwd, ".cursor", "mcp.json");
+  if (!fs.existsSync(mcpJsonPath) || force) {
+    let existing = {};
+    if (fs.existsSync(mcpJsonPath)) {
+      try { existing = JSON.parse(fs.readFileSync(mcpJsonPath, "utf8")); } catch {}
+    }
+    if (!existing.mcpServers) existing.mcpServers = {};
+    existing.mcpServers.infernoflow = { command: "node", args: ["./inferno-mcp-server.mjs"], env: {} };
+    fs.mkdirSync(path.dirname(mcpJsonPath), { recursive: true });
+    fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2), "utf8");
+    if (!silent) logOk("Created: .cursor/mcp.json");
+  } else {
+    if (!silent) logWarn("Skipped (exists): .cursor/mcp.json");
+  }
+}

package/dist/lib/draftToolingInstall.mjs

@@ -1,8 +1,69 @@
-import*as t from"node:fs";import*as n from"node:path";const d=`
-# infernoflow: agent draft (IDE hooks \u2014 review before commit)
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const GITIGNORE_SNIPPET = `
+# infernoflow: agent draft (IDE hooks — review before commit)
 inferno/CONTEXT.draft.md
-`.trimStart();function S(o,e,c){const s=n.join(o,"package.json");if(!t.existsSync(s)){e||c("No package.json \u2014 add script manually: inferno:promote-draft");return}const r=JSON.parse(t.readFileSync(s,"utf8"));r.scripts=r.scripts||{},r.scripts["inferno:promote-draft"]||(r.scripts["inferno:promote-draft"]="node scripts/inferno-promote-draft.mjs",t.writeFileSync(s,JSON.stringify(r,null,2)+`
-`,"utf8"),e||c("Updated package.json script: inferno:promote-draft"))}function y(o){const{cwd:e,templatesRoot:c,force:s,silent:r}=o,f=o.logOk||(()=>{}),l=o.logWarn||(()=>{});function m(p,a){return t.existsSync(a)&&!s?(r||l("Skipped (exists): "+n.relative(e,a)),!1):(t.mkdirSync(n.dirname(a),{recursive:!0}),t.copyFileSync(p,a),r||f("Created: "+n.relative(e,a)),!0)}const u=n.join(c,"scripts","inferno-promote-draft.mjs"),g=n.join(e,"scripts","inferno-promote-draft.mjs");m(u,g),S(e,r,f);const i=n.join(e,".gitignore");t.existsSync(i)?t.readFileSync(i,"utf8").includes("CONTEXT.draft.md")?r||f(".gitignore already mentions CONTEXT.draft.md"):(t.appendFileSync(i,`
-${d}
-`,"utf8"),r||f("Updated: "+n.relative(e,i))):(t.writeFileSync(i,`${d}
-`,"utf8"),r||f("Created: "+n.relative(e,i)))}export{y as installInfernoDraftTooling};
+`.trimStart();
+
+function upsertPromoteScript(cwd, silent, logOk) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    if (!silent) logOk("No package.json — add script manually: inferno:promote-draft");
+    return;
+  }
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  pkg.scripts = pkg.scripts || {};
+  if (!pkg.scripts["inferno:promote-draft"]) {
+    pkg.scripts["inferno:promote-draft"] = "node scripts/inferno-promote-draft.mjs";
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    if (!silent) logOk("Updated package.json script: inferno:promote-draft");
+  }
+}
+
+/**
+ * inferno/CONTEXT.draft.md gitignore + promote script (shared by Cursor and VS Code installers).
+ * @param {object} opts
+ * @param {string} opts.cwd
+ * @param {string} opts.templatesRoot
+ * @param {boolean} opts.force
+ * @param {boolean} opts.silent
+ * @param {(msg: string) => void} [opts.logOk]
+ * @param {(msg: string) => void} [opts.logWarn]
+ */
+export function installInfernoDraftTooling(opts) {
+  const { cwd, templatesRoot, force, silent } = opts;
+  const logOk = opts.logOk || (() => {});
+  const logWarn = opts.logWarn || (() => {});
+
+  function copyFile(src, dst) {
+    if (fs.existsSync(dst) && !force) {
+      if (!silent) logWarn("Skipped (exists): " + path.relative(cwd, dst));
+      return false;
+    }
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.copyFileSync(src, dst);
+    if (!silent) logOk("Created: " + path.relative(cwd, dst));
+    return true;
+  }
+
+  const srcPromote = path.join(templatesRoot, "scripts", "inferno-promote-draft.mjs");
+  const dstPromote = path.join(cwd, "scripts", "inferno-promote-draft.mjs");
+  copyFile(srcPromote, dstPromote);
+
+  upsertPromoteScript(cwd, silent, logOk);
+
+  const gi = path.join(cwd, ".gitignore");
+  if (fs.existsSync(gi)) {
+    const cur = fs.readFileSync(gi, "utf8");
+    if (cur.includes("CONTEXT.draft.md")) {
+      if (!silent) logOk(".gitignore already mentions CONTEXT.draft.md");
+    } else {
+      fs.appendFileSync(gi, `\n${GITIGNORE_SNIPPET}\n`, "utf8");
+      if (!silent) logOk("Updated: " + path.relative(cwd, gi));
+    }
+  } else {
+    fs.writeFileSync(gi, `${GITIGNORE_SNIPPET}\n`, "utf8");
+    if (!silent) logOk("Created: " + path.relative(cwd, gi));
+  }
+}