infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/adoptWizard.mjs

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

package/dist/lib/commands/agent.mjs

@@ -1,5 +1,191 @@
-import*as c from"node:fs";import*as g from"node:path";import{execSync as v}from"node:child_process";import{header as y,ok as x,warn as r,info as p,done as C,bold as m,cyan as f,green as D,gray as $,red as N}from"../ui/output.mjs";import{observeCommandStart as O}from"../learning/observe.mjs";function R(t){const e=g.join(t,"inferno");return c.existsSync(e)?e:null}function S(t){return g.join(t,"agents")}function k(t){const e=S(t);return c.existsSync(e)?c.readdirSync(e).filter(n=>n.endsWith(".json")).map(n=>{try{return JSON.parse(c.readFileSync(g.join(e,n),"utf8"))}catch{return null}}).filter(Boolean):[]}function w(t,e){return k(t).find(o=>o.name===e||o.id===e)}function U(t,e,n){const o=`npx infernoflow ${t} ${e.join(" ")}`.trim();try{return{ok:!0,output:v(o,{cwd:n,encoding:"utf8",timeout:6e4,stdio:["inherit","pipe","inherit"]})}}catch(s){return{ok:!1,output:s.stdout||s.message}}}function F(t){const e=k(t);if(e.length===0){p("No agents saved yet."),p(`Run ${f("infernoflow synthesize")} to auto-generate agents from your workflow patterns.`);return}y("infernoflow agents"),console.log(`
-  ${m(String(e.length))} saved agent${e.length!==1?"s":""}:
-`);for(const n of e){const o=(n.steps||[]).map(l=>l.command).join(" \u2192 "),s=n.confidence?$(`${Math.round(n.confidence*100)}% confidence`):"";console.log(`  ${D("\u25B6")} ${m(n.name)}  ${s}`),console.log(`      ${$(n.description||o)}`),console.log(`      Steps: ${f(o)}`),console.log()}console.log(`  Run: ${f("infernoflow agent run <name>")}`)}async function A(t,e,n){const o=w(t,n);o||(r(`Agent "${n}" not found.`),r(`Run ${f("infernoflow agent list")} to see available agents.`),process.exit(1)),y(`infernoflow agent run: ${o.name}`),p(o.description||o.name),console.log();const s=o.steps||[];let l=!0;for(let i=0;i<s.length;i++){const a=s[i],u=typeof a=="string"?a:a.command,h=typeof a=="string"?[]:a.args||[];console.log(`  ${m(`[${i+1}/${s.length}]`)} ${f(`infernoflow ${u} ${h.join(" ")}`.trim())}`);const d=U(u,h,e);if(d.output){const b=d.output.trim().split(`
-`);for(const j of b)console.log(`    ${$(j)}`)}if(!d.ok){r(`Step "${u}" exited with an error \u2014 stopping agent.`),l=!1;break}x(`Step ${i+1} complete`),console.log()}l?C(`Agent "${o.name}" completed all ${s.length} steps`):(console.log(`
-  ${N("\u2718")} Agent stopped early. Fix the error above and re-run.`),process.exit(1))}function J(t,e){const n=w(t,e);n||(r(`Agent "${e}" not found.`),process.exit(1)),console.log(JSON.stringify(n,null,2))}function z(t,e){const n=w(t,e);n||(r(`Agent "${e}" not found.`),process.exit(1));const o=g.join(S(t),`${n.name}.json`);c.unlinkSync(o),x(`Deleted agent: ${n.name}`)}async function P(t){const e=process.cwd(),n=R(e);n||(r("inferno/ not found \u2014 run infernoflow init first"),process.exit(1)),O(n,"agent");const o=t[0],s=t[1];switch(o){case"list":case void 0:F(n);break;case"run":s||(r("Usage: infernoflow agent run <name>"),process.exit(1)),await A(n,e,s);break;case"show":s||(r("Usage: infernoflow agent show <name>"),process.exit(1)),J(n,s);break;case"delete":case"remove":s||(r("Usage: infernoflow agent delete <name>"),process.exit(1)),z(n,s);break;default:await A(n,e,o)}}export{P as agentCommand};
+/**
+ * infernoflow agent
+ *
+ * Manage and run auto-synthesized agents.
+ *
+ * Sub-commands:
+ *   infernoflow agent list              — list all saved agents
+ *   infernoflow agent run <name>        — execute an agent's command sequence
+ *   infernoflow agent show <name>       — print agent definition
+ *   infernoflow agent delete <name>     — remove an agent
+ */
+
+import * as fs      from "node:fs";
+import * as path    from "node:path";
+import { execSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, green, gray, red } from "../ui/output.mjs";
+import { observeCommandStart } from "../learning/observe.mjs";
+
+function findInfernoDir(cwd) {
+  const d = path.join(cwd, "inferno");
+  return fs.existsSync(d) ? d : null;
+}
+
+function agentsDir(infernoDir) {
+  return path.join(infernoDir, "agents");
+}
+
+function loadAgents(infernoDir) {
+  const dir = agentsDir(infernoDir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith(".json"))
+    .map(f => {
+      try { return JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")); }
+      catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function findAgent(infernoDir, name) {
+  const agents = loadAgents(infernoDir);
+  return agents.find(a => a.name === name || a.id === name);
+}
+
+function runStep(cmd, args, cwd) {
+  const fullCmd = `npx infernoflow ${cmd} ${args.join(" ")}`.trim();
+  try {
+    const out = execSync(fullCmd, {
+      cwd,
+      encoding: "utf8",
+      timeout: 60_000,
+      stdio: ["inherit", "pipe", "inherit"],
+    });
+    return { ok: true, output: out };
+  } catch (err) {
+    return { ok: false, output: err.stdout || err.message };
+  }
+}
+
+// ── Sub-commands ──────────────────────────────────────────────────────────────
+
+function listAgents(infernoDir) {
+  const agents = loadAgents(infernoDir);
+  if (agents.length === 0) {
+    info("No agents saved yet.");
+    info(`Run ${cyan("infernoflow synthesize")} to auto-generate agents from your workflow patterns.`);
+    return;
+  }
+
+  header("infernoflow agents");
+  console.log(`\n  ${bold(String(agents.length))} saved agent${agents.length !== 1 ? "s" : ""}:\n`);
+  for (const agent of agents) {
+    const steps = (agent.steps || []).map(s => s.command).join(" → ");
+    const conf  = agent.confidence ? gray(`${Math.round(agent.confidence * 100)}% confidence`) : "";
+    console.log(`  ${green("▶")} ${bold(agent.name)}  ${conf}`);
+    console.log(`      ${gray(agent.description || steps)}`);
+    console.log(`      Steps: ${cyan(steps)}`);
+    console.log();
+  }
+  console.log(`  Run: ${cyan("infernoflow agent run <name>")}`);
+}
+
+async function runAgent(infernoDir, cwd, name) {
+  const agent = findAgent(infernoDir, name);
+  if (!agent) {
+    warn(`Agent "${name}" not found.`);
+    warn(`Run ${cyan("infernoflow agent list")} to see available agents.`);
+    process.exit(1);
+  }
+
+  header(`infernoflow agent run: ${agent.name}`);
+  info(agent.description || agent.name);
+  console.log();
+
+  const steps = agent.steps || [];
+  let allOk = true;
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const cmd  = typeof step === "string" ? step : step.command;
+    const args = typeof step === "string" ? [] : (step.args || []);
+
+    console.log(`  ${bold(`[${i + 1}/${steps.length}]`)} ${cyan(`infernoflow ${cmd} ${args.join(" ")}`.trim())}`);
+
+    const result = runStep(cmd, args, cwd);
+    if (result.output) {
+      const lines = result.output.trim().split("\n");
+      for (const line of lines) console.log(`    ${gray(line)}`);
+    }
+
+    if (!result.ok) {
+      warn(`Step "${cmd}" exited with an error — stopping agent.`);
+      allOk = false;
+      break;
+    }
+
+    ok(`Step ${i + 1} complete`);
+    console.log();
+  }
+
+  if (allOk) {
+    done(`Agent "${agent.name}" completed all ${steps.length} steps`);
+  } else {
+    console.log(`\n  ${red("✘")} Agent stopped early. Fix the error above and re-run.`);
+    process.exit(1);
+  }
+}
+
+function showAgent(infernoDir, name) {
+  const agent = findAgent(infernoDir, name);
+  if (!agent) {
+    warn(`Agent "${name}" not found.`);
+    process.exit(1);
+  }
+  console.log(JSON.stringify(agent, null, 2));
+}
+
+function deleteAgent(infernoDir, name) {
+  const agent = findAgent(infernoDir, name);
+  if (!agent) {
+    warn(`Agent "${name}" not found.`);
+    process.exit(1);
+  }
+  const filePath = path.join(agentsDir(infernoDir), `${agent.name}.json`);
+  fs.unlinkSync(filePath);
+  ok(`Deleted agent: ${agent.name}`);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+export async function agentCommand(args) {
+  const cwd = process.cwd();
+  const infernoDir = findInfernoDir(cwd);
+
+  if (!infernoDir) {
+    warn("inferno/ not found — run infernoflow init first");
+    process.exit(1);
+  }
+
+  observeCommandStart(infernoDir, "agent");
+
+  const sub  = args[0];
+  const name = args[1];
+
+  switch (sub) {
+    case "list":
+    case undefined:
+      listAgents(infernoDir);
+      break;
+
+    case "run":
+      if (!name) { warn("Usage: infernoflow agent run <name>"); process.exit(1); }
+      await runAgent(infernoDir, cwd, name);
+      break;
+
+    case "show":
+      if (!name) { warn("Usage: infernoflow agent show <name>"); process.exit(1); }
+      showAgent(infernoDir, name);
+      break;
+
+    case "delete":
+    case "remove":
+      if (!name) { warn("Usage: infernoflow agent delete <name>"); process.exit(1); }
+      deleteAgent(infernoDir, name);
+      break;
+
+    default:
+      // Treat unknown arg as agent name to run (convenience shortcut)
+      await runAgent(infernoDir, cwd, sub);
+  }
+}