infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/scout.mjs

@@ -1,2 +1,291 @@
-import*as l from"node:fs";import*as r from"node:path";import{done as w,warn as j,info as b,bold as h,cyan as _,gray as x,green as F,yellow as L}from"../ui/output.mjs";const C=[{name:"http-route",regex:/(?:app|router|server)\s*\.\s*(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi,extract:e=>({id:p(e[2],e[1]),hint:`${e[1].toUpperCase()} ${e[2]}`,confidence:.85})},{name:"api-file",filePattern:/[/\\](pages[/\\]api|app[/\\]api)[/\\](.+)\.(js|ts|mjs)$/,extract:e=>{const n=e.match(/[/\\](pages[/\\]api|app[/\\]api)[/\\](.+)\.(js|ts|mjs)$/);if(!n)return null;const t=n[2].replace(/[/\\]index$/,"").replace(/\[([^\]]+)\]/g,":$1");return{id:p("/"+t,"api"),hint:`Next.js API: /${t}`,confidence:.9}}},{name:"export",regex:/export\s+(?:async\s+)?(?:function|class|const|let)\s+([A-Z][A-Za-z0-9]+)/g,extract:e=>({id:m(e[1]),hint:`export ${e[1]}`,confidence:.65})},{name:"controller-method",regex:/^\s{2,}(?:async\s+)?([a-z][A-Za-z0-9]+)\s*[:(]/gm,extract:e=>({id:m(e[1]),hint:`method ${e[1]}`,confidence:.5}),minLen:5},{name:"graphql-resolver",regex:/['"`]?([A-Za-z][A-Za-z0-9]+)['"`]?\s*:\s*(?:async\s+)?\([^)]*\)\s*(?:=>|{)/g,extract:e=>({id:m(e[1]),hint:`resolver ${e[1]}`,confidence:.6})},{name:"python-route",regex:/(?:path|url|re_path)\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*([A-Za-z0-9_.]+)/g,extract:e=>({id:p(e[1],"view"),hint:`view ${e[2]} @ ${e[1]}`,confidence:.8})},{name:"rails-route",regex:/(?:get|post|put|patch|delete)\s+['"`]([^'"`]+)['"`]\s*,\s*to:\s*['"`]([^'"`]+)['"`]/g,extract:e=>({id:p(e[1],"rails"),hint:`Rails: ${e[2]}`,confidence:.8})}];function p(e,n){return e.replace(/^\//,"").replace(/\/:?[^/]+/g,"").replace(/\//g,"-").replace(/[^a-zA-Z0-9-]/g,"").replace(/-+/g,"-").replace(/^-|-$/g,"").toLowerCase()||n.toLowerCase()+"-root"}function m(e){return e.replace(/([A-Z])/g,"-$1").toLowerCase().replace(/^-/,"").replace(/-+/g,"-")}const Z=new Set([".js",".mjs",".cjs",".ts",".tsx",".jsx",".py",".rb"]),k=new Set(["node_modules",".git","dist","build",".next","__pycache__","vendor","coverage"]);function*I(e){if(!l.existsSync(e))return;const n=l.readdirSync(e,{withFileTypes:!0});for(const t of n){if(k.has(t.name))continue;const s=r.join(e,t.name);t.isDirectory()?yield*I(s):t.isFile()&&Z.has(r.extname(t.name))&&(yield s)}}function z(e){const n=[];for(const s of C)if(s.filePattern&&s.filePattern.test(e)){const i=s.extract(e);i&&n.push({...i,source:e,pattern:s.name})}let t;try{t=l.readFileSync(e,"utf8")}catch{return n}for(const s of C){if(!s.regex)continue;s.regex.lastIndex=0;let i;for(;(i=s.regex.exec(t))!==null;){const c=s.extract(i);c&&(s.minLen&&c.id.length<s.minLen||n.push({...c,source:e,pattern:s.name}))}}return n}function E(e){for(const n of["capabilities.json","contract.json"]){const t=r.join(e,n);if(l.existsSync(t))try{return{file:n,data:JSON.parse(l.readFileSync(t,"utf8"))}}catch{}}return null}function R(e){const n=e?.data?.capabilities||[];return new Set(n.map(t=>(typeof t=="string"?t:t.id||t.name||"").toLowerCase()))}function T(e){const n=new Map;for(const t of e){const s=t.id,i=n.get(s);(!i||t.confidence>i.confidence)&&n.set(s,t)}return[...n.values()].sort((t,s)=>s.confidence-t.confidence)}function D(e,n,t){const s=n.data.capabilities||[],i=[];for(const c of t){const d={id:c.id,description:c.hint,since:new Date().toISOString().slice(0,10),source:"scout"};s.push(d),i.push(c.id)}return n.data.capabilities=s,l.writeFileSync(r.join(e,n.file),JSON.stringify(n.data,null,2)+`
-`),i}async function U(e){const n=e.slice(1),t=n.includes("--json"),s=n.includes("--apply"),i=process.cwd(),c=r.join(i,"inferno");if(!l.existsSync(c)){const o="inferno/ not found. Run: infernoflow init";t?console.log(JSON.stringify({ok:!1,error:o})):j(o),process.exit(1)}const d=n.indexOf("--dir"),f=d!==-1?n[d+1].split(",").map(o=>r.resolve(i,o.trim())):["src","lib","app","api","pages","routes","controllers","handlers"].map(o=>r.join(i,o)).filter(l.existsSync),y=n.indexOf("--min-confidence"),N=y!==-1?parseFloat(n[y+1]):.6;if(!f.length){const o="No source directories found. Use --dir src,lib,api";t?console.log(JSON.stringify({ok:!1,error:o})):j(o),process.exit(1)}const u=E(c),v=R(u);t||(b(`Scanning ${f.map(o=>r.relative(i,o)).join(", ")} \u2026`),console.log());const $=[];for(const o of f)for(const g of I(o))$.push(...z(g));const a=T($).filter(o=>!v.has(o.id.toLowerCase())&&o.confidence>=N&&o.id.length>=3&&!["index","app","main","root","default","handler"].includes(o.id));if(t){console.log(JSON.stringify({ok:!0,found:a.length,candidates:a}));return}if(!a.length){w("No undocumented capabilities found \u2014 contract looks complete.");return}console.log(`  ${h(`${a.length} undocumented capability candidate${a.length!==1?"s":""} found`)}`),console.log();const S=Math.max(...a.map(o=>o.id.length),10)+2;for(const o of a){const g=`${Math.round(o.confidence*100)}%`,A=o.confidence>=.8?F:o.confidence>=.65?L:x,O=r.relative(i,o.source);console.log(`  ${h(o.id.padEnd(S))} ${A(g.padEnd(5))} ${x(o.hint)}`),console.log(`  ${" ".repeat(S+7)}${x(O)}`)}if(console.log(),s){const o=D(c,u,a);w(`Added ${h(String(o.length))} capabilities to ${u.file}`),console.log()}else b(`Run with ${_("--apply")} to add these to your contract.`),console.log()}export{U as scoutCommand};
+/**
+ * infernoflow scout
+ *
+ * Scans your source files for undocumented capabilities — functions, routes,
+ * exports, controllers — that exist in code but are missing from the contract.
+ *
+ * Smarter than --adopt: it reads your existing contract, diffs against what
+ * it finds in source, and only surfaces genuine gaps.
+ *
+ * Usage:
+ *   infernoflow scout                   Scan src/, lib/, app/ (auto-detected)
+ *   infernoflow scout --dir src,api     Custom scan directories
+ *   infernoflow scout --apply           Write discovered caps to capabilities.json
+ *   infernoflow scout --json            Machine-readable output
+ *   infernoflow scout --min-confidence 0.7   Only show high-confidence hits
+ *
+ * Output:
+ *   Lists undocumented capabilities with confidence score + source location.
+ *   With --apply, merges them into the contract file.
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { done, warn, info, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ── Pattern library ───────────────────────────────────────────────────────────
+
+const PATTERNS = [
+  // Express / Fastify / Hono routes
+  {
+    name: "http-route",
+    regex: /(?:app|router|server)\s*\.\s*(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+    extract: (m) => ({ id: routeToId(m[2], m[1]), hint: `${m[1].toUpperCase()} ${m[2]}`, confidence: 0.85 }),
+  },
+  // Next.js / Nuxt API route files  (path from filename)
+  {
+    name: "api-file",
+    filePattern: /[/\\](pages[/\\]api|app[/\\]api)[/\\](.+)\.(js|ts|mjs)$/,
+    extract: (filePath) => {
+      const m = filePath.match(/[/\\](pages[/\\]api|app[/\\]api)[/\\](.+)\.(js|ts|mjs)$/);
+      if (!m) return null;
+      const route = m[2].replace(/[/\\]index$/, "").replace(/\[([^\]]+)\]/g, ":$1");
+      return { id: routeToId("/" + route, "api"), hint: `Next.js API: /${route}`, confidence: 0.9 };
+    },
+  },
+  // Named exports (functions, classes, consts)
+  {
+    name: "export",
+    regex: /export\s+(?:async\s+)?(?:function|class|const|let)\s+([A-Z][A-Za-z0-9]+)/g,
+    extract: (m) => ({ id: camelToId(m[1]), hint: `export ${m[1]}`, confidence: 0.65 }),
+  },
+  // Default export object keys (controller-style)
+  {
+    name: "controller-method",
+    regex: /^\s{2,}(?:async\s+)?([a-z][A-Za-z0-9]+)\s*[:(]/gm,
+    extract: (m) => ({ id: camelToId(m[1]), hint: `method ${m[1]}`, confidence: 0.5 }),
+    minLen: 5,
+  },
+  // GraphQL resolver fields
+  {
+    name: "graphql-resolver",
+    regex: /['"`]?([A-Za-z][A-Za-z0-9]+)['"`]?\s*:\s*(?:async\s+)?\([^)]*\)\s*(?:=>|{)/g,
+    extract: (m) => ({ id: camelToId(m[1]), hint: `resolver ${m[1]}`, confidence: 0.6 }),
+  },
+  // Django / Flask URL patterns
+  {
+    name: "python-route",
+    regex: /(?:path|url|re_path)\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*([A-Za-z0-9_.]+)/g,
+    extract: (m) => ({ id: routeToId(m[1], "view"), hint: `view ${m[2]} @ ${m[1]}`, confidence: 0.8 }),
+  },
+  // Rails routes
+  {
+    name: "rails-route",
+    regex: /(?:get|post|put|patch|delete)\s+['"`]([^'"`]+)['"`]\s*,\s*to:\s*['"`]([^'"`]+)['"`]/g,
+    extract: (m) => ({ id: routeToId(m[1], "rails"), hint: `Rails: ${m[2]}`, confidence: 0.8 }),
+  },
+];
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function routeToId(route, method) {
+  return route
+    .replace(/^\//, "")
+    .replace(/\/:?[^/]+/g, "")    // strip params
+    .replace(/\//g, "-")
+    .replace(/[^a-zA-Z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .toLowerCase() || method.toLowerCase() + "-root";
+}
+
+function camelToId(name) {
+  return name
+    .replace(/([A-Z])/g, "-$1")
+    .toLowerCase()
+    .replace(/^-/, "")
+    .replace(/-+/g, "-");
+}
+
+// ── File scanner ──────────────────────────────────────────────────────────────
+
+const SOURCE_EXTENSIONS = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py", ".rb"]);
+const IGNORE_DIRS       = new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "vendor", "coverage"]);
+
+function* walkFiles(dir) {
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (IGNORE_DIRS.has(e.name)) continue;
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      yield* walkFiles(full);
+    } else if (e.isFile() && SOURCE_EXTENSIONS.has(path.extname(e.name))) {
+      yield full;
+    }
+  }
+}
+
+function scanFile(filePath) {
+  const hits = [];
+
+  // File-pattern rules (e.g. Next.js API files)
+  for (const pat of PATTERNS) {
+    if (pat.filePattern && pat.filePattern.test(filePath)) {
+      const result = pat.extract(filePath);
+      if (result) hits.push({ ...result, source: filePath, pattern: pat.name });
+    }
+  }
+
+  let content;
+  try { content = fs.readFileSync(filePath, "utf8"); } catch { return hits; }
+
+  for (const pat of PATTERNS) {
+    if (!pat.regex) continue;
+    pat.regex.lastIndex = 0;
+    let m;
+    while ((m = pat.regex.exec(content)) !== null) {
+      const result = pat.extract(m);
+      if (!result) continue;
+      if (pat.minLen && result.id.length < pat.minLen) continue;
+      hits.push({ ...result, source: filePath, pattern: pat.name });
+    }
+  }
+
+  return hits;
+}
+
+// ── Gap detection ─────────────────────────────────────────────────────────────
+
+function readContract(infernoDir) {
+  for (const f of ["capabilities.json", "contract.json"]) {
+    const p = path.join(infernoDir, f);
+    if (!fs.existsSync(p)) continue;
+    try { return { file: f, data: JSON.parse(fs.readFileSync(p, "utf8")) }; } catch {}
+  }
+  return null;
+}
+
+function getKnownIds(contract) {
+  const caps = contract?.data?.capabilities || [];
+  return new Set(caps.map(c => (typeof c === "string" ? c : c.id || c.name || "").toLowerCase()));
+}
+
+function dedupeHits(hits) {
+  const seen = new Map();
+  for (const h of hits) {
+    const key = h.id;
+    const existing = seen.get(key);
+    if (!existing || h.confidence > existing.confidence) {
+      seen.set(key, h);
+    }
+  }
+  return [...seen.values()].sort((a, b) => b.confidence - a.confidence);
+}
+
+// ── Apply ─────────────────────────────────────────────────────────────────────
+
+function applyToContract(infernoDir, contract, newCaps) {
+  const caps    = contract.data.capabilities || [];
+  const added   = [];
+
+  for (const cap of newCaps) {
+    const entry = {
+      id:          cap.id,
+      description: cap.hint,
+      since:       new Date().toISOString().slice(0, 10),
+      source:      "scout",
+    };
+    caps.push(entry);
+    added.push(cap.id);
+  }
+
+  contract.data.capabilities = caps;
+  fs.writeFileSync(
+    path.join(infernoDir, contract.file),
+    JSON.stringify(contract.data, null, 2) + "\n"
+  );
+  return added;
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function scoutCommand(rawArgs) {
+  const args      = rawArgs.slice(1);
+  const jsonMode  = args.includes("--json");
+  const apply     = args.includes("--apply");
+  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);
+  }
+
+  // Parse --dir flag
+  const dirIdx = args.indexOf("--dir");
+  const scanDirs = dirIdx !== -1
+    ? args[dirIdx + 1].split(",").map(d => path.resolve(cwd, d.trim()))
+    : ["src", "lib", "app", "api", "pages", "routes", "controllers", "handlers"]
+        .map(d => path.join(cwd, d))
+        .filter(fs.existsSync);
+
+  // Parse --min-confidence
+  const confIdx     = args.indexOf("--min-confidence");
+  const minConfidence = confIdx !== -1 ? parseFloat(args[confIdx + 1]) : 0.6;
+
+  if (!scanDirs.length) {
+    const msg = "No source directories found. Use --dir src,lib,api";
+    if (jsonMode) console.log(JSON.stringify({ ok: false, error: msg }));
+    else warn(msg);
+    process.exit(1);
+  }
+
+  const contract = readContract(infernoDir);
+  const knownIds = getKnownIds(contract);
+
+  if (!jsonMode) {
+    info(`Scanning ${scanDirs.map(d => path.relative(cwd, d)).join(", ")} …`);
+    console.log();
+  }
+
+  // Collect hits from all source dirs
+  const allHits = [];
+  for (const dir of scanDirs) {
+    for (const file of walkFiles(dir)) {
+      allHits.push(...scanFile(file));
+    }
+  }
+
+  // Filter: unknown, above confidence threshold, non-trivial id
+  const candidates = dedupeHits(allHits).filter(h =>
+    !knownIds.has(h.id.toLowerCase()) &&
+    h.confidence >= minConfidence &&
+    h.id.length >= 3 &&
+    !["index", "app", "main", "root", "default", "handler"].includes(h.id)
+  );
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, found: candidates.length, candidates }));
+    return;
+  }
+
+  if (!candidates.length) {
+    done("No undocumented capabilities found — contract looks complete.");
+    return;
+  }
+
+  console.log(`  ${bold(`${candidates.length} undocumented capability candidate${candidates.length !== 1 ? "s" : ""} found`)}`);
+  console.log();
+
+  const w = Math.max(...candidates.map(c => c.id.length), 10) + 2;
+  for (const c of candidates) {
+    const confStr  = `${Math.round(c.confidence * 100)}%`;
+    const confColor = c.confidence >= 0.8 ? green : c.confidence >= 0.65 ? yellow : gray;
+    const rel      = path.relative(cwd, c.source);
+    console.log(`  ${bold(c.id.padEnd(w))} ${confColor(confStr.padEnd(5))} ${gray(c.hint)}`);
+    console.log(`  ${" ".repeat(w + 7)}${gray(rel)}`);
+  }
+  console.log();
+
+  if (apply) {
+    const added = applyToContract(infernoDir, contract, candidates);
+    done(`Added ${bold(String(added.length))} capabilities to ${contract.file}`);
+    console.log();
+  } else {
+    info(`Run with ${cyan("--apply")} to add these to your contract.`);
+    console.log();
+  }
+}

