infernoflow 0.10.6 → 0.10.8

package/lib/commands/implement.mjs

@@ -1,103 +1,103 @@
-import fs from "node:fs";
-import path from "node:path";
-import { execSync } from "node:child_process";
-import { header, section, info, warn, cyan, gray, errorAndExit } from "../ui/output.mjs";
-import {
-  loadImplementContext,
-  buildCursorImplementPrompt,
-  buildGenericImplementPrompt,
-} from "../ui/prompts.mjs";
-
-function getFlagValue(args, flag) {
-  const idx = args.indexOf(flag);
-  return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
-}
-
-function extractTask(args) {
-  const skipNextFor = new Set(["--mode"]);
-  const parts = [];
-  for (let i = 0; i < args.length; i += 1) {
-    const token = args[i];
-    if (token.startsWith("-")) {
-      if (skipNextFor.has(token)) i += 1;
-      continue;
-    }
-    if (i === 0) continue; // command name
-    parts.push(token);
-  }
-  return parts.join(" ").trim();
-}
-
-function copyToClipboard(text) {
-  try {
-    const p = process.platform;
-    if (p === "win32") execSync("clip", { input: text });
-    else if (p === "darwin") execSync("pbcopy", { input: text });
-    else {
-      try { execSync("xclip -selection clipboard", { input: text }); }
-      catch { execSync("xsel --clipboard --input", { input: text }); }
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function implementCommand(args = []) {
-  header("implement");
-
-  const cwd = process.cwd();
-  const infernoDir = path.join(cwd, "inferno");
-  if (!fs.existsSync(infernoDir)) {
-    errorAndExit("inferno/ not found", "Run: infernoflow init");
-  }
-
-  const mode = (getFlagValue(args, "--mode") || "both").toLowerCase();
-  const copyFlag = args.includes("--copy") || args.includes("-c");
-  if (!["cursor", "generic", "both"].includes(mode)) {
-    errorAndExit("Invalid --mode value", "Use: --mode cursor|generic|both");
-  }
-
-  const rawTask = extractTask(args);
-  if (!rawTask) {
-    errorAndExit("No task provided", 'Usage: infernoflow implement "your task description"');
-  }
-
-  const context = loadImplementContext(cwd);
-  const cursorPrompt = buildCursorImplementPrompt({ task: rawTask, ...context });
-  const genericPrompt = buildGenericImplementPrompt({ task: rawTask, ...context });
-
-  info(`Task: ${cyan(rawTask)}`);
-  info(`Mode: ${cyan(mode)}`);
-  warn("If you hit model high-load/resource-exhausted, retry with Auto/another model.");
-
-  if (mode === "cursor" || mode === "both") {
-    section("Cursor Agent Prompt");
-    console.log();
-    console.log(gray("─".repeat(50)));
-    console.log(cursorPrompt);
-    console.log(gray("─".repeat(50)));
-  }
-
-  if (mode === "generic" || mode === "both") {
-    section("Generic Agent Prompt");
-    console.log();
-    console.log(gray("─".repeat(50)));
-    console.log(genericPrompt);
-    console.log(gray("─".repeat(50)));
-  }
-
-  if (copyFlag) {
-    const textToCopy =
-      mode === "cursor"
-        ? cursorPrompt
-        : mode === "generic"
-          ? genericPrompt
-          : `## Cursor Agent Prompt\n\n${cursorPrompt}\n\n## Generic Agent Prompt\n\n${genericPrompt}`;
-    const ok = copyToClipboard(textToCopy);
-    if (ok) info(`Copied ${mode} prompt${mode === "both" ? "s" : ""} to clipboard.`);
-    else warn("Clipboard copy failed. Copy from terminal output.");
-  }
-
-  console.log();
-}
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { header, section, info, warn, cyan, gray, errorAndExit } from "../ui/output.mjs";
+import {
+  loadImplementContext,
+  buildCursorImplementPrompt,
+  buildGenericImplementPrompt,
+} from "../ui/prompts.mjs";
+
+function getFlagValue(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
+}
+
+function extractTask(args) {
+  const skipNextFor = new Set(["--mode"]);
+  const parts = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token.startsWith("-")) {
+      if (skipNextFor.has(token)) i += 1;
+      continue;
+    }
+    if (i === 0) continue; // command name
+    parts.push(token);
+  }
+  return parts.join(" ").trim();
+}
+
+function copyToClipboard(text) {
+  try {
+    const p = process.platform;
+    if (p === "win32") execSync("clip", { input: text });
+    else if (p === "darwin") execSync("pbcopy", { input: text });
+    else {
+      try { execSync("xclip -selection clipboard", { input: text }); }
+      catch { execSync("xsel --clipboard --input", { input: text }); }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function implementCommand(args = []) {
+  header("implement");
+
+  const cwd = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+  if (!fs.existsSync(infernoDir)) {
+    errorAndExit("inferno/ not found", "Run: infernoflow init");
+  }
+
+  const mode = (getFlagValue(args, "--mode") || "both").toLowerCase();
+  const copyFlag = args.includes("--copy") || args.includes("-c");
+  if (!["cursor", "generic", "both"].includes(mode)) {
+    errorAndExit("Invalid --mode value", "Use: --mode cursor|generic|both");
+  }
+
+  const rawTask = extractTask(args);
+  if (!rawTask) {
+    errorAndExit("No task provided", 'Usage: infernoflow implement "your task description"');
+  }
+
+  const context = loadImplementContext(cwd);
+  const cursorPrompt = buildCursorImplementPrompt({ task: rawTask, ...context });
+  const genericPrompt = buildGenericImplementPrompt({ task: rawTask, ...context });
+
+  info(`Task: ${cyan(rawTask)}`);
+  info(`Mode: ${cyan(mode)}`);
+  warn("If you hit model high-load/resource-exhausted, retry with Auto/another model.");
+
+  if (mode === "cursor" || mode === "both") {
+    section("Cursor Agent Prompt");
+    console.log();
+    console.log(gray("─".repeat(50)));
+    console.log(cursorPrompt);
+    console.log(gray("─".repeat(50)));
+  }
+
+  if (mode === "generic" || mode === "both") {
+    section("Generic Agent Prompt");
+    console.log();
+    console.log(gray("─".repeat(50)));
+    console.log(genericPrompt);
+    console.log(gray("─".repeat(50)));
+  }
+
+  if (copyFlag) {
+    const textToCopy =
+      mode === "cursor"
+        ? cursorPrompt
+        : mode === "generic"
+          ? genericPrompt
+          : `## Cursor Agent Prompt\n\n${cursorPrompt}\n\n## Generic Agent Prompt\n\n${genericPrompt}`;
+    const ok = copyToClipboard(textToCopy);
+    if (ok) info(`Copied ${mode} prompt${mode === "both" ? "s" : ""} to clipboard.`);
+    else warn("Clipboard copy failed. Copy from terminal output.");
+  }
+
+  console.log();
+}

package/lib/commands/init.mjs

@@ -65,7 +65,11 @@ function upsertScripts(cwd, silent = false) {
   const toAdd = {
     "inferno:check":  "infernoflow check",
     "inferno:status": "infernoflow status",
-    "inferno:gate":   "infernoflow doc-gate"
+    "inferno:gate":   "infernoflow doc-gate",
+    "inferno:impact": "infernoflow pr-impact --json",
+    "inferno:sync":   "infernoflow sync --auto --json",
+    "inferno:run":    "infernoflow run \"sync check\" --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; }
@@ -167,6 +171,7 @@ export async function initCommand(args) {
   }
 
   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));
@@ -303,6 +308,12 @@ export async function initCommand(args) {
   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);
 

package/lib/commands/prImpact.mjs

@@ -0,0 +1,157 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { header, section, ok, warn, fail, gray, cyan, yellow } from "../ui/output.mjs";
+
+const CODE_PREFIXES = ["src/", "frontend/", "backend/", "app/", "pages/", "components/", "lib/", "api/", "server/", "Controllers/"];
+
+function sh(cmd) {
+  return execSync(cmd, { stdio: ["ignore", "pipe", "pipe"] }).toString("utf8").trim();
+}
+
+function readJson(filePath, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function readFile(filePath, fallback = "") {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+function getChangedFiles(base, head) {
+  const out = base && head
+    ? sh(`git diff --name-only ${base}..${head}`)
+    : sh("git diff --name-only HEAD");
+  return out ? out.split("\n").map((s) => s.trim()).filter(Boolean) : [];
+}
+
+function buildCapabilityHints(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  const contract = readJson(path.join(infernoDir, "contract.json"), { capabilities: [] });
+  const registry = readJson(path.join(infernoDir, "capabilities.json"), { capabilities: [] });
+  const titleById = new Map((registry.capabilities || []).map((c) => [c.id, c.title || c.id]));
+  return (contract.capabilities || []).map((id) => {
+    const title = titleById.get(id) || id;
+    const keywords = new Set(
+      `${id} ${title}`
+        .replace(/([A-Z])/g, " $1")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((k) => k.length >= 4)
+    );
+    return { id, title, keywords: Array.from(keywords) };
+  });
+}
+
+function inferImpactedCapabilities(cwd, changedCodeFiles) {
+  const hints = buildCapabilityHints(cwd);
+  const impacted = [];
+  for (const hint of hints) {
+    const matched = [];
+    for (const rel of changedCodeFiles) {
+      const abs = path.join(cwd, rel);
+      const text = readFile(abs, "").toLowerCase();
+      if (!text) continue;
+      if (hint.keywords.some((k) => text.includes(k))) {
+        matched.push(rel);
+      }
+    }
+    if (matched.length) {
+      impacted.push({ id: hint.id, title: hint.title, matchedFiles: matched.slice(0, 5) });
+    }
+  }
+  return impacted;
+}
+
+export async function prImpactCommand(args = []) {
+  const asJson = args.includes("--json");
+  const cwd = process.cwd();
+  const base = process.env.BASE_SHA || null;
+  const head = process.env.HEAD_SHA || null;
+
+  let changedFiles = [];
+  try {
+    changedFiles = getChangedFiles(base, head);
+  } catch {
+    const payload = { ok: true, skipped: true, reason: "no_git_available" };
+    if (asJson) {
+      console.log(JSON.stringify(payload, null, 2));
+      return;
+    }
+    header("pr-impact");
+    warn("git not available; cannot compute PR impact");
+    console.log();
+    return;
+  }
+
+  const changedCodeFiles = changedFiles.filter((f) => CODE_PREFIXES.some((p) => f.startsWith(p)));
+  const changedInfernoFiles = changedFiles.filter((f) => f.startsWith("inferno/"));
+  const impactedCapabilities = inferImpactedCapabilities(cwd, changedCodeFiles);
+  const inferredBehaviorChange = changedCodeFiles.length > 0;
+  const missingInfernoUpdate = inferredBehaviorChange && changedInfernoFiles.length === 0;
+  const confidence = impactedCapabilities.length > 0 ? "high" : inferredBehaviorChange ? "medium" : "low";
+  const reasonCodes = [];
+  if (inferredBehaviorChange) reasonCodes.push("CODE_CHANGED");
+  if (missingInfernoUpdate) reasonCodes.push("INFERNO_NOT_UPDATED");
+  if (impactedCapabilities.length > 0) reasonCodes.push("CAPABILITY_HINT_MATCH");
+  if (!reasonCodes.length) reasonCodes.push("NO_BEHAVIOR_SIGNAL");
+
+  const payload = {
+    ok: !missingInfernoUpdate,
+    base: base || "HEAD",
+    head: head || "WORKTREE",
+    changedFiles,
+    changedCodeFiles,
+    changedInfernoFiles,
+    inferredBehaviorChange,
+    impactedCapabilities,
+    confidence,
+    reasonCodes,
+    recommendations: missingInfernoUpdate
+      ? ["Run infernoflow suggest \"describe behavior change\" and update inferno/", "Run infernoflow check --json"]
+      : ["Run infernoflow check --json to validate final state"],
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  header("pr-impact");
+
+  section("Diff Scope");
+  ok(`Changed files: ${cyan(String(changedFiles.length))}`);
+  ok(`Code files: ${cyan(String(changedCodeFiles.length))}`);
+  ok(`Inferno files: ${cyan(String(changedInfernoFiles.length))}`);
+
+  section("Capability Impact");
+  if (impactedCapabilities.length === 0) {
+    warn("No capability hints matched changed code files");
+  } else {
+    impactedCapabilities.forEach((c) => {
+      console.log(`  ${cyan("•")} ${c.id} ${gray(`(${c.title})`)}`);
+      c.matchedFiles.slice(0, 3).forEach((f) => console.log(`      ${gray("- " + f)}`));
+    });
+  }
+
+  section("Doc Sync");
+  if (missingInfernoUpdate) {
+    fail("Code changed but inferno/ was not updated", "Run infernoflow suggest and then infernoflow check");
+  } else {
+    ok("No immediate inferno drift signal from changed files");
+  }
+  ok(`Confidence: ${cyan(confidence)}`);
+
+  section("Suggested Next");
+  payload.recommendations.forEach((r) => console.log(`  ${yellow("→")} ${r}`));
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
+

package/lib/commands/run.mjs

@@ -0,0 +1,227 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { generateWithLocalModel } from "../ai/localProvider.mjs";
+import {
+  buildPrompt,
+  loadSuggestContext,
+  parseSuggestionJson,
+  validateSuggestion,
+  detectSuggestionConflicts,
+  applyChanges,
+} from "./suggest.mjs";
+import { header, section, ok, warn, fail, info, gray } from "../ui/output.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const binPath = path.resolve(__dirname, "..", "..", "bin", "infernoflow.mjs");
+
+function runCliJson(args) {
+  try {
+    const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return { ok: true, data: JSON.parse(out) };
+  } catch (err) {
+    const stdout = err?.stdout?.toString?.() || "";
+    try {
+      return { ok: false, data: JSON.parse(stdout) };
+    } catch {
+      return { ok: false, data: { ok: false, errors: ["command_failed"] } };
+    }
+  }
+}
+
+function stageEvent(asJson, events, stage, status, details = {}) {
+  const ev = { ts: new Date().toISOString(), stage, status, ...details };
+  events.push(ev);
+  if (asJson) return;
+  const text = `${stage}: ${status}`;
+  if (status === "ok") ok(text);
+  else if (status === "warn") warn(text);
+  else if (status === "fail") fail(text);
+  else info(text);
+}
+
+function snapshotInferno(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  const targets = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else targets.push(p);
+    }
+  };
+  if (fs.existsSync(infernoDir)) walk(infernoDir);
+  const snapshot = new Map();
+  targets.forEach((filePath) => snapshot.set(filePath, fs.readFileSync(filePath, "utf8")));
+  return snapshot;
+}
+
+function restoreSnapshot(cwd, snapshot) {
+  const infernoDir = path.join(cwd, "inferno");
+  if (fs.existsSync(infernoDir)) {
+    const existing = [];
+    const walk = (dir) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, entry.name);
+        if (entry.isDirectory()) walk(p);
+        else existing.push(p);
+      }
+    };
+    walk(infernoDir);
+    existing.forEach((filePath) => {
+      if (!snapshot.has(filePath)) fs.unlinkSync(filePath);
+    });
+  }
+  for (const [filePath, content] of snapshot.entries()) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+}
+
+function writeRunArtifact(cwd, artifact) {
+  const runsDir = path.join(cwd, "inferno", "runs");
+  fs.mkdirSync(runsDir, { recursive: true });
+  const filePath = path.join(runsDir, `${Date.now()}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  return path.relative(cwd, filePath);
+}
+
+export async function runCommand(args = []) {
+  const asJson = args.includes("--json");
+  const dryRun = args.includes("--dry-run");
+  const noRollback = args.includes("--no-rollback");
+  const task = args.filter((a) => !a.startsWith("-")).slice(1).join(" ").trim() || "sync check";
+  const cwd = process.cwd();
+  const events = [];
+
+  if (!asJson) header("run");
+  stageEvent(asJson, events, "init", "info", { task, dryRun, noRollback });
+
+  // detect
+  const impact = runCliJson(["pr-impact", "--json"]);
+  stageEvent(asJson, events, "detect", impact.data?.ok ? "ok" : "warn", { confidence: impact.data?.confidence || "low" });
+
+  const ctx = loadSuggestContext(cwd);
+  if (!ctx?.contract) {
+    const payload = { ok: false, error: "inferno_missing", events };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("inferno/ missing or invalid");
+    process.exit(1);
+  }
+
+  // propose
+  const prompt = buildPrompt({
+    description: task,
+    contract: ctx.contract,
+    capabilities: ctx.capabilities,
+    scenarios: ctx.scenarios,
+  });
+  let suggestion;
+  try {
+    const raw = await generateWithLocalModel(prompt);
+    suggestion = parseSuggestionJson(raw);
+  } catch (err) {
+    const payload = { ok: false, error: "local_model_failed", reason: String(err.message || err), events };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail(`local model failed`, err.message);
+    process.exit(1);
+  }
+  stageEvent(asJson, events, "propose", "ok", {
+    newCapabilities: (suggestion.newCapabilities || []).length,
+    removedCapabilities: (suggestion.removedCapabilities || []).length,
+  });
+
+  const schemaErrors = validateSuggestion(suggestion);
+  const conflictErrors = detectSuggestionConflicts(ctx.contract, suggestion);
+  if (schemaErrors.length || conflictErrors.length) {
+    const payload = {
+      ok: false,
+      error: "invalid_suggestion",
+      issues: [...schemaErrors, ...conflictErrors],
+      events,
+    };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("suggestion invalid", payload.issues[0]);
+    process.exit(1);
+  }
+
+  const snapshot = snapshotInferno(cwd);
+  let rolledBack = false;
+  let applyChanged = false;
+  let validationPassed = false;
+
+  try {
+    if (dryRun) {
+      stageEvent(asJson, events, "apply", "info", { dryRun: true });
+    } else {
+      applyChanged = applyChanges({
+        cwd,
+        contract: ctx.contract,
+        capabilities: ctx.capabilities,
+        suggestion,
+        version: ctx.version,
+        quiet: asJson,
+      });
+      stageEvent(asJson, events, "apply", "ok", { changed: applyChanged });
+    }
+
+    let check = runCliJson(["check", "--json"]);
+    if (process.env.INFERNO_TEST_FORCE_VALIDATE_FAIL === "1") {
+      check = { ok: false, data: { ok: false, errors: ["forced_validation_failure"] } };
+    }
+    if (!check.ok || !check.data?.ok) {
+      throw new Error(`validation_failed:${(check.data?.errors || []).join(",")}`);
+    }
+    validationPassed = true;
+    stageEvent(asJson, events, "validate", "ok");
+  } catch (err) {
+    stageEvent(asJson, events, "validate", "fail", { reason: String(err.message || err) });
+    if (!dryRun && !noRollback) {
+      restoreSnapshot(cwd, snapshot);
+      rolledBack = true;
+      stageEvent(asJson, events, "rollback", "ok");
+    }
+  }
+
+  const artifact = {
+    task,
+    dryRun,
+    noRollback,
+    rolledBack,
+    applyChanged,
+    suggestionSummary: suggestion.summary || "",
+    touchedCapabilities: [
+      ...(suggestion.newCapabilities || []).map((c) => c.id),
+      ...(suggestion.removedCapabilities || []),
+    ],
+    events,
+  };
+  const artifactPath = writeRunArtifact(cwd, artifact);
+
+  const payload = {
+    ok: validationPassed,
+    mode: "run",
+    task,
+    dryRun,
+    rolledBack,
+    applyChanged,
+    artifactPath,
+    events,
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  section("Result");
+  info(`task: ${gray(task)}`);
+  info(`artifact: ${gray(artifactPath)}`);
+  if (payload.ok) ok("run completed");
+  else warn("run rolled back after failed validation");
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
+