infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/init.mjs

@@ -1,30 +1,552 @@
-import*as r from"node:fs";import*as t from"node:path";import*as G from"node:readline";import{fileURLToPath as ne}from"node:url";import{header as oe,ok as d,warn as $,done as D,nextSteps as ie,cyan as l,yellow as N,gray as S}from"../ui/output.mjs";import{discoverProjectSignals as I,reviewCapabilitiesInteractive as te,writeAdoptionBaseline as se,buildAdoptionReport as re,summarizeCapabilities as ae,buildSignalsReport as ce}from"./adopt.mjs";import{installCursorHooksArtifacts as le}from"../cursorHooksInstall.mjs";import{installVsCodeCopilotHooksArtifacts as pe}from"../vsCodeCopilotHooksInstall.mjs";const fe=t.dirname(ne(import.meta.url));function de(){return t.resolve(fe,"../../templates")}function P(e,n,i=""){return new Promise(s=>{const u=i?S(` (${i})`):"";e.question(`  ${n}${u}: `,y=>{s(y.trim()||i)})})}function J(e,...n){for(const i of n){const s=e.indexOf(i);if(s!==-1&&e[s+1]&&!e[s+1].startsWith("-"))return e[s+1]}return null}function T(e,n,i,s=!1){return r.existsSync(n)&&!i?(s||$("Skipped (exists): "+t.relative(process.cwd(),n)),!1):(r.mkdirSync(t.dirname(n),{recursive:!0}),r.copyFileSync(e,n),s||d("Created: "+l(t.relative(process.cwd(),n))),!0)}function ue(e,n,i){r.mkdirSync(n,{recursive:!0});for(const s of r.readdirSync(e,{withFileTypes:!0})){const u=t.join(e,s.name),y=t.join(n,s.name);s.isDirectory()?ue(u,y,i):T(u,y,i)}}function me(e,n=!1){const i=t.join(e,"package.json");if(!r.existsSync(i))return;const s=JSON.parse(r.readFileSync(i,"utf8"));s.scripts=s.scripts||{};let u=!1;const y={"inferno:check":"infernoflow check","inferno:status":"infernoflow status","inferno:gate":"infernoflow doc-gate","inferno:impact":"infernoflow pr-impact --json","inferno:sync":"infernoflow sync --auto --json","inferno:run":'infernoflow run "sync check" --provider auto --json',"inferno:hooks":"node scripts/inferno-install-hooks.mjs"};for(const[g,v]of Object.entries(y))s.scripts[g]||(s.scripts[g]=v,u=!0);u&&(r.writeFileSync(i,JSON.stringify(s,null,2)+`
-`,"utf8"),n||d("Updated "+l("package.json")+" scripts"))}function U(e){const n=t.join(e,"package.json");if(r.existsSync(n))try{const i=JSON.parse(r.readFileSync(n,"utf8"));if(i.name)return i.name.replace(/[^a-z0-9_-]/gi,"_")}catch{}return t.basename(e)}function ye(e,n,i){const s={policyId:n,policyVersion:1,capabilities:i,rules:{docsRequiredOnCapabilityChange:!0,requireScenarioForEachCapability:!0,requireChangelogOnCapabilityChange:!0}};r.writeFileSync(e,JSON.stringify(s,null,2)+`
-`)}function ge(e,n){const i={schemaVersion:1,capabilities:n.map(s=>({id:s,title:s.replace(/([A-Z])/g," $1").trim(),since:"0.1.0"}))};r.writeFileSync(e,JSON.stringify(i,null,2)+`
-`)}function we(e,n){r.mkdirSync(e,{recursive:!0});const i={scenarioId:"happy_path",description:"Basic happy-path flow covering all capabilities",capabilitiesCovered:n,steps:n.map(s=>({action:s,expect:`${s} works as expected`}))};r.writeFileSync(t.join(e,"happy_path.json"),JSON.stringify(i,null,2)+`
-`)}function K(e,n){const i=`# Changelog \u2014 ${n}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { fileURLToPath } from "node:url";
+import { header, ok, warn, done, nextSteps, cyan, yellow, gray } from "../ui/output.mjs";
+import {
+  discoverProjectSignals,
+  reviewCapabilitiesInteractive,
+  writeAdoptionBaseline,
+  buildAdoptionReport,
+  summarizeCapabilities,
+  buildSignalsReport,
+} from "./adopt.mjs";
+import { installCursorHooksArtifacts } from "../cursorHooksInstall.mjs";
+import { installVsCodeCopilotHooksArtifacts } from "../vsCodeCopilotHooksInstall.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getTemplatesRoot() {
+  return path.resolve(__dirname, "../../templates");
+}
+
+function ask(rl, question, defaultVal = "") {
+  return new Promise(resolve => {
+    const hint = defaultVal ? gray(` (${defaultVal})`) : "";
+    rl.question(`  ${question}${hint}: `, answer => {
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+function getArgValue(args, ...flags) {
+  for (const flag of flags) {
+    const i = args.indexOf(flag);
+    if (i !== -1 && args[i + 1] && !args[i + 1].startsWith("-")) return args[i + 1];
+  }
+  return null;
+}
+
+function copyFile(src, dst, force, silent = false) {
+  if (fs.existsSync(dst) && !force) {
+    if (!silent) warn("Skipped (exists): " + path.relative(process.cwd(), dst));
+    return false;
+  }
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  fs.copyFileSync(src, dst);
+  if (!silent) ok("Created: " + cyan(path.relative(process.cwd(), dst)));
+  return true;
+}
+
+function copyDirDeep(srcDir, dstDir, force) {
+  fs.mkdirSync(dstDir, { recursive: true });
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const src = path.join(srcDir, entry.name);
+    const dst = path.join(dstDir, entry.name);
+    if (entry.isDirectory()) copyDirDeep(src, dst, force);
+    else copyFile(src, dst, force);
+  }
+}
+
+function upsertScripts(cwd, silent = false) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return;
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  pkg.scripts = pkg.scripts || {};
+  let changed = false;
+  const toAdd = {
+    "inferno:check":  "infernoflow check",
+    "inferno:status": "infernoflow status",
+    "inferno:gate":   "infernoflow doc-gate",
+    "inferno:impact": "infernoflow pr-impact --json",
+    "inferno:sync":   "infernoflow sync --auto --json",
+    "inferno:run":    "infernoflow run \"sync check\" --provider auto --json",
+    "inferno:hooks":  "node scripts/inferno-install-hooks.mjs"
+  };
+  for (const [k, v] of Object.entries(toAdd)) {
+    if (!pkg.scripts[k]) { pkg.scripts[k] = v; changed = true; }
+  }
+  if (changed) {
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    if (!silent) ok("Updated " + cyan("package.json") + " scripts");
+  }
+}
+
+function detectProjectName(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.name) return pkg.name.replace(/[^a-z0-9_-]/gi, "_");
+    } catch {}
+  }
+  return path.basename(cwd);
+}
+
+function writeContract(contractPath, policyId, capabilities) {
+  const contract = {
+    policyId,
+    policyVersion: 1,
+    capabilities,
+    rules: {
+      docsRequiredOnCapabilityChange: true,
+      requireScenarioForEachCapability: true,
+      requireChangelogOnCapabilityChange: true
+    }
+  };
+  fs.writeFileSync(contractPath, JSON.stringify(contract, null, 2) + "\n");
+}
+
+function writeCapabilities(capsPath, capabilities) {
+  const registry = {
+    schemaVersion: 1,
+    capabilities: capabilities.map(id => ({
+      id,
+      title: id.replace(/([A-Z])/g, " $1").trim(),
+      since: "0.1.0"
+    }))
+  };
+  fs.writeFileSync(capsPath, JSON.stringify(registry, null, 2) + "\n");
+}
+
+function writeScenario(scenariosDir, capabilities) {
+  fs.mkdirSync(scenariosDir, { recursive: true });
+  const scenario = {
+    scenarioId: "happy_path",
+    description: "Basic happy-path flow covering all capabilities",
+    capabilitiesCovered: capabilities,
+    steps: capabilities.map(c => ({
+      action: c,
+      expect: `${c} works as expected`
+    }))
+  };
+  fs.writeFileSync(
+    path.join(scenariosDir, "happy_path.json"),
+    JSON.stringify(scenario, null, 2) + "\n"
+  );
+}
+
+function writeChangelog(changelogPath, policyId) {
+  const content = `# Changelog — ${policyId}
 
 ## Unreleased
 
 - Initial capabilities defined
 
-## 0.1.0 \u2014 Initial release
+## 0.1.0 — Initial release
 
 - Project initialized with infernoflow
-`;r.writeFileSync(e,i)}async function Ce(e){const n=process.cwd(),i=e.includes("--force")||e.includes("-f"),s=e.includes("--yes")||e.includes("-y"),u=e.includes("--adopt"),y=e.indexOf("--template"),g=y!==-1?e[y+1]:null;if(g){let a;try{a=await import("../templates/index.mjs")}catch{}const o=a?.getTemplate(g);if(!o){const c=a?a.listTemplates().map(j=>j.name).join(", "):"rest-api, nextjs, cli, graphql, monorepo";$(`Unknown template: ${g}. Available: ${c}`),process.exit(1)}const f=t.join(n,"inferno"),h=t.join(f,"scenarios");r.existsSync(f)||r.mkdirSync(f,{recursive:!0}),r.existsSync(h)||r.mkdirSync(h,{recursive:!0});const x=U(n),m=o.capabilities;r.writeFileSync(t.join(f,"contract.json"),JSON.stringify({policyId:x,policyVersion:1,capabilities:m.map(c=>c.id)},null,2)+`
-`),r.writeFileSync(t.join(f,"capabilities.json"),JSON.stringify({capabilities:m.map(c=>({id:c.id,description:c.description,since:new Date().toISOString().slice(0,10),source:`template:${g}`}))},null,2)+`
-`);for(const c of m)r.writeFileSync(t.join(h,`${c.id}.json`),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)+`
-`);K(t.join(f,"CHANGELOG.md"),x),r.writeFileSync(t.join(f,"CONTEXT.md"),`# ${x} \u2014 infernoflow context
-
-> Template: ${g} \u2014 ${o.description}
-
-## Hint
-${o.contextHint}
-
-## Capabilities (${m.length})
-${m.map(c=>`- \`${c.id}\`: ${c.description}`).join(`
-`)}
-`),o.scripts&&(info("Suggested package.json scripts for this template:"),Object.entries(o.scripts).forEach(([c,j])=>console.log(`  ${bold(c)}: ${S(j)}`)),console.log()),D(`Initialised from template ${bold(l(g))} \u2014 ${bold(String(m.length))} capabilities`),console.log(),info(`Run ${l("infernoflow vibe")} to start vibe coding mode`),console.log();return}const v=e.includes("--cursor-hooks"),E=e.includes("--vscode-copilot-hooks"),q=e.includes("--report-json"),A=e.includes("--report-json-only"),H=e.includes("--report-human-only"),F=J(e,"--lang"),_=J(e,"--framework"),R=J(e,"--project-type"),p=A;A&&H&&(console.error("Error: --report-json-only and --report-human-only cannot be used together."),process.exit(1)),p||oe("init");const w=t.join(n,"inferno"),z=t.join(n,".github","workflows");r.existsSync(w)&&!i&&(p&&(console.log(JSON.stringify({ok:!1,error:"inferno_exists",hint:"Use --force to overwrite"},null,2)),process.exit(1)),$("inferno/ already exists. Use --force to overwrite."),console.log(),process.exit(0));const C=U(n),L="CreateTask, ReadTasks, UpdateTask, ToggleComplete, DeleteTask";let b=C,k=L.split(",").map(a=>a.trim());if(u){let o=I(n,{language:F||void 0,framework:_||void 0,projectType:R||void 0});if(!s&&!A){const m=G.createInterface({input:process.stdin,output:process.stdout}),c=o.developmentProfile||{},j=c.detected||{};console.log(S(`  Review inferred development stack (press Enter to accept detected values)
-`));const Z=await P(m,"Language",c.language||j.language||"unknown"),Q=await P(m,"Framework",c.framework||j.framework||"unknown"),ee=await P(m,"Project type",c.projectType||j.projectType||"unknown");m.close(),o=I(n,{language:Z,framework:Q,projectType:ee})}const f=o.capabilities,h=ae(f);A?console.log(JSON.stringify({mode:"adopt",policyId:C,inferredCapabilities:h,components:o.components,displayFields:o.displayFields,externalLibraries:o.externalLibraries,uiLayout:o.uiLayout,styling:o.styling,developmentProfile:o.developmentProfile,apiCalls:o.apiCalls},null,2)):(console.log(),console.log(S(re(f))),console.log(),console.log(S(ce(o))),console.log(),q&&!H&&(console.log(JSON.stringify({mode:"adopt",policyId:C,inferredCapabilities:h,components:o.components,displayFields:o.displayFields,externalLibraries:o.externalLibraries,uiLayout:o.uiLayout,styling:o.styling,developmentProfile:o.developmentProfile,apiCalls:o.apiCalls},null,2)),console.log()));const x=await te(f,s);b=C,k=x.map(m=>m.id)}else if(!s){const a=G.createInterface({input:process.stdin,output:process.stdout});console.log(S(`  Press Enter to accept defaults
-`)),b=await P(a,"Project / policy name",C),k=(await P(a,"Capabilities (comma-separated)",L)).split(",").map(f=>f.trim()).filter(Boolean),a.close(),console.log()}if(r.mkdirSync(w,{recursive:!0}),u){const a=k.map(f=>({id:f,title:f.replace(/([A-Z])/g," $1").trim()})),o=I(n,{language:F||void 0,framework:_||void 0,projectType:R||void 0});se(w,b,a,o),p||(d("Created: "+l("inferno/contract.json")),d("Created: "+l("inferno/capabilities.json")),d("Created: "+l("inferno/scenarios/adoption_baseline.json")),d("Created: "+l("inferno/adoption_profile.json")),d("Created: "+l("inferno/CHANGELOG.md")))}else ye(t.join(w,"contract.json"),b,k),p||d("Created: "+l("inferno/contract.json")),ge(t.join(w,"capabilities.json"),k),p||d("Created: "+l("inferno/capabilities.json")),we(t.join(w,"scenarios"),k),p||d("Created: "+l("inferno/scenarios/happy_path.json")),K(t.join(w,"CHANGELOG.md"),b),p||d("Created: "+l("inferno/CHANGELOG.md"));const O=de(),W=t.join(O,"scripts","inferno-doc-gate.mjs"),Y=t.join(n,"scripts","inferno-doc-gate.mjs");T(W,Y,i,p);const V=t.join(O,"scripts","inferno-install-hooks.mjs"),B=t.join(n,"scripts","inferno-install-hooks.mjs");T(V,B,i,p);const X=t.join(O,"ci","github-inferno-check.yml"),M=t.join(z,"infernoflow-check.yml");if(T(X,M,i,p),me(n,p),v&&le({cwd:n,templatesRoot:O,force:i,silent:p,logOk:a=>{p||d(a)},logWarn:a=>{p||$(a)}}),E&&pe({cwd:n,templatesRoot:O,force:i,silent:p,logOk:a=>{p||d(a)},logWarn:a=>{p||$(a)}}),u){const a=t.join(w,"context-state.json");let o={};try{o=JSON.parse(r.readFileSync(a,"utf8"))}catch{}const f=I(n,{language:F||void 0,framework:_||void 0,projectType:R||void 0});o.stack=f.developmentProfile,r.writeFileSync(a,JSON.stringify(o,null,2)+`
-`,"utf8"),p||d("Created: "+l("inferno/context-state.json"))}if(!p){D("infernoflow initialized!");const a=t.join(w,"integrations.json");!(process.env.ANTHROPIC_API_KEY||process.env.OPENAI_API_KEY||process.env.GOOGLE_AI_API_KEY||process.env.OPENROUTER_API_KEY||process.env.GEMINI_API_KEY)&&!r.existsSync(a)&&(console.log(),console.log(`  ${N("\u{1F4A1}")} ${bold("Tip:")} connect an AI provider for explain, why, review, and changelog AI.`),console.log(`     ${l("infernoflow ai setup")}  \u2014 takes 60 seconds`)),ie([l("infernoflow status")+"  \u2014 see your contract at a glance",l("infernoflow check")+"   \u2014 validate everything",(u?"Review inferred baseline in ":"Edit ")+N("inferno/capabilities.json")+(u?" and refine IDs/titles":" to describe each capability in detail"),"Add more "+N("inferno/scenarios/*.json")+" files for edge cases","Add "+l("inferno:check")+" to your CI pipeline",...v?["Restart Cursor \u2014 hooks write assistant text to "+N("inferno/CONTEXT.draft.md"),"Promote when ready: "+l("npm run inferno:promote-draft -- --append-notes")]:[],...E?["Restart VS Code \u2014 Copilot hooks append prompts + assistant (from transcript) to "+N("inferno/CONTEXT.draft.md"),"Promote when ready: "+l("npm run inferno:promote-draft -- --append-notes")]:[],...!v&&!E?["Optional: "+l("infernoflow install-cursor-hooks")+" or "+l("infernoflow install-vscode-copilot-hooks")]:[]])}}export{Ce as initCommand};
+`;
+  fs.writeFileSync(changelogPath, content);
+}
+
+// ── Lite init — minimal footprint for small projects ─────────────────────────
+
+async function initLite(cwd, force) {
+  const { bold, cyan, gray, green, yellow, red } = await import("../ui/output.mjs");
+
+  console.log("\n  " + bold("🔥 infernoflow init --lite"));
+  console.log("  " + "─".repeat(50) + "\n");
+  console.log(gray("  Lite mode: 3 files, no scripts, no workflows, no hooks."));
+  console.log(gray("  Use `infernoflow upgrade` later to expand to the full setup.\n"));
+
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (fs.existsSync(infernoDir) && !force) {
+    console.log(yellow("  ⚠ inferno/ already exists. Use --force to overwrite.\n"));
+    process.exit(0);
+  }
+
+  fs.mkdirSync(infernoDir, { recursive: true });
+
+  const policyId = detectProjectName(cwd);
+
+  // Prompt for a one-liner intent (skip if --yes)
+  let intent = "";
+  if (!process.argv.includes("--yes") && !process.argv.includes("-y") && process.stdin.isTTY) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    intent = await new Promise(resolve => {
+      rl.question(gray("  What does this project do? (one line, Enter to skip): "), ans => {
+        rl.close();
+        resolve(ans.trim());
+      });
+    });
+  }
+
+  // contract.json — minimal, no rules bloat
+  const contract = {
+    policyId,
+    policyVersion: 1,
+    lite: true,
+    capabilities: [],
+    intent: intent || undefined,
+  };
+  fs.writeFileSync(path.join(infernoDir, "contract.json"), JSON.stringify(contract, null, 2) + "\n");
+
+  // capabilities.json — bare array (lite projects stay flat)
+  fs.writeFileSync(path.join(infernoDir, "capabilities.json"), JSON.stringify([], null, 2) + "\n");
+
+  // sessions.jsonl — empty, ready to receive log entries
+  fs.writeFileSync(path.join(infernoDir, "sessions.jsonl"), "", "utf8");
+
+  // .lite marker — lets `infernoflow upgrade` know the mode
+  fs.writeFileSync(path.join(infernoDir, ".lite"), "1", "utf8");
+
+  console.log(green("  ✔ Created inferno/contract.json"));
+  console.log(green("  ✔ Created inferno/capabilities.json"));
+  console.log(green("  ✔ Created inferno/sessions.jsonl"));
+  console.log();
+  console.log("  " + bold("Ready. Start using it:"));
+  console.log("  " + cyan("infernoflow log") + gray(' "what you\'re building" --type note'));
+  console.log("  " + cyan("infernoflow theme") + gray(" — scan your fonts + colors"));
+  console.log("  " + cyan("infernoflow context") + gray(" — generate AI context to paste"));
+  console.log("  " + cyan("infernoflow upgrade") + gray(" — expand to full setup when you need it"));
+  console.log();
+}
+
+export async function initCommand(args) {
+  const cwd = process.cwd();
+  const force = args.includes("--force") || args.includes("-f");
+  const yes = args.includes("--yes") || args.includes("-y");
+  const adopt = args.includes("--adopt");
+
+  // ── Lite mode — tiny project, single directory, 3 files only ──────────────
+  if (args.includes("--lite")) {
+    await initLite(cwd, force);
+    return;
+  }
+
+  // ── Template shortcut ──────────────────────────────────────────────────────
+  const templateIdx  = args.indexOf("--template");
+  const templateName = templateIdx !== -1 ? args[templateIdx + 1] : null;
+
+  if (templateName) {
+    let tmplMod;
+    try { tmplMod = await import("../templates/index.mjs"); } catch {}
+    const tmpl = tmplMod?.getTemplate(templateName);
+    if (!tmpl) {
+      const available = tmplMod ? tmplMod.listTemplates().map(t => t.name).join(", ") : "rest-api, nextjs, cli, graphql, monorepo";
+      warn(`Unknown template: ${templateName}. Available: ${available}`);
+      process.exit(1);
+    }
+
+    const infernoDir = path.join(cwd, "inferno");
+    const scenDir    = path.join(infernoDir, "scenarios");
+    if (!fs.existsSync(infernoDir)) fs.mkdirSync(infernoDir, { recursive: true });
+    if (!fs.existsSync(scenDir))    fs.mkdirSync(scenDir,    { recursive: true });
+
+    const policyId = detectProjectName(cwd);
+    const caps     = tmpl.capabilities;
+
+    // Write contract.json
+    fs.writeFileSync(path.join(infernoDir, "contract.json"), JSON.stringify({
+      policyId, policyVersion: 1,
+      capabilities: caps.map(c => c.id),
+    }, null, 2) + "\n");
+
+    // Write capabilities.json
+    fs.writeFileSync(path.join(infernoDir, "capabilities.json"), JSON.stringify({
+      capabilities: caps.map(c => ({
+        id: c.id, description: c.description,
+        since: new Date().toISOString().slice(0, 10), source: `template:${templateName}`,
+      })),
+    }, null, 2) + "\n");
+
+    // Write one scenario per capability
+    for (const cap of caps) {
+      fs.writeFileSync(path.join(scenDir, `${cap.id}.json`), JSON.stringify({
+        id: `${cap.id}-happy-path`, capability: cap.id,
+        description: `Happy path for ${cap.description || cap.id}`,
+        steps: [
+          { action: "invoke", target: cap.id, input: {} },
+          { action: "assert", field: "status", value: "success" },
+        ],
+        capabilitiesCovered: [cap.id],
+      }, null, 2) + "\n");
+    }
+
+    // Write CHANGELOG.md
+    writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
+
+    // Write CONTEXT.md hint
+    fs.writeFileSync(path.join(infernoDir, "CONTEXT.md"),
+      `# ${policyId} — infernoflow context\n\n> Template: ${templateName} — ${tmpl.description}\n\n## Hint\n${tmpl.contextHint}\n\n## Capabilities (${caps.length})\n${caps.map(c => `- \`${c.id}\`: ${c.description}`).join("\n")}\n`
+    );
+
+    if (tmpl.scripts) {
+      info(`Suggested package.json scripts for this template:`);
+      Object.entries(tmpl.scripts).forEach(([k, v]) => console.log(`  ${bold(k)}: ${gray(v)}`));
+      console.log();
+    }
+
+    done(`Initialised from template ${bold(cyan(templateName))} — ${bold(String(caps.length))} capabilities`);
+    console.log();
+    info(`Run ${cyan("infernoflow vibe")} to start vibe coding mode`);
+    console.log();
+    return;
+  }
+  const cursorHooks = args.includes("--cursor-hooks");
+  const vscodeCopilotHooks = args.includes("--vscode-copilot-hooks");
+  const reportJson = args.includes("--report-json");
+  const reportJsonOnly = args.includes("--report-json-only");
+  const reportHumanOnly = args.includes("--report-human-only");
+  const langOverride = getArgValue(args, "--lang");
+  const frameworkOverride = getArgValue(args, "--framework");
+  const projectTypeOverride = getArgValue(args, "--project-type");
+  const silent = reportJsonOnly;
+
+  if (reportJsonOnly && reportHumanOnly) {
+    console.error("Error: --report-json-only and --report-human-only cannot be used together.");
+    process.exit(1);
+  }
+
+  if (!silent) {
+    header("init");
+  }
+
+  const infernoDir = path.join(cwd, "inferno");
+  const workflowsDir = path.join(cwd, ".github", "workflows");
+  if (fs.existsSync(infernoDir) && !force) {
+    if (silent) {
+      console.log(JSON.stringify({ ok: false, error: "inferno_exists", hint: "Use --force to overwrite" }, null, 2));
+      process.exit(1);
+    }
+    warn("inferno/ already exists. Use --force to overwrite.");
+    console.log();
+    process.exit(0);
+  }
+
+  const detectedName = detectProjectName(cwd);
+  const defaultCaps = "CreateTask, ReadTasks, UpdateTask, ToggleComplete, DeleteTask";
+
+  let policyId = detectedName;
+  let capabilities = defaultCaps.split(",").map(c => c.trim());
+
+  if (adopt) {
+    const profileOverrides = {
+      language: langOverride || undefined,
+      framework: frameworkOverride || undefined,
+      projectType: projectTypeOverride || undefined,
+    };
+    let signals = discoverProjectSignals(cwd, profileOverrides);
+    if (!yes && !reportJsonOnly) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const profile = signals.developmentProfile || {};
+      const detected = profile.detected || {};
+      console.log(gray("  Review inferred development stack (press Enter to accept detected values)\n"));
+      const language = await ask(rl, "Language", profile.language || detected.language || "unknown");
+      const framework = await ask(rl, "Framework", profile.framework || detected.framework || "unknown");
+      const projectType = await ask(rl, "Project type", profile.projectType || detected.projectType || "unknown");
+      rl.close();
+      signals = discoverProjectSignals(cwd, { language, framework, projectType });
+    }
+    const inferred = signals.capabilities;
+    const summarized = summarizeCapabilities(inferred);
+    if (reportJsonOnly) {
+      console.log(
+        JSON.stringify(
+          {
+            mode: "adopt",
+            policyId: detectedName,
+            inferredCapabilities: summarized,
+            components: signals.components,
+            displayFields: signals.displayFields,
+            externalLibraries: signals.externalLibraries,
+            uiLayout: signals.uiLayout,
+            styling: signals.styling,
+            developmentProfile: signals.developmentProfile,
+            apiCalls: signals.apiCalls,
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log();
+      console.log(gray(buildAdoptionReport(inferred)));
+      console.log();
+      console.log(gray(buildSignalsReport(signals)));
+      console.log();
+      if (reportJson && !reportHumanOnly) {
+        console.log(
+          JSON.stringify(
+            {
+              mode: "adopt",
+              policyId: detectedName,
+              inferredCapabilities: summarized,
+              components: signals.components,
+              displayFields: signals.displayFields,
+              externalLibraries: signals.externalLibraries,
+              uiLayout: signals.uiLayout,
+              styling: signals.styling,
+              developmentProfile: signals.developmentProfile,
+              apiCalls: signals.apiCalls,
+            },
+            null,
+            2
+          )
+        );
+        console.log();
+      }
+    }
+    const reviewed = await reviewCapabilitiesInteractive(inferred, yes);
+    policyId = detectedName;
+    capabilities = reviewed.map((c) => c.id);
+  } else if (!yes) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log(gray("  Press Enter to accept defaults\n"));
+    policyId = await ask(rl, "Project / policy name", detectedName);
+    const capsRaw = await ask(rl, "Capabilities (comma-separated)", defaultCaps);
+    capabilities = capsRaw.split(",").map(c => c.trim()).filter(Boolean);
+    rl.close();
+    console.log();
+  }
+
+  // Write files
+  fs.mkdirSync(infernoDir, { recursive: true });
+
+  if (adopt) {
+    const capDetails = capabilities.map((id) => ({
+      id,
+      title: id.replace(/([A-Z])/g, " $1").trim(),
+    }));
+    const signals = discoverProjectSignals(cwd, {
+      language: langOverride || undefined,
+      framework: frameworkOverride || undefined,
+      projectType: projectTypeOverride || undefined,
+    });
+    writeAdoptionBaseline(infernoDir, policyId, capDetails, signals);
+    if (!silent) {
+      ok("Created: " + cyan("inferno/contract.json"));
+      ok("Created: " + cyan("inferno/capabilities.json"));
+      ok("Created: " + cyan("inferno/scenarios/adoption_baseline.json"));
+      ok("Created: " + cyan("inferno/adoption_profile.json"));
+      ok("Created: " + cyan("inferno/CHANGELOG.md"));
+    }
+  } else {
+    writeContract(path.join(infernoDir, "contract.json"), policyId, capabilities);
+    if (!silent) ok("Created: " + cyan("inferno/contract.json"));
+
+    writeCapabilities(path.join(infernoDir, "capabilities.json"), capabilities);
+    if (!silent) ok("Created: " + cyan("inferno/capabilities.json"));
+
+    writeScenario(path.join(infernoDir, "scenarios"), capabilities);
+    if (!silent) ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
+
+    writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
+    if (!silent) ok("Created: " + cyan("inferno/CHANGELOG.md"));
+  }
+
+  // Copy doc-gate script
+  const templates = getTemplatesRoot();
+  const srcScript = path.join(templates, "scripts", "inferno-doc-gate.mjs");
+  const dstScript = path.join(cwd, "scripts", "inferno-doc-gate.mjs");
+  copyFile(srcScript, dstScript, force, silent);
+  const srcHookScript = path.join(templates, "scripts", "inferno-install-hooks.mjs");
+  const dstHookScript = path.join(cwd, "scripts", "inferno-install-hooks.mjs");
+  copyFile(srcHookScript, dstHookScript, force, silent);
+  const srcWorkflow = path.join(templates, "ci", "github-inferno-check.yml");
+  const dstWorkflow = path.join(workflowsDir, "infernoflow-check.yml");
+  copyFile(srcWorkflow, dstWorkflow, force, silent);
+
+  upsertScripts(cwd, silent);
+
+  if (cursorHooks) {
+    installCursorHooksArtifacts({
+      cwd,
+      templatesRoot: templates,
+      force,
+      silent,
+      logOk: (msg) => {
+        if (!silent) ok(msg);
+      },
+      logWarn: (msg) => {
+        if (!silent) warn(msg);
+      },
+    });
+  }
+  if (vscodeCopilotHooks) {
+    installVsCodeCopilotHooksArtifacts({
+      cwd,
+      templatesRoot: templates,
+      force,
+      silent,
+      logOk: (msg) => {
+        if (!silent) ok(msg);
+      },
+      logWarn: (msg) => {
+        if (!silent) warn(msg);
+      },
+    });
+  }
+
+  if (adopt) {
+    const statePath = path.join(infernoDir, "context-state.json");
+    let state = {};
+    try {
+      state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    } catch {}
+    const signals = discoverProjectSignals(cwd, {
+      language: langOverride || undefined,
+      framework: frameworkOverride || undefined,
+      projectType: projectTypeOverride || undefined,
+    });
+    state.stack = signals.developmentProfile;
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+    if (!silent) ok("Created: " + cyan("inferno/context-state.json"));
+  }
+
+  if (!silent) {
+    done("infernoflow initialized!");
+
+    // AI provider nudge — show once at init if nothing is configured
+    const intPath = path.join(infernoDir, "integrations.json");
+    const hasAiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY ||
+                     process.env.GOOGLE_AI_API_KEY || process.env.OPENROUTER_API_KEY ||
+                     process.env.GEMINI_API_KEY;
+    if (!hasAiKey && !fs.existsSync(intPath)) {
+      console.log();
+      console.log(`  ${yellow("💡")} ${bold("Tip:")} connect an AI provider for explain, why, review, and changelog AI.`);
+      console.log(`     ${cyan("infernoflow ai setup")}  — takes 60 seconds`);
+    }
+
+    nextSteps([
+      cyan("infernoflow status") + "  — see your contract at a glance",
+      cyan("infernoflow check") + "   — validate everything",
+      (adopt ? "Review inferred baseline in " : "Edit ") + yellow("inferno/capabilities.json") + (adopt ? " and refine IDs/titles" : " to describe each capability in detail"),
+      "Add more " + yellow("inferno/scenarios/*.json") + " files for edge cases",
+      "Add " + cyan("inferno:check") + " to your CI pipeline",
+      ...(cursorHooks
+        ? [
+            "Restart Cursor — hooks write assistant text to " + yellow("inferno/CONTEXT.draft.md"),
+            "Promote when ready: " + cyan("npm run inferno:promote-draft -- --append-notes"),
+          ]
+        : []),
+      ...(vscodeCopilotHooks
+        ? [
+            "Restart VS Code — Copilot hooks append prompts + assistant (from transcript) to " +
+              yellow("inferno/CONTEXT.draft.md"),
+            "Promote when ready: " + cyan("npm run inferno:promote-draft -- --append-notes"),
+          ]
+        : []),
+      ...(!cursorHooks && !vscodeCopilotHooks
+        ? [
+            "Optional: " +
+              cyan("infernoflow install-cursor-hooks") +
+              " or " +
+              cyan("infernoflow install-vscode-copilot-hooks"),
+          ]
+        : []),
+    ]);
+  }
+}

package/dist/lib/commands/installCursorHooks.mjs

@@ -1 +1,36 @@
-import*as t from"node:path";import{fileURLToPath as i}from"node:url";import{header as d,ok as m,warn as p,done as l,nextSteps as f,cyan as r,yellow as n}from"../ui/output.mjs";import{installCursorHooksArtifacts as c}from"../cursorHooksInstall.mjs";const u=t.dirname(i(import.meta.url));function h(){return t.resolve(u,"../../templates")}async function g(e){const s=process.cwd(),a=e.includes("--force")||e.includes("-f");d("install-cursor-hooks"),c({cwd:s,templatesRoot:h(),force:a,silent:!1,logOk:o=>m(o),logWarn:o=>p(o)}),l("Cursor draft hooks installed"),f(["Restart Cursor (or reload window) so "+n(".cursor/hooks.json")+" is picked up","Use Agent chat \u2014 each assistant reply appends to "+n("inferno/CONTEXT.draft.md")+" (gitignored)",r("npm run inferno:promote-draft")+" \u2014 preview draft",r("npm run inferno:promote-draft -- --append-notes")+" \u2014 merge into inferno/CONTEXT.md under Decisions",r("npm run inferno:promote-draft -- --clear")+" \u2014 discard draft"])}export{g as installCursorHooksCommand};
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { header, ok, warn, done, nextSteps, cyan, yellow } from "../ui/output.mjs";
+import { installCursorHooksArtifacts } from "../cursorHooksInstall.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getTemplatesRoot() {
+  return path.resolve(__dirname, "../../templates");
+}
+
+export async function installCursorHooksCommand(args) {
+  const cwd = process.cwd();
+  const force = args.includes("--force") || args.includes("-f");
+
+  header("install-cursor-hooks");
+
+  installCursorHooksArtifacts({
+    cwd,
+    templatesRoot: getTemplatesRoot(),
+    force,
+    silent: false,
+    logOk: (msg) => ok(msg),
+    logWarn: (msg) => warn(msg),
+  });
+
+  done("Cursor draft hooks installed");
+
+  nextSteps([
+    "Restart Cursor (or reload window) so " + yellow(".cursor/hooks.json") + " is picked up",
+    "Use Agent chat — each assistant reply appends to " + yellow("inferno/CONTEXT.draft.md") + " (gitignored)",
+    cyan("npm run inferno:promote-draft") + " — preview draft",
+    cyan("npm run inferno:promote-draft -- --append-notes") + " — merge into inferno/CONTEXT.md under Decisions",
+    cyan("npm run inferno:promote-draft -- --clear") + " — discard draft",
+  ]);
+}

package/dist/lib/commands/installVsCodeCopilotHooks.mjs

@@ -1 +1,37 @@
-import*as e from"node:path";import{fileURLToPath as a}from"node:url";import{header as l,ok as d,warn as p,done as m,nextSteps as c,cyan as n,yellow as r}from"../ui/output.mjs";import{installVsCodeCopilotHooksArtifacts as f}from"../vsCodeCopilotHooksInstall.mjs";const u=e.dirname(a(import.meta.url));function h(){return e.resolve(u,"../../templates")}async function g(t){const s=process.cwd(),i=t.includes("--force")||t.includes("-f");l("install-vscode-copilot-hooks"),f({cwd:s,templatesRoot:h(),force:i,silent:!1,logOk:o=>d(o),logWarn:o=>p(o)}),m("VS Code / Copilot draft hooks installed"),c(["Requires VS Code + GitHub Copilot and **Agent hooks (Preview)** \u2014 see "+r("https://code.visualstudio.com/docs/copilot/customization/hooks"),"Hooks load from "+r(".github/hooks/*.json")+" \u2014 restart VS Code or reload window after first install","Check the **GitHub Copilot Chat Hooks** output channel if nothing runs",n("npm run inferno:promote-draft")+" \u2014 preview draft",n("npm run inferno:promote-draft -- --append-notes")+" \u2014 merge into inferno/CONTEXT.md"])}export{g as installVsCodeCopilotHooksCommand};
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { header, ok, warn, done, nextSteps, cyan, yellow } from "../ui/output.mjs";
+import { installVsCodeCopilotHooksArtifacts } from "../vsCodeCopilotHooksInstall.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getTemplatesRoot() {
+  return path.resolve(__dirname, "../../templates");
+}
+
+export async function installVsCodeCopilotHooksCommand(args) {
+  const cwd = process.cwd();
+  const force = args.includes("--force") || args.includes("-f");
+
+  header("install-vscode-copilot-hooks");
+
+  installVsCodeCopilotHooksArtifacts({
+    cwd,
+    templatesRoot: getTemplatesRoot(),
+    force,
+    silent: false,
+    logOk: (msg) => ok(msg),
+    logWarn: (msg) => warn(msg),
+  });
+
+  done("VS Code / Copilot draft hooks installed");
+
+  nextSteps([
+    "Requires VS Code + GitHub Copilot and **Agent hooks (Preview)** — see " +
+      yellow("https://code.visualstudio.com/docs/copilot/customization/hooks"),
+    "Hooks load from " + yellow(".github/hooks/*.json") + " — restart VS Code or reload window after first install",
+    "Check the **GitHub Copilot Chat Hooks** output channel if nothing runs",
+    cyan("npm run inferno:promote-draft") + " — preview draft",
+    cyan("npm run inferno:promote-draft -- --append-notes") + " — merge into inferno/CONTEXT.md",
+  ]);
+}