package/dist/lib/commands/setup.mjs

@@ -1,5 +1,310 @@
-import*as n from"node:fs";import*as r from"node:path";import*as $ from"node:os";import{fileURLToPath as x}from"node:url";import{execSync as M}from"node:child_process";import{detectIdeContext as b}from"../ai/ideDetection.mjs";import{header as F,ok as p,warn as m,info as j,done as A,cyan as D,yellow as L,bold as S,green as h}from"../ui/output.mjs";import{installCursorHooksArtifacts as T}from"../cursorHooksInstall.mjs";import{installVsCodeCopilotHooksArtifacts as J}from"../vsCodeCopilotHooksInstall.mjs";import{writeClaudeMd as O}from"./claudeMd.mjs";const P=r.dirname(x(import.meta.url));function I(){return r.resolve(P,"../../templates")}function N(s){try{return M(`npx infernoflow ${s}`,{encoding:"utf8",cwd:process.cwd(),timeout:6e4,stdio:["inherit","pipe","pipe"]})}catch(t){return t.stdout||t.stderr||t.message}}const _=["infernoflow_status","infernoflow_run","infernoflow_suggest","infernoflow_check","infernoflow_context","infernoflow_implement","infernoflow_git_drift","infernoflow_scan_ui","infernoflow_review","infernoflow_synthesize","infernoflow_agent_list","infernoflow_agent_run","infernoflow_version"];function R(s,t,i){const c=r.join(s,".git"),e=r.join(c,"hooks");if(!n.existsSync(c))return{skipped:!0,reason:"no .git directory"};n.mkdirSync(e,{recursive:!0});const l=["post-commit","pre-push"],d=[];for(const a of l){const f=r.join(t,"git-hooks",a),u=r.join(e,a);if(n.existsSync(f))if(n.existsSync(u)&&!i){if(!n.readFileSync(u,"utf8").includes("# infernoflow")){const w=n.readFileSync(f,"utf8");n.appendFileSync(u,`
-${w}`),d.push(`${a} (appended)`)}}else{n.copyFileSync(f,u);try{n.chmodSync(u,493)}catch{}d.push(a)}}return{skipped:!1,installed:d}}function U(s,t,i){const c=r.join($.homedir(),".claude.json");let e={};if(n.existsSync(c))try{const g=n.readFileSync(c,"utf8").replace(/\u0000+/g,"");e=JSON.parse(g)}catch{e={}}let l=!1;e.mcpServers||(e.mcpServers={});const d=e.mcpServers.infernoflow;(!d||!d.args||d.args[0]!==s)&&(e.mcpServers.infernoflow={command:"node",args:[s]},l=!0),e.projects||(e.projects={}),e.projects[t]||(e.projects[t]={});const a=e.projects[t],f=new Set(a.allowedTools||[]),u=f.size;for(const g of i)f.add(g);(f.size!==u||a.allowedTools===void 0)&&(a.allowedTools=[...f],l=!0);const y=JSON.stringify(e,null,2).replace(/\u0000+/g,"");return n.writeFileSync(c,y,"utf8"),{changed:l,mcpUpdated:!d||d.args[0]!==s}}function z(s,t){const i=r.join(s,".claude"),c=r.join(i,"settings.json");let e={};if(n.existsSync(c))try{e=JSON.parse(n.readFileSync(c,"utf8"))}catch{e={}}const l=new Set(e.allowedTools||[]);for(const a of _)l.add(`mcp__infernoflow__${a}`);const d={...e,allowedTools:[...l]};return n.mkdirSync(i,{recursive:!0}),n.writeFileSync(c,JSON.stringify(d,null,2),"utf8"),c}async function q(s){const t=process.cwd(),i=s.includes("--force")||s.includes("-f"),c=s.includes("--yes")||s.includes("-y"),e=I();F("infernoflow setup");const{ideDetected:l}=b("auto");j(`IDE detected: ${S(l==="cursor"?"Cursor":l==="vscode"?"VS Code":l==="windsurf"?"Windsurf":"unknown")}`);const a=r.join(t,"inferno"),f=r.join(a,"contract.json");if(n.existsSync(f))p("inferno/contract.json already exists \u2014 skipping init");else{console.log(`
-  ${L("inferno/")} not found \u2014 running init --adopt ...
-`);const o=["--adopt",c?"--yes":""].filter(Boolean).join(" ");N(`init ${o}`)}const u=o=>p(o),y=o=>m(o);T({cwd:t,templatesRoot:e,force:i,silent:!1,logOk:u,logWarn:y});const g=r.join(e,"cursor","inferno-mcp-server.mjs"),w=r.join(t,".cursor","inferno-mcp-server.mjs");(!n.existsSync(w)||i)&&(n.mkdirSync(r.dirname(w),{recursive:!0}),n.copyFileSync(g,w),p("Copied MCP server \u2192 .cursor/inferno-mcp-server.mjs")),l==="vscode"&&J({cwd:t,templatesRoot:e,force:i,silent:!1,logOk:u,logWarn:y}),console.log(),j("Configuring Claude Code (VS Code extension)...");const v=w,C=_.map(o=>`mcp__infernoflow__${o}`);try{U(v,t,C).mcpUpdated?p("~/.claude.json \u2192 MCP server registered"):p("~/.claude.json \u2192 MCP server already registered"),p(`~/.claude.json \u2192 ${C.length} infernoflow tools pre-approved for this project`)}catch(o){m(`Could not update ~/.claude.json: ${o.message}`),m(`Add manually: ${D('"mcpServers": { "infernoflow": { "command": "node", "args": ["'+v+'"] } }')}`)}try{z(t,i),p(".claude/settings.json \u2192 tools pre-approved (CLI fallback)")}catch(o){m(`Could not write .claude/settings.json: ${o.message}`)}console.log(),j("Installing invisible AI behavior layer...");try{const o=O(t,a,{force:i});p(`CLAUDE.md \u2192 ${o.action} (auto-behavior instructions for Claude)`)}catch(o){m(`Could not write CLAUDE.md: ${o.message}`)}try{const o=R(t,e,i);o.skipped?m(`Git hooks skipped: ${o.reason}`):o.installed.length>0?p(`Git hooks \u2192 ${o.installed.join(", ")} installed`):p("Git hooks \u2192 already installed (use --force to overwrite)")}catch(o){m(`Could not install git hooks: ${o.message}`)}let k=0;try{k=(JSON.parse(n.readFileSync(f,"utf8")).capabilities||[]).length}catch{}console.log(),A(k>0?`infernoflow ready \u2014 ${k} capabilities tracked`:"infernoflow ready"),console.log(`
-  ${S("What was set up:")}`),console.log(`    ${h("\u2714")} MCP server \u2192 .cursor/inferno-mcp-server.mjs`),console.log(`    ${h("\u2714")} ~/.claude.json \u2192 MCP registered + ${C.length} tools pre-approved (no prompts)`),console.log(`    ${h("\u2714")} .claude/settings.json \u2192 CLI fallback approvals`),console.log(`    ${h("\u2714")} CLAUDE.md \u2192 Claude auto-calls infernoflow silently every session`),console.log(`    ${h("\u2714")} Git hooks \u2192 post-commit (changelog) + pre-push (drift check)`),console.log(),console.log(`  ${S("You're done.")} Just write code \u2014 infernoflow handles itself.`),console.log("  Claude automatically tracks capabilities, updates the contract,"),console.log("  and synthesizes agents from your workflow patterns."),console.log(),console.log(`  ${S("Restart VS Code")} to activate the MCP server.`),console.log()}export{q as setupCommand};
+/**
+ * infernoflow setup
+ * One command that gets a project fully operational:
+ *   1. Detects IDE (Cursor / VS Code / other)
+ *   2. Runs `infernoflow init --adopt` if inferno/ doesn't exist yet
+ *   3. Copies MCP server + hooks
+ *   4. Auto-updates ~/.claude.json for Claude Code (VS Code extension):
+ *      - Registers MCP server under mcpServers.infernoflow
+ *      - Pre-approves all tools under projects[cwd].allowedTools  ← kills prompts
+ *   5. Writes .claude/settings.json with pre-approved tools (CLI fallback)
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as os   from "node:os";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { detectIdeContext } from "../ai/ideDetection.mjs";
+import { header, ok, warn, info, done, cyan, yellow, bold, green } from "../ui/output.mjs";
+import { installCursorHooksArtifacts } from "../cursorHooksInstall.mjs";
+import { installVsCodeCopilotHooksArtifacts } from "../vsCodeCopilotHooksInstall.mjs";
+import { writeClaudeMd } from "./claudeMd.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getTemplatesRoot() {
+  return path.resolve(__dirname, "../../templates");
+}
+
+function runInferno(args) {
+  try {
+    return execSync(`npx infernoflow ${args}`, {
+      encoding: "utf8",
+      cwd: process.cwd(),
+      timeout: 60_000,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+  } catch (err) {
+    return err.stdout || err.stderr || err.message;
+  }
+}
+
+// ── MCP tool names (must match inferno-mcp-server.mjs) ───────────────────────
+const MCP_TOOLS = [
+  "infernoflow_status",
+  "infernoflow_run",
+  "infernoflow_suggest",
+  "infernoflow_check",
+  "infernoflow_context",
+  "infernoflow_implement",
+  "infernoflow_git_drift",
+  "infernoflow_scan_ui",
+  "infernoflow_review",
+  "infernoflow_synthesize",
+  "infernoflow_agent_list",
+  "infernoflow_agent_run",
+  "infernoflow_version",
+];
+
+// ── Git hooks installer ───────────────────────────────────────────────────────
+function installGitHooks(cwd, templatesRoot, force) {
+  const gitDir  = path.join(cwd, ".git");
+  const hooksDir = path.join(gitDir, "hooks");
+
+  if (!fs.existsSync(gitDir)) {
+    return { skipped: true, reason: "no .git directory" };
+  }
+
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  const hooks = ["post-commit", "pre-push"];
+  const installed = [];
+
+  for (const hookName of hooks) {
+    const src = path.join(templatesRoot, "git-hooks", hookName);
+    const dst = path.join(hooksDir, hookName);
+
+    if (!fs.existsSync(src)) continue;
+
+    if (fs.existsSync(dst) && !force) {
+      // Append our hook to existing one rather than overwriting
+      const existing = fs.readFileSync(dst, "utf8");
+      const marker = "# infernoflow";
+      if (!existing.includes(marker)) {
+        const hookContent = fs.readFileSync(src, "utf8");
+        // Append the infernoflow block after the existing content
+        fs.appendFileSync(dst, `\n${hookContent}`);
+        installed.push(`${hookName} (appended)`);
+      }
+      // Already has infernoflow — skip silently
+    } else {
+      fs.copyFileSync(src, dst);
+      // Make executable
+      try { fs.chmodSync(dst, 0o755); } catch {}
+      installed.push(hookName);
+    }
+  }
+
+  return { skipped: false, installed };
+}
+
+// ── ~/.claude.json updater (Claude Code for VS Code) ─────────────────────────
+//
+// Claude Code VS Code stores two kinds of data in ~/.claude.json:
+//   mcpServers           → global MCP server registry
+//   projects[path]       → per-project settings incl. allowedTools
+//
+// Writing allowedTools under projects[cwd] is the same thing the extension
+// does when you click "Yes, allow for this project" — so setup pre-fills it.
+//
+function updateClaudeJson(mcpServerAbsPath, projectPath, allowedToolNames) {
+  const claudeJsonPath = path.join(os.homedir(), ".claude.json");
+
+  let config = {};
+  if (fs.existsSync(claudeJsonPath)) {
+    try {
+      const raw = fs.readFileSync(claudeJsonPath, "utf8").replace(/\u0000+/g, "");
+      config = JSON.parse(raw);
+    } catch { config = {}; }
+  }
+
+  let changed = false;
+
+  // ── 1. MCP server registration ────────────────────────────────────────────
+  if (!config.mcpServers) config.mcpServers = {};
+  const existingSrv = config.mcpServers.infernoflow;
+  if (!existingSrv || !existingSrv.args || existingSrv.args[0] !== mcpServerAbsPath) {
+    config.mcpServers.infernoflow = { command: "node", args: [mcpServerAbsPath] };
+    changed = true;
+  }
+
+  // ── 2. Per-project tool approvals ─────────────────────────────────────────
+  // This mirrors exactly what Claude Code writes when user clicks
+  // "Yes, allow <tool> for this project (just you)".
+  if (!config.projects) config.projects = {};
+  if (!config.projects[projectPath]) config.projects[projectPath] = {};
+
+  const proj = config.projects[projectPath];
+  const existingAllowed = new Set(proj.allowedTools || []);
+  const sizeBefore = existingAllowed.size;
+  for (const name of allowedToolNames) existingAllowed.add(name);
+
+  if (existingAllowed.size !== sizeBefore || proj.allowedTools === undefined) {
+    proj.allowedTools = [...existingAllowed];
+    changed = true;
+  }
+
+  // Strip null bytes before writing (Windows artifact)
+  const content = JSON.stringify(config, null, 2).replace(/\u0000+/g, "");
+  fs.writeFileSync(claudeJsonPath, content, "utf8");
+  return { changed, mcpUpdated: !existingSrv || existingSrv.args[0] !== mcpServerAbsPath };
+}
+
+// ── .claude/settings.json (auto-approve tools) ───────────────────────────────
+function writeClaudeSettings(cwd, force) {
+  const settingsDir  = path.join(cwd, ".claude");
+  const settingsPath = path.join(settingsDir, "settings.json");
+
+  let existing = {};
+  if (fs.existsSync(settingsPath)) {
+    try { existing = JSON.parse(fs.readFileSync(settingsPath, "utf8")); }
+    catch { existing = {}; }
+  }
+
+  // Build allowedTools — add infernoflow tools, keep any existing entries
+  const existingAllowed = new Set(existing.allowedTools || []);
+  for (const tool of MCP_TOOLS) {
+    existingAllowed.add(`mcp__infernoflow__${tool}`);
+  }
+
+  const updated = { ...existing, allowedTools: [...existingAllowed] };
+
+  // Also keep mcpServers if it was in the project settings
+  fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(updated, null, 2), "utf8");
+  return settingsPath;
+}
+
+// ── main ─────────────────────────────────────────────────────────────────────
+
+export async function setupCommand(args) {
+  const cwd          = process.cwd();
+  const force        = args.includes("--force") || args.includes("-f");
+  const yes          = args.includes("--yes")   || args.includes("-y");
+  const templatesRoot = getTemplatesRoot();
+
+  header("infernoflow setup");
+
+  // ── 1. Detect IDE ─────────────────────────────────────────────────────────
+  const { ideDetected } = detectIdeContext("auto");
+  const ideLabel = ideDetected === "cursor"   ? "Cursor"
+                 : ideDetected === "vscode"   ? "VS Code"
+                 : ideDetected === "windsurf" ? "Windsurf"
+                 : "unknown";
+
+  info(`IDE detected: ${bold(ideLabel)}`);
+
+  // ── 2. Init if needed ─────────────────────────────────────────────────────
+  const infernoDir   = path.join(cwd, "inferno");
+  const contractPath = path.join(infernoDir, "contract.json");
+
+  if (!fs.existsSync(contractPath)) {
+    console.log(`\n  ${yellow("inferno/")} not found — running init --adopt ...\n`);
+    const initArgs = ["--adopt", yes ? "--yes" : ""].filter(Boolean).join(" ");
+    runInferno(`init ${initArgs}`);
+  } else {
+    ok("inferno/contract.json already exists — skipping init");
+  }
+
+  // ── 3. Install hooks + MCP server file ───────────────────────────────────
+  const logOk   = (msg) => ok(msg);
+  const logWarn = (msg) => warn(msg);
+
+  // Always install Cursor artifacts (MCP server works for both Cursor + VS Code)
+  installCursorHooksArtifacts({ cwd, templatesRoot, force, silent: false, logOk, logWarn });
+
+  // Also copy MCP server into .cursor/ so it's findable by absolute path
+  const srcMcp = path.join(templatesRoot, "cursor", "inferno-mcp-server.mjs");
+  const dstMcp = path.join(cwd, ".cursor", "inferno-mcp-server.mjs");
+  if (!fs.existsSync(dstMcp) || force) {
+    fs.mkdirSync(path.dirname(dstMcp), { recursive: true });
+    fs.copyFileSync(srcMcp, dstMcp);
+    ok("Copied MCP server → .cursor/inferno-mcp-server.mjs");
+  }
+
+  if (ideDetected === "vscode") {
+    installVsCodeCopilotHooksArtifacts({ cwd, templatesRoot, force, silent: false, logOk, logWarn });
+  }
+
+  // ── 4. Auto-update ~/.claude.json for Claude Code VS Code ────────────────
+  console.log();
+  info("Configuring Claude Code (VS Code extension)...");
+
+  const mcpAbsPath    = dstMcp;  // absolute path to .cursor/inferno-mcp-server.mjs
+  const allowedTools  = MCP_TOOLS.map(t => `mcp__infernoflow__${t}`);
+
+  try {
+    const result = updateClaudeJson(mcpAbsPath, cwd, allowedTools);
+    if (result.mcpUpdated) {
+      ok(`~/.claude.json → MCP server registered`);
+    } else {
+      ok(`~/.claude.json → MCP server already registered`);
+    }
+    ok(`~/.claude.json → ${allowedTools.length} infernoflow tools pre-approved for this project`);
+  } catch (err) {
+    warn(`Could not update ~/.claude.json: ${err.message}`);
+    warn(`Add manually: ${cyan('"mcpServers": { "infernoflow": { "command": "node", "args": ["' + mcpAbsPath + '"] } }')}`);
+  }
+
+  // ── 5. Write .claude/settings.json (CLI / non-interactive fallback) ───────
+  try {
+    writeClaudeSettings(cwd, force);
+    ok(`.claude/settings.json → tools pre-approved (CLI fallback)`);
+  } catch (err) {
+    warn(`Could not write .claude/settings.json: ${err.message}`);
+  }
+
+  // ── 6. Generate CLAUDE.md (invisible instruction layer) ──────────────────
+  console.log();
+  info("Installing invisible AI behavior layer...");
+  try {
+    const claudeMdResult = writeClaudeMd(cwd, infernoDir, { force });
+    ok(`CLAUDE.md → ${claudeMdResult.action} (auto-behavior instructions for Claude)`);
+  } catch (err) {
+    warn(`Could not write CLAUDE.md: ${err.message}`);
+  }
+
+  // ── 7. Install git hooks ──────────────────────────────────────────────────
+  try {
+    const hooksResult = installGitHooks(cwd, templatesRoot, force);
+    if (hooksResult.skipped) {
+      warn(`Git hooks skipped: ${hooksResult.reason}`);
+    } else if (hooksResult.installed.length > 0) {
+      ok(`Git hooks → ${hooksResult.installed.join(", ")} installed`);
+    } else {
+      ok(`Git hooks → already installed (use --force to overwrite)`);
+    }
+  } catch (err) {
+    warn(`Could not install git hooks: ${err.message}`);
+  }
+
+  // ── 8. Verify contract ────────────────────────────────────────────────────
+  let capCount = 0;
+  try {
+    const contract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
+    capCount = (contract.capabilities || []).length;
+  } catch {}
+
+  // ── 9. Summary ────────────────────────────────────────────────────────────
+  console.log();
+  done(
+    capCount > 0
+      ? `infernoflow ready — ${capCount} capabilities tracked`
+      : `infernoflow ready`
+  );
+
+  console.log(`\n  ${bold("What was set up:")}`);
+  console.log(`    ${green("✔")} MCP server → .cursor/inferno-mcp-server.mjs`);
+  console.log(`    ${green("✔")} ~/.claude.json → MCP registered + ${allowedTools.length} tools pre-approved (no prompts)`);
+  console.log(`    ${green("✔")} .claude/settings.json → CLI fallback approvals`);
+  console.log(`    ${green("✔")} CLAUDE.md → Claude auto-calls infernoflow silently every session`);
+  console.log(`    ${green("✔")} Git hooks → post-commit (changelog) + pre-push (drift check)`);
+  console.log();
+  console.log(`  ${bold("You're done.")} Just write code — infernoflow handles itself.`);
+  console.log(`  Claude automatically tracks capabilities, updates the contract,`);
+  console.log(`  and synthesizes agents from your workflow patterns.`);
+  console.log();
+  console.log(`  ${bold("Restart VS Code")} to activate the MCP server.`);
+  console.log();
+}