infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/test.mjs

@@ -1,6 +1,363 @@
-import*as y from"node:fs";import*as $ from"node:path";import*as E from"node:os";import{spawnSync as w}from"node:child_process";import{bold as A,gray as f,green as F,yellow as I,red as b}from"../ui/output.mjs";function N(i){try{return JSON.parse(y.readFileSync(i,"utf8"))}catch{return null}}function J(i){return i?.stability||"experimental"}const P=F("\u2713"),R=b("\u2717"),L=f("\u25CB");function O(i,n){const e=$.join(n,"scenarios");if(!y.existsSync(e))return[];const g=[];for(const c of y.readdirSync(e))if(c.endsWith(".json"))try{const p=JSON.parse(y.readFileSync($.join(e,c),"utf8"));(p.capabilitiesCovered||p.capabilities||[]).some(a=>a.toLowerCase()===i.toLowerCase())&&g.push({...p,_file:c})}catch{}return g}function z(i){const n=N($.join(i,"package.json"));if(!n)return null;const e={...n.dependencies,...n.devDependencies};return e?.vitest?"vitest":e?.jest?"jest":e?.mocha?"mocha":n.scripts?.test&&!n.scripts.test.includes("no test")?{custom:n.scripts.test}:null}function D(i,n,e,g){const c=n.name||n.title||i,p=n.description||"(no description)",r=g?.codeAnalysis?.sourceFiles||[],a=g?.codeAnalysis?.functions||[],m=e?.steps||e?.actions||[],u=e?.expects||e?.assertions||[],s=[`// Auto-generated smoke test for: ${i}`,"// Generated by infernoflow test \u2014 edit as needed","",'import { strict as assert } from "node:assert";',"",`// Capability: ${c}`,`// ${p}`,""];return r.length&&(s.push(`// Source: ${r[0]}`),s.push(`// import { ${a[0]||i} } from "./${$.basename(r[0])}";`),s.push("")),s.push("async function run() {"),s.push("  const results = [];"),s.push(""),m.length?m.forEach((t,h)=>{const d=typeof t=="string"?t:t.action||t.description||`step ${h+1}`;s.push(`  // Step ${h+1}: ${d}`),s.push(`  results.push({ step: ${JSON.stringify(d)}, status: "manual" });`),s.push("")}):(s.push("  // No explicit steps \u2014 running basic smoke test"),s.push('  results.push({ step: "capability exists", status: "pass" });'),s.push("")),u.length&&(u.forEach((t,h)=>{const d=typeof t=="string"?t:t.condition||t.description||`assertion ${h+1}`;s.push(`  // Assert: ${d}`),s.push(`  // assert(condition, ${JSON.stringify(d)});`)}),s.push("")),s.push("  return results;"),s.push("}"),s.push(""),s.push("run().then(results => {"),s.push('  const failed = results.filter(r => r.status === "fail");'),s.push("  results.forEach(r => {"),s.push('    const icon = r.status === "pass" ? "\u2713" : r.status === "fail" ? "\u2717" : "\u25CB";'),s.push("    console.log(`  ${icon}  ${r.step}`);"),s.push("  });"),s.push("  if (failed.length) { console.error(`\\n  ${failed.length} failed`); process.exit(1); }"),s.push("  else console.log(`\\n  All steps passed`);"),s.push("}).catch(err => { console.error(err); process.exit(1); });"),s.join(`
-`)}function M(i,n,e,g,c){const p=e?.scenarioId||e?.id||e?._file?.replace(".json","")||"unnamed",r=z(c),a=e?.testFiles||e?.testFile?[e.testFile].flat().filter(Boolean):[];if(a.length){for(const s of a){const t=$.resolve(c,s);if(!y.existsSync(t))return{scenarioId:p,status:"skip",reason:`test file not found: ${s}`}}if(r&&typeof r=="string"){const s=r==="vitest"?`npx vitest run ${a.join(" ")} --reporter verbose`:r==="jest"?`npx jest ${a.join(" ")} --no-coverage`:r==="mocha"?`npx mocha ${a.join(" ")}`:null;if(s){const t=w(s,{shell:!0,cwd:c,encoding:"utf8",timeout:6e4}),h=t.status===0;return{scenarioId:p,status:h?"pass":"fail",output:(t.stdout||"")+(t.stderr||""),runner:r}}}if(r?.custom){const s=w(r.custom,{shell:!0,cwd:c,encoding:"utf8",timeout:6e4});return{scenarioId:p,status:s.status===0?"pass":"fail",output:(s.stdout||"")+(s.stderr||""),runner:"npm test"}}}const m=D(i,n,e,g),u=$.join(E.tmpdir(),`infernoflow-test-${i}-${Date.now()}.mjs`);try{y.writeFileSync(u,m);const s=w(process.execPath,[u],{cwd:c,encoding:"utf8",timeout:3e4}),t=s.status===0;return{scenarioId:p,status:t?"pass":"fail",output:(s.stdout||"")+(s.stderr||""),runner:"ad-hoc",generated:!0}}finally{try{y.unlinkSync(u)}catch{}}}function T(i,n,e,g){const c=J(n),p=c==="frozen"?b("frozen"):c==="stable"?I("stable"):f("experimental"),r=e.length,a=e.filter(t=>t.status==="pass").length,m=e.filter(t=>t.status==="fail").length,u=e.filter(t=>t.status==="skip").length,s=m>0?b("\u2717"):a>0?F("\u2713"):f("\u25CB");console.log(`  ${s}  ${A(i)}  ${f(`[${p}]`)}`);for(const t of e){const h=t.status==="pass"?P:t.status==="fail"?R:L,d=t.generated?f(" (generated)"):t.runner?f(` (${t.runner})`):"";if(console.log(`       ${h}  ${f(t.scenarioId)}${d}`),t.reason&&console.log(`          ${f(t.reason)}`),g&&t.output){const l=t.output.trim().split(`
-`).slice(0,10).join(`
-`);console.log(l.split(`
-`).map(k=>`          ${f(k)}`).join(`
-`))}}return{total:r,passed:a,failed:m,skipped:u}}async function K(i){const n=(i||[]).slice(1),e=n.includes("--json"),g=n.includes("--bail"),c=n.includes("--generate"),p=n.includes("--all"),r=n.includes("--verbose")||n.includes("-v"),a=n.filter(o=>!o.startsWith("--")&&o!=="-v"),m=process.cwd(),u=$.join(m,"inferno");y.existsSync(u)||(e||console.error(b("\u2717 inferno/ not found. Run: infernoflow init")),process.exit(1));let s=[];const t=N($.join(u,"capabilities.json"));t&&(s=Array.isArray(t)?t:t.capabilities||[]);const h=N($.join(u,"scan.json"));let d;if(a.length?d=a.map(o=>{const j=s.find(v=>v.id===o);return j||(e||console.error(b(`\u2717 Capability "${o}" not found in capabilities.json`)),process.exit(1)),j}):p?d=s:(d=s.filter(o=>O(o.id,u).length>0),d.length||(e||(console.log(),console.log(`  ${f("No scenarios registered. Use --all to test all capabilities, or")} `),console.log(`  ${f("add scenarios to inferno/scenarios/ first.")}`),console.log()),process.exit(0))),e||(console.log(),console.log(`  ${A("\u{1F9EA} infernoflow test")}`),console.log()),c){const o=d[0],v=O(o.id,u)[0]||{},S=h?.capabilities?.find(C=>C.id===o.id),x=D(o.id,o,v,S);console.log(x);return}const l={total:0,passed:0,failed:0,skipped:0,caps:[]};let k=!1;for(const o of d){const j=O(o.id,u),v=h?.capabilities?.find(C=>C.id===o.id);let S=[];if(!j.length)S=[{scenarioId:"(no scenarios)",status:"skip",reason:"register scenarios in inferno/scenarios/"}];else for(const C of j){const _=M(o.id,o,C,v,m);if(S.push(_),g&&_.status==="fail"){k=!0;break}}const x=T(o.id,o,S,r);if(l.total+=x.total,l.passed+=x.passed,l.failed+=x.failed,l.skipped+=x.skipped,l.caps.push({id:o.id,stability:J(o),results:S}),k)break}if(!e){console.log();const o=l.failed>0?b:l.passed>0?F:f;console.log(`  ${o(A(String(l.passed)))} passed  ${l.failed>0?b(A(String(l.failed))):f("0")} failed  ${f(String(l.skipped))} skipped`),k&&console.log(`  ${I("(bailed on first failure)")}`),console.log(),l.failed||console.log(f("  \u2500\u2500 infernoflow test complete")),console.log()}e&&console.log(JSON.stringify(l,null,2)),process.exit(l.failed>0?1:0)}export{K as testCommand};
+/**
+ * infernoflow test
+ *
+ * Run registered scenarios for a capability and report pass/fail.
+ * When no test runner is configured, generates a minimal ad-hoc harness
+ * from the scenario + source file and runs it with Node.
+ *
+ * Usage:
+ *   infernoflow test                          Run all caps with scenarios
+ *   infernoflow test user-auth                Run scenarios for one cap
+ *   infernoflow test user-auth payment-process  Run multiple caps
+ *   infernoflow test --all                    Run every cap (including no-scenario)
+ *   infernoflow test --generate user-auth     Print generated test file, don't run
+ *   infernoflow test --json                   Machine-readable output
+ *   infernoflow test --bail                   Stop on first failure
+ */
+
+import * as fs      from "node:fs";
+import * as path    from "node:path";
+import * as os      from "node:os";
+import { execSync, spawnSync } from "node:child_process";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function loadJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); }
+  catch { return null; }
+}
+
+function stability(cap) { return cap?.stability || "experimental"; }
+
+const PASS_ICON = green("✓");
+const FAIL_ICON = red("✗");
+const SKIP_ICON = gray("○");
+
+// ── scenario loader ───────────────────────────────────────────────────────────
+
+function loadScenarios(capId, infernoDir) {
+  const dir = path.join(infernoDir, "scenarios");
+  if (!fs.existsSync(dir)) return [];
+  const found = [];
+  for (const f of fs.readdirSync(dir)) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const s = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
+      const covered = s.capabilitiesCovered || s.capabilities || [];
+      if (covered.some(c => c.toLowerCase() === capId.toLowerCase())) {
+        found.push({ ...s, _file: f });
+      }
+    } catch {}
+  }
+  return found;
+}
+
+// ── test runner detection ─────────────────────────────────────────────────────
+
+function detectTestRunner(cwd) {
+  const pkg = loadJson(path.join(cwd, "package.json"));
+  if (!pkg) return null;
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps?.vitest)  return "vitest";
+  if (deps?.jest)    return "jest";
+  if (deps?.mocha)   return "mocha";
+  if (pkg.scripts?.test && !pkg.scripts.test.includes("no test")) {
+    return { custom: pkg.scripts.test };
+  }
+  return null;
+}
+
+// ── ad-hoc test generator ─────────────────────────────────────────────────────
+
+function generateAdHocTest(capId, cap, scenario, scanEntry) {
+  const name    = cap.name || cap.title || capId;
+  const desc    = cap.description || "(no description)";
+  const files   = scanEntry?.codeAnalysis?.sourceFiles || [];
+  const fns     = scanEntry?.codeAnalysis?.functions   || [];
+  const steps   = scenario?.steps   || scenario?.actions || [];
+  const expects = scenario?.expects || scenario?.assertions || [];
+
+  const lines = [
+    `// Auto-generated smoke test for: ${capId}`,
+    `// Generated by infernoflow test — edit as needed`,
+    ``,
+    `import { strict as assert } from "node:assert";`,
+    ``,
+    `// Capability: ${name}`,
+    `// ${desc}`,
+    ``,
+  ];
+
+  // Import source if we know the file
+  if (files.length) {
+    lines.push(`// Source: ${files[0]}`);
+    lines.push(`// import { ${fns[0] || capId} } from "./${path.basename(files[0])}";`);
+    lines.push(``);
+  }
+
+  lines.push(`async function run() {`);
+  lines.push(`  const results = [];`);
+  lines.push(``);
+
+  // Generate test cases from scenario steps
+  if (steps.length) {
+    steps.forEach((step, i) => {
+      const desc = typeof step === "string" ? step : (step.action || step.description || `step ${i + 1}`);
+      lines.push(`  // Step ${i + 1}: ${desc}`);
+      lines.push(`  results.push({ step: ${JSON.stringify(desc)}, status: "manual" });`);
+      lines.push(``);
+    });
+  } else {
+    lines.push(`  // No explicit steps — running basic smoke test`);
+    lines.push(`  results.push({ step: "capability exists", status: "pass" });`);
+    lines.push(``);
+  }
+
+  // Add assertion checks
+  if (expects.length) {
+    expects.forEach((exp, i) => {
+      const desc = typeof exp === "string" ? exp : (exp.condition || exp.description || `assertion ${i + 1}`);
+      lines.push(`  // Assert: ${desc}`);
+      lines.push(`  // assert(condition, ${JSON.stringify(desc)});`);
+    });
+    lines.push(``);
+  }
+
+  lines.push(`  return results;`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`run().then(results => {`);
+  lines.push(`  const failed = results.filter(r => r.status === "fail");`);
+  lines.push(`  results.forEach(r => {`);
+  lines.push(`    const icon = r.status === "pass" ? "✓" : r.status === "fail" ? "✗" : "○";`);
+  lines.push(`    console.log(\`  \${icon}  \${r.step}\`);`);
+  lines.push(`  });`);
+  lines.push(`  if (failed.length) { console.error(\`\\n  \${failed.length} failed\`); process.exit(1); }`);
+  lines.push(`  else console.log(\`\\n  All steps passed\`);`);
+  lines.push(`}).catch(err => { console.error(err); process.exit(1); });`);
+
+  return lines.join("\n");
+}
+
+// ── run a single scenario ─────────────────────────────────────────────────────
+
+function runScenario(capId, cap, scenario, scanEntry, cwd) {
+  const scenarioId = scenario?.scenarioId || scenario?.id || scenario?._file?.replace(".json", "") || "unnamed";
+  const runner     = detectTestRunner(cwd);
+
+  // If there are testFiles registered in the scenario, run those
+  const testFiles = scenario?.testFiles || scenario?.testFile ? [scenario.testFile].flat().filter(Boolean) : [];
+  if (testFiles.length) {
+    for (const tf of testFiles) {
+      const absPath = path.resolve(cwd, tf);
+      if (!fs.existsSync(absPath)) {
+        return { scenarioId, status: "skip", reason: `test file not found: ${tf}` };
+      }
+    }
+
+    // Run with detected test runner
+    if (runner && typeof runner === "string") {
+      const cmd = runner === "vitest"
+        ? `npx vitest run ${testFiles.join(" ")} --reporter verbose`
+        : runner === "jest"
+        ? `npx jest ${testFiles.join(" ")} --no-coverage`
+        : runner === "mocha"
+        ? `npx mocha ${testFiles.join(" ")}`
+        : null;
+
+      if (cmd) {
+        const result = spawnSync(cmd, { shell: true, cwd, encoding: "utf8", timeout: 60_000 });
+        const passed = result.status === 0;
+        return {
+          scenarioId,
+          status:   passed ? "pass" : "fail",
+          output:   (result.stdout || "") + (result.stderr || ""),
+          runner,
+        };
+      }
+    }
+
+    // Custom script runner
+    if (runner?.custom) {
+      const result = spawnSync(runner.custom, { shell: true, cwd, encoding: "utf8", timeout: 60_000 });
+      return {
+        scenarioId,
+        status: result.status === 0 ? "pass" : "fail",
+        output: (result.stdout || "") + (result.stderr || ""),
+        runner: "npm test",
+      };
+    }
+  }
+
+  // No test files — generate and run ad-hoc test
+  const testSrc = generateAdHocTest(capId, cap, scenario, scanEntry);
+  const tmpFile = path.join(os.tmpdir(), `infernoflow-test-${capId}-${Date.now()}.mjs`);
+
+  try {
+    fs.writeFileSync(tmpFile, testSrc);
+    const result = spawnSync(process.execPath, [tmpFile], {
+      cwd,
+      encoding: "utf8",
+      timeout:  30_000,
+    });
+    const passed = result.status === 0;
+    return {
+      scenarioId,
+      status:  passed ? "pass" : "fail",
+      output:  (result.stdout || "") + (result.stderr || ""),
+      runner:  "ad-hoc",
+      generated: true,
+    };
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+}
+
+// ── print result ──────────────────────────────────────────────────────────────
+
+function printCapResult(capId, cap, results, verbose) {
+  const level  = stability(cap);
+  const badge  = level === "frozen" ? red("frozen") : level === "stable" ? yellow("stable") : gray("experimental");
+  const total  = results.length;
+  const passed = results.filter(r => r.status === "pass").length;
+  const failed = results.filter(r => r.status === "fail").length;
+  const skipped = results.filter(r => r.status === "skip").length;
+
+  const statusIcon = failed > 0 ? red("✗") : passed > 0 ? green("✓") : gray("○");
+  console.log(`  ${statusIcon}  ${bold(capId)}  ${gray(`[${badge}]`)}`);
+
+  for (const r of results) {
+    const icon = r.status === "pass" ? PASS_ICON : r.status === "fail" ? FAIL_ICON : SKIP_ICON;
+    const note = r.generated ? gray(" (generated)") : r.runner ? gray(` (${r.runner})`) : "";
+    console.log(`       ${icon}  ${gray(r.scenarioId)}${note}`);
+    if (r.reason) console.log(`          ${gray(r.reason)}`);
+    if (verbose && r.output) {
+      const trimmed = r.output.trim().split("\n").slice(0, 10).join("\n");
+      console.log(trimmed.split("\n").map(l => `          ${gray(l)}`).join("\n"));
+    }
+  }
+
+  return { total, passed, failed, skipped };
+}
+
+// ── entry point ───────────────────────────────────────────────────────────────
+
+export async function testCommand(rawArgs) {
+  const args       = (rawArgs || []).slice(1);
+  const jsonMode   = args.includes("--json");
+  const bail       = args.includes("--bail");
+  const generateMode = args.includes("--generate");
+  const runAll     = args.includes("--all");
+  const verbose    = args.includes("--verbose") || args.includes("-v");
+
+  const capArgs    = args.filter(a => !a.startsWith("--") && a !== "-v");
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    if (!jsonMode) console.error(red("✗ inferno/ not found. Run: infernoflow init"));
+    process.exit(1);
+  }
+
+  // Load capabilities
+  let allCaps = [];
+  const rawCaps = loadJson(path.join(infernoDir, "capabilities.json"));
+  if (rawCaps) allCaps = Array.isArray(rawCaps) ? rawCaps : (rawCaps.capabilities || []);
+
+  const scanData = loadJson(path.join(infernoDir, "scan.json"));
+
+  // Determine which caps to test
+  let targetCaps;
+  if (capArgs.length) {
+    targetCaps = capArgs.map(id => {
+      const cap = allCaps.find(c => c.id === id);
+      if (!cap) {
+        if (!jsonMode) console.error(red(`✗ Capability "${id}" not found in capabilities.json`));
+        process.exit(1);
+      }
+      return cap;
+    });
+  } else if (runAll) {
+    targetCaps = allCaps;
+  } else {
+    // Default: caps that have scenarios registered
+    targetCaps = allCaps.filter(cap => loadScenarios(cap.id, infernoDir).length > 0);
+    if (!targetCaps.length) {
+      if (!jsonMode) {
+        console.log();
+        console.log(`  ${gray("No scenarios registered. Use --all to test all capabilities, or")} `);
+        console.log(`  ${gray("add scenarios to inferno/scenarios/ first.")}`);
+        console.log();
+      }
+      process.exit(0);
+    }
+  }
+
+  if (!jsonMode) {
+    console.log();
+    console.log(`  ${bold("🧪 infernoflow test")}`);
+    console.log();
+  }
+
+  // --generate mode: print generated test for first cap
+  if (generateMode) {
+    const cap     = targetCaps[0];
+    const scenarios = loadScenarios(cap.id, infernoDir);
+    const scenario  = scenarios[0] || {};
+    const scanEntry = scanData?.capabilities?.find(c => c.id === cap.id);
+    const src = generateAdHocTest(cap.id, cap, scenario, scanEntry);
+    console.log(src);
+    return;
+  }
+
+  // Run tests
+  const summary = { total: 0, passed: 0, failed: 0, skipped: 0, caps: [] };
+  let bailed = false;
+
+  for (const cap of targetCaps) {
+    const scenarios = loadScenarios(cap.id, infernoDir);
+    const scanEntry = scanData?.capabilities?.find(c => c.id === cap.id);
+
+    let capResults = [];
+
+    if (!scenarios.length) {
+      capResults = [{ scenarioId: "(no scenarios)", status: "skip", reason: "register scenarios in inferno/scenarios/" }];
+    } else {
+      for (const scenario of scenarios) {
+        const r = runScenario(cap.id, cap, scenario, scanEntry, cwd);
+        capResults.push(r);
+        if (bail && r.status === "fail") { bailed = true; break; }
+      }
+    }
+
+    const counts = printCapResult(cap.id, cap, capResults, verbose);
+    summary.total   += counts.total;
+    summary.passed  += counts.passed;
+    summary.failed  += counts.failed;
+    summary.skipped += counts.skipped;
+    summary.caps.push({ id: cap.id, stability: stability(cap), results: capResults });
+
+    if (bailed) break;
+  }
+
+  if (!jsonMode) {
+    console.log();
+    const statusColor = summary.failed > 0 ? red : summary.passed > 0 ? green : gray;
+    console.log(`  ${statusColor(bold(String(summary.passed)))} passed  ${summary.failed > 0 ? red(bold(String(summary.failed))) : gray("0")} failed  ${gray(String(summary.skipped))} skipped`);
+    if (bailed) console.log(`  ${yellow("(bailed on first failure)")}`);
+    console.log();
+    if (!summary.failed) {
+      console.log(gray("  ── infernoflow test complete"));
+    }
+    console.log();
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify(summary, null, 2));
+  }
+
+  process.exit(summary.failed > 0 ? 1 : 0);
+}

