infernoflow 0.29.0 → 0.31.0

package/dist/lib/commands/test.mjs

@@ -0,0 +1,363 @@
+/**
+ * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "The forge for liquid code - keep capabilities, contracts, and docs in sync.",
   "type": "module",
   "bin": {