package/dist/lib/commands/theme.mjs

@@ -1,18 +1,195 @@
-import*as u from"node:fs";import*as y from"node:path";import{scanTheme as F}from"../theme/scanner.mjs";import{bold as $,cyan as h,gray as i,green as k,yellow as d,red as I}from"../ui/output.mjs";const p="inferno",S=y.join(p,"theme.json"),w=y.join(p,"sessions.jsonl");function j(e){try{return JSON.parse(u.readFileSync(e,"utf8"))}catch{return null}}function N(e){u.existsSync(w)&&u.appendFileSync(w,JSON.stringify(e)+`
-`,"utf8")}function C(e,o){const c=[];e?.fonts?.primary!==o?.fonts?.primary&&c.push(`primary font: ${e?.fonts?.primary||"none"} \u2192 ${o?.fonts?.primary||"none"}`),e?.fonts?.mono!==o?.fonts?.mono&&c.push(`mono font: ${e?.fonts?.mono||"none"} \u2192 ${o?.fonts?.mono||"none"}`),e?.colors?.mode!==o?.colors?.mode&&c.push(`color mode: ${e?.colors?.mode||"unknown"} \u2192 ${o?.colors?.mode}`);const l=e?.colors?.palette||{},f=o?.colors?.palette||{};for(const t of new Set([...Object.keys(l),...Object.keys(f)]))l[t]!==f[t]&&c.push(`${t} color: ${l[t]||"none"} \u2192 ${f[t]||"none"}`);const a=e?.cssVars||{},r=o?.cssVars||{},n=Object.keys(r).filter(t=>!a[t]),s=Object.keys(r).filter(t=>a[t]&&a[t]!==r[t]);return n.length&&c.push(`new CSS vars: ${n.slice(0,5).join(", ")}`),s.length&&c.push(`changed CSS vars: ${s.slice(0,5).join(", ")}`),c}function O(e){const{fonts:o,colors:c,cssVars:l,framework:f,stats:a}=e;console.log(`
-  `+$("\u{1F3A8} Design System")),console.log("  "+"\u2500".repeat(50)),console.log(h(`
-  Fonts`)),o.primary&&console.log(`    Primary   : ${o.primary}`),o.mono&&console.log(`    Mono      : ${o.mono}`),o.all?.length>2&&console.log(i(`    All       : ${o.all.join(", ")}`)),o.sources?.length&&console.log(i(`    Sources   : ${o.sources.join(", ")}`)),console.log(h(`
-  Colors`)+i(` (${c.mode} mode)`));for(const[r,n]of Object.entries(c.palette)){const s=`\x1B[48;2;${parseInt(n.slice(1,3),16)};${parseInt(n.slice(3,5),16)};${parseInt(n.slice(5,7),16)}m   \x1B[0m`;console.log(`    ${r.padEnd(14)} ${s} ${n}`)}if(Object.keys(l).length){console.log(h(`
-  CSS Variables`)+i(` (${Object.keys(l).length} found)`));const r=Object.entries(l).slice(0,12);for(const[n,s]of r)console.log(`    ${n.padEnd(24)} ${i(s)}`);Object.keys(l).length>12&&console.log(i(`    \u2026 and ${Object.keys(l).length-12} more`))}console.log(h(`
-  Framework`)+`  ${f}`),console.log(i(`
-  Scanned: ${a.styleFiles} style files \xB7 ${a.colorsFound} colors \xB7 ${a.varsFound} CSS vars
-`))}async function V(e){const o=n=>e.includes(n),c=o("--dry-run"),l=o("--show")||o("-s"),f=o("--json"),a=o("--watch");if(console.log(`
-  `+$("\u{1F525} infernoflow \u2014 theme")),console.log("  "+"\u2500".repeat(50)+`
-`),u.existsSync(p)||(console.error(I(`  \u2718 inferno/ not found \u2014 run: infernoflow init
-`)),process.exit(1)),l){const n=j(S);if(!n){console.log(d(`  \u26A0 No theme.json yet \u2014 run: infernoflow theme
-`));return}if(f){console.log(JSON.stringify(n,null,2));return}O(n);return}const r=()=>{console.log(i("  Scanning style files\u2026"));const n=process.cwd(),s=F(n);if(f){console.log(JSON.stringify(s,null,2));return}if(O(s),c){console.log(d(`  \u2691 Dry run \u2014 theme.json not written
-`));return}const t=j(S),g={...s,scannedAt:new Date().toISOString()};if(u.writeFileSync(S,JSON.stringify(g,null,2)+`
-`,"utf8"),console.log(k(`  \u2714 Written \u2192 inferno/theme.json
-`)),t){const m=C(t,s);if(m.length){N({ts:new Date().toISOString(),agent:"infernoflow",type:"theme",summary:"Theme changed: "+m.join("; ")}),console.log(d("  \u26A1 Theme changes logged to sessions.jsonl"));for(const b of m)console.log(i(`     \u2022 ${b}`));console.log()}}};if(r(),a){console.log(h(`  Watching style files for changes\u2026 (Ctrl+C to stop)
-`));const{watch:n}=await import("node:fs");let s=null;n(process.cwd(),{recursive:!0},(t,g)=>{if(!g)return;const m=y.extname(g);[".css",".scss",".sass",".less",".styl"].includes(m)&&(s&&clearTimeout(s),s=setTimeout(()=>{console.log(i(`
-  Change detected: ${g}`)),r()},1e3))}),await new Promise(()=>{})}}export{V as themeCommand};
+/**
+ * infernoflow theme
+ *
+ * Scans the project for design tokens — fonts, colors, CSS variables —
+ * and writes inferno/theme.json so AI agents always know the visual system.
+ *
+ * This captures what AI can't reliably infer from scattered style files:
+ * the actual palette, typography, and spacing tokens in use.
+ *
+ * When theme.json changes between runs, the delta is auto-logged to sessions.jsonl
+ * so agents know the design system evolved (not just the code).
+ *
+ * Usage:
+ *   infernoflow theme             Scan + write inferno/theme.json
+ *   infernoflow theme --show      Print current theme.json
+ *   infernoflow theme --json      Output as JSON
+ *   infernoflow theme --dry-run   Scan but don't write
+ *   infernoflow theme --watch     Re-scan on style file changes
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { scanTheme }  from "../theme/scanner.mjs";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+const INFERNO_DIR  = "inferno";
+const THEME_FILE   = path.join(INFERNO_DIR, "theme.json");
+const SESSIONS_FILE = path.join(INFERNO_DIR, "sessions.jsonl");
+
+function readJSON(f) { try { return JSON.parse(fs.readFileSync(f, "utf8")); } catch { return null; } }
+
+function appendSession(entry) {
+  if (!fs.existsSync(SESSIONS_FILE)) return;
+  fs.appendFileSync(SESSIONS_FILE, JSON.stringify(entry) + "\n", "utf8");
+}
+
+function diffTheme(prev, next) {
+  const changes = [];
+
+  // Font changes
+  if (prev?.fonts?.primary !== next?.fonts?.primary) {
+    changes.push(`primary font: ${prev?.fonts?.primary || "none"} → ${next?.fonts?.primary || "none"}`);
+  }
+  if (prev?.fonts?.mono !== next?.fonts?.mono) {
+    changes.push(`mono font: ${prev?.fonts?.mono || "none"} → ${next?.fonts?.mono || "none"}`);
+  }
+
+  // Mode change
+  if (prev?.colors?.mode !== next?.colors?.mode) {
+    changes.push(`color mode: ${prev?.colors?.mode || "unknown"} → ${next?.colors?.mode}`);
+  }
+
+  // Palette changes
+  const prevPalette = prev?.colors?.palette || {};
+  const nextPalette = next?.colors?.palette || {};
+  for (const key of new Set([...Object.keys(prevPalette), ...Object.keys(nextPalette)])) {
+    if (prevPalette[key] !== nextPalette[key]) {
+      changes.push(`${key} color: ${prevPalette[key] || "none"} → ${nextPalette[key] || "none"}`);
+    }
+  }
+
+  // CSS var changes (new or changed vars only)
+  const prevVars = prev?.cssVars || {};
+  const nextVars = next?.cssVars || {};
+  const newVars  = Object.keys(nextVars).filter(k => !prevVars[k]);
+  const changedVars = Object.keys(nextVars).filter(k => prevVars[k] && prevVars[k] !== nextVars[k]);
+  if (newVars.length)     changes.push(`new CSS vars: ${newVars.slice(0,5).join(", ")}`);
+  if (changedVars.length) changes.push(`changed CSS vars: ${changedVars.slice(0,5).join(", ")}`);
+
+  return changes;
+}
+
+function printTheme(theme) {
+  const { fonts, colors, cssVars, framework, stats } = theme;
+
+  console.log("\n  " + bold("🎨 Design System"));
+  console.log("  " + "─".repeat(50));
+
+  console.log(cyan("\n  Fonts"));
+  if (fonts.primary) console.log(`    Primary   : ${fonts.primary}`);
+  if (fonts.mono)    console.log(`    Mono      : ${fonts.mono}`);
+  if (fonts.all?.length > 2) console.log(gray(`    All       : ${fonts.all.join(", ")}`));
+  if (fonts.sources?.length) console.log(gray(`    Sources   : ${fonts.sources.join(", ")}`));
+
+  console.log(cyan("\n  Colors") + gray(` (${colors.mode} mode)`));
+  for (const [role, hex] of Object.entries(colors.palette)) {
+    const swatch = `\x1b[48;2;${parseInt(hex.slice(1,3),16)};${parseInt(hex.slice(3,5),16)};${parseInt(hex.slice(5,7),16)}m   \x1b[0m`;
+    console.log(`    ${role.padEnd(14)} ${swatch} ${hex}`);
+  }
+
+  if (Object.keys(cssVars).length) {
+    console.log(cyan("\n  CSS Variables") + gray(` (${Object.keys(cssVars).length} found)`));
+    const entries = Object.entries(cssVars).slice(0, 12);
+    for (const [name, val] of entries) {
+      console.log(`    ${name.padEnd(24)} ${gray(val)}`);
+    }
+    if (Object.keys(cssVars).length > 12) {
+      console.log(gray(`    … and ${Object.keys(cssVars).length - 12} more`));
+    }
+  }
+
+  console.log(cyan("\n  Framework") + `  ${framework}`);
+  console.log(gray(`\n  Scanned: ${stats.styleFiles} style files · ${stats.colorsFound} colors · ${stats.varsFound} CSS vars\n`));
+}
+
+export async function themeCommand(args) {
+  const has     = (f) => args.includes(f);
+  const dryRun  = has("--dry-run");
+  const showOnly = has("--show") || has("-s");
+  const jsonFlag = has("--json");
+  const watchFlag = has("--watch");
+
+  console.log("\n  " + bold("🔥 infernoflow — theme"));
+  console.log("  " + "─".repeat(50) + "\n");
+
+  if (!fs.existsSync(INFERNO_DIR)) {
+    console.error(red("  ✘ inferno/ not found — run: infernoflow init\n"));
+    process.exit(1);
+  }
+
+  // ── Show existing theme ────────────────────────────────────────────────────
+  if (showOnly) {
+    const existing = readJSON(THEME_FILE);
+    if (!existing) {
+      console.log(yellow("  ⚠ No theme.json yet — run: infernoflow theme\n"));
+      return;
+    }
+    if (jsonFlag) { console.log(JSON.stringify(existing, null, 2)); return; }
+    printTheme(existing);
+    return;
+  }
+
+  const runScan = () => {
+    console.log(gray("  Scanning style files…"));
+    const cwd = process.cwd();
+    const theme = scanTheme(cwd);
+
+    if (jsonFlag) { console.log(JSON.stringify(theme, null, 2)); return; }
+
+    printTheme(theme);
+
+    if (dryRun) {
+      console.log(yellow("  ⚑ Dry run — theme.json not written\n"));
+      return;
+    }
+
+    // Read previous theme to diff
+    const prev = readJSON(THEME_FILE);
+
+    const output = {
+      ...theme,
+      scannedAt: new Date().toISOString(),
+    };
+
+    fs.writeFileSync(THEME_FILE, JSON.stringify(output, null, 2) + "\n", "utf8");
+    console.log(green("  ✔ Written → inferno/theme.json\n"));
+
+    // Auto-log changes to sessions.jsonl if theme changed
+    if (prev) {
+      const changes = diffTheme(prev, theme);
+      if (changes.length) {
+        appendSession({
+          ts:      new Date().toISOString(),
+          agent:   "infernoflow",
+          type:    "theme",
+          summary: "Theme changed: " + changes.join("; "),
+        });
+        console.log(yellow("  ⚡ Theme changes logged to sessions.jsonl"));
+        for (const c of changes) console.log(gray(`     • ${c}`));
+        console.log();
+      }
+    }
+  };
+
+  runScan();
+
+  // ── Watch mode ─────────────────────────────────────────────────────────────
+  if (watchFlag) {
+    console.log(cyan("  Watching style files for changes… (Ctrl+C to stop)\n"));
+    const { watch } = await import("node:fs");
+    let debounce = null;
+    watch(process.cwd(), { recursive: true }, (_, filename) => {
+      if (!filename) return;
+      const ext = path.extname(filename);
+      if (![".css",".scss",".sass",".less",".styl"].includes(ext)) return;
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        console.log(gray(`\n  Change detected: ${filename}`));
+        runScan();
+      }, 1000);
+    });
+    // Keep alive
+    await new Promise(() => {});
+  }
+}