infernoflow 0.10.6 → 0.10.7

package/README.md

@@ -166,6 +166,8 @@ infernoflow doc-gate --json
 | `infernoflow status` | At-a-glance health of your contract |
 | `infernoflow suggest` | Generate an AI prompt, apply capability updates |
 | `infernoflow implement` | Generate implementation prompts for coding agents |
+| `infernoflow pr-impact` | Analyze changed files and infer capability/doc drift |
+| `infernoflow sync --auto` | Deterministic sync flow for agents (skeleton) |
 | `infernoflow check` | Full validation: contract, capabilities, scenarios, changelog |
 | `infernoflow doc-gate` | Fails if code changed but docs weren't updated |
 | `infernoflow context` | Build/persist AI session context for this project |
@@ -183,6 +185,11 @@ infernoflow implement "..." --mode both
 infernoflow implement "..." --mode cursor
 infernoflow implement "..." --mode generic
 infernoflow implement "..." --mode both --copy
+infernoflow pr-impact
+infernoflow pr-impact --json
+infernoflow sync --auto
+infernoflow sync --auto --json
+npm run inferno:hooks      # install local git hooks (after init)
 infernoflow check --json       # machine-readable output for CI
 infernoflow check --skip-doc-gate
 infernoflow status --json      # machine-readable status summary
@@ -272,13 +279,25 @@ Recommended chain:
 
 ```yaml
 # .github/workflows/ci.yml
-- name: infernoflow check
-  run: npx infernoflow check --json
+- name: infernoflow impact + check
+  run: |
+    npx infernoflow pr-impact --json
+    npx infernoflow check --json
   env:
     BASE_SHA: ${{ github.event.pull_request.base.sha }}
     HEAD_SHA: ${{ github.event.pull_request.head.sha }}
 ```
 
+When you run `infernoflow init`, it now scaffolds:
+- `scripts/inferno-install-hooks.mjs`
+- `.github/workflows/infernoflow-check.yml`
+
+Install local hooks once per clone:
+
+```bash
+npm run inferno:hooks
+```
+
 ## Release Checklist
 
 ```bash

package/bin/infernoflow.mjs

@@ -11,6 +11,8 @@ const COMMAND_DESCRIPTIONS = {
   init: "Scaffold inferno/ in your project (or adopt existing project)",
   check: "Validate contract, capabilities, scenarios, changelog",
   status: "Show contract health at a glance",
+  "pr-impact": "Summarize PR impact on capabilities and docs",
+  sync: "Run deterministic inferno sync flow",
   "doc-gate": "Fail if code changed but docs were not updated",
   suggest: "Generate AI prompt + apply capability updates",
   implement: "Generate code-agent implementation prompt(s)",
@@ -21,6 +23,8 @@ const COMMAND_HANDLERS = {
   init: async (args) => (await import("../lib/commands/init.mjs")).initCommand(args),
   check: async (args) => (await import("../lib/commands/check.mjs")).checkCommand(args),
   status: async (args) => (await import("../lib/commands/status.mjs")).statusCommand(args),
+  "pr-impact": async (args) => (await import("../lib/commands/prImpact.mjs")).prImpactCommand(args),
+  sync: async (args) => (await import("../lib/commands/syncAuto.mjs")).syncCommand(args),
   suggest: async (args) => (await import("../lib/commands/suggest.mjs")).suggestCommand(args),
   implement: async (args) => (await import("../lib/commands/implement.mjs")).implementCommand(args),
   context: async (args) => (await import("../lib/commands/context.mjs")).contextCommand(args),
@@ -77,6 +81,8 @@ ${formatCommandsHelp()}
     ${gray("status --json")}
     ${gray("check --json")}
     ${gray("doc-gate --json")}
+    ${gray("pr-impact --json")}
+    ${gray("sync --auto --json")}
 `;
 
 const [, , cmd, ...rest] = process.argv;

package/lib/commands/adopt.mjs

@@ -300,11 +300,25 @@ function detectDevelopmentProfile(cwd, files, externalLibraries, overrides = {})
 function detectApiCalls(cwd, files) {
   const calls = [];
   const seen = new Set();
+  const normalizeEndpointPattern = (value) => {
+    let out = String(value || "").trim();
+    if (!out) return "";
+    out = out.replace(/https?:\/\/[^/]+/gi, "");
+    out = out.replace(/\$\{[^}]+\}/g, "{var}");
+    out = out.replace(/\{[A-Za-z_][A-Za-z0-9_]*\}/g, "{var}");
+    out = out.replace(/:[A-Za-z_][A-Za-z0-9_]*/g, "{var}");
+    out = out.replace(/\/\d+(?=\/|$)/g, "/{id}");
+    out = out.replace(/=[^&\s]+/g, "={value}");
+    out = out.replace(/\/+/g, "/");
+    return out;
+  };
   const addCall = (call) => {
-    const key = `${call.method}|${call.endpointPattern}|${call.sourceFile}|${call.style}`;
+    const endpointPattern = normalizeEndpointPattern(call.endpointPattern);
+    if (!endpointPattern) return;
+    const key = `${call.method}|${endpointPattern}|${call.sourceFile}|${call.style}`;
     if (seen.has(key)) return;
     seen.add(key);
-    calls.push(call);
+    calls.push({ ...call, endpointPattern });
   };
 
   for (const filePath of files) {
@@ -393,7 +407,7 @@ function detectApiCalls(cwd, files) {
       if (!raw || !isLikelyEndpoint(raw)) continue;
       addCall({
         method,
-        endpointPattern: normalizeExpr(raw),
+        endpointPattern: raw,
         style: "httpClient",
         sourceFile: rel,
       });
@@ -409,12 +423,54 @@ function detectApiCalls(cwd, files) {
       const method = (methodMatch?.[1] || "GET").toUpperCase();
       addCall({
         method,
-        endpointPattern: normalizeExpr(firstArg),
+        endpointPattern: firstArg,
         style: "fetch",
         sourceFile: rel,
       });
     }
 
+    const axiosPattern = /\baxios\.(get|post|put|patch|delete)\s*\(\s*([\s\S]*?)(?:,|\))/gi;
+    for (const m of normalized.matchAll(axiosPattern)) {
+      const method = m[1].toUpperCase();
+      const endpoint = resolveExpr(m[2]);
+      if (!endpoint || !isLikelyEndpoint(endpoint)) continue;
+      addCall({
+        method,
+        endpointPattern: endpoint,
+        style: "axios",
+        sourceFile: rel,
+      });
+    }
+
+    const axiosObjPattern = /\baxios\s*\(\s*\{([\s\S]*?)\}\s*\)/gi;
+    for (const m of normalized.matchAll(axiosObjPattern)) {
+      const body = m[1];
+      const methodMatch = /\bmethod\s*:\s*["']?(get|post|put|patch|delete)["']?/i.exec(body);
+      const urlMatch = /\burl\s*:\s*([^,\n]+)/i.exec(body);
+      const method = (methodMatch?.[1] || "get").toUpperCase();
+      const endpoint = resolveExpr(urlMatch?.[1] || "");
+      if (!endpoint || !isLikelyEndpoint(endpoint)) continue;
+      addCall({
+        method,
+        endpointPattern: endpoint,
+        style: "axios-config",
+        sourceFile: rel,
+      });
+    }
+
+    const requestPattern = /\.\s*request\s*\(\s*["'](GET|POST|PUT|PATCH|DELETE)["']\s*,\s*([\s\S]*?)(?:,|\))/gi;
+    for (const m of normalized.matchAll(requestPattern)) {
+      const method = m[1].toUpperCase();
+      const endpoint = resolveExpr(m[2]);
+      if (!endpoint || !isLikelyEndpoint(endpoint)) continue;
+      addCall({
+        method,
+        endpointPattern: endpoint,
+        style: "request",
+        sourceFile: rel,
+      });
+    }
+
     if (/\.cs$/i.test(filePath)) {
       const mapPattern = /\bapp\.Map(Get|Post|Put|Delete|Patch)\s*\(\s*"([^"]+)"/gi;
       for (const m of normalized.matchAll(mapPattern)) {
@@ -432,7 +488,7 @@ function detectApiCalls(cwd, files) {
       for (const m of normalized.matchAll(attrPattern)) {
         const method = m[1].replace("Http", "").toUpperCase();
         const attrRoute = m[2] || "";
-        const endpoint = [classRoute, attrRoute].filter(Boolean).join("/").replace(/\/+/g, "/");
+        const endpoint = [classRoute, attrRoute].filter(Boolean).join("/").replace(/\/+/g, "/").replace(/\[controller\]/gi, "{controller}");
         addCall({
           method,
           endpointPattern: endpoint || classRoute || "{controller-route}",

package/lib/commands/init.mjs

@@ -65,7 +65,10 @@ 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: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 +170,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 +307,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/syncAuto.mjs

@@ -0,0 +1,96 @@
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { header, section, ok, warn, yellow, 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) {
+  const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return JSON.parse(out);
+}
+
+function tryRunCliJson(args) {
+  try {
+    return { ok: true, data: runCliJson(args) };
+  } 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"] } };
+    }
+  }
+}
+
+export async function syncCommand(args = []) {
+  const auto = args.includes("--auto");
+  const asJson = args.includes("--json");
+  const dryRun = args.includes("--dry-run");
+
+  if (!auto) {
+    const payload = { ok: false, error: "missing_required_flag", hint: "Use: infernoflow sync --auto" };
+    if (asJson) {
+      console.log(JSON.stringify(payload, null, 2));
+      process.exit(1);
+    }
+    header("sync");
+    warn("missing --auto flag");
+    console.log(`  ${yellow("→")} infernoflow sync --auto`);
+    console.log();
+    process.exit(1);
+  }
+
+  const impact = tryRunCliJson(["pr-impact", "--json"]);
+  const needsSync = !impact.data?.ok;
+  const confidence = impact.data?.confidence || "low";
+  const policyDecision = confidence === "high" ? "auto" : confidence === "medium" ? "ask" : "block";
+  const actions = needsSync
+    ? ["Generate inferno update proposal (suggest)", "Review changes", "Validate with check --json"]
+    : ["No inferno drift detected", "Validate with check --json"];
+
+  const check = tryRunCliJson(["check", "--json"]);
+  const payload = {
+    ok: impact.ok && check.ok && !!check.data?.ok,
+    mode: "auto-skeleton",
+    dryRun,
+    needsSync,
+    didApply: false,
+    confidence,
+    policyDecision,
+    actions,
+    prImpact: impact.data,
+    postCheck: check.data,
+    reasonCodes: [
+      ...(needsSync ? ["DRIFT_DETECTED"] : ["NO_DRIFT"]),
+      `POLICY_${policyDecision.toUpperCase()}`,
+      ...(policyDecision === "auto" ? ["AUTO_APPLY_DISABLED_IN_SKELETON"] : []),
+    ],
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  header("sync --auto");
+  section("State");
+  if (needsSync) warn("Inferno drift detected");
+  else ok("No inferno drift detected");
+  ok(`Confidence: ${gray(confidence)}`);
+  ok(`Policy decision: ${gray(policyDecision)}`);
+  ok(`Apply mode: ${gray("skeleton (no file writes)")}`);
+  if (dryRun) ok("Dry run enabled");
+
+  section("Plan");
+  actions.forEach((a) => console.log(`  ${yellow("→")} ${a}`));
+
+  section("Validation");
+  if (check.ok && check.data?.ok) ok("Post-check passed");
+  else warn("Post-check failed; see infernoflow check --json");
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "description": "The forge for liquid code — keep capabilities, contracts, and docs in sync.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "README.md"
   ],
   "scripts": {
-    "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs",
+    "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs && node scripts/adopt-smoke.mjs && node scripts/pr-impact-smoke.mjs && node scripts/sync-smoke.mjs",
     "test:help": "node bin/infernoflow.mjs --help"
   },
   "keywords": [

package/templates/ci/github-inferno-check.yml

@@ -0,0 +1,36 @@
+name: infernoflow-check
+
+on:
+  pull_request:
+  push:
+    branches: [main, master]
+
+jobs:
+  inferno:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        run: npm ci --ignore-scripts || npm install --ignore-scripts
+
+      - name: Inferno PR impact
+        run: npx infernoflow pr-impact --json
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
+
+      - name: Inferno check
+        run: npx infernoflow check --json
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
+

package/templates/scripts/inferno-install-hooks.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const cwd = process.cwd();
+const gitDir = path.join(cwd, ".git");
+const hooksDir = path.join(gitDir, "hooks");
+
+if (!fs.existsSync(gitDir)) {
+  console.error("[inferno hooks] .git not found. Run inside a git repository.");
+  process.exit(1);
+}
+
+fs.mkdirSync(hooksDir, { recursive: true });
+
+const preCommit = `#!/bin/sh
+echo "[inferno hooks] pre-commit: infernoflow check --skip-doc-gate"
+npx infernoflow check --skip-doc-gate
+`;
+
+const prePush = `#!/bin/sh
+echo "[inferno hooks] pre-push: infernoflow doc-gate"
+npx infernoflow doc-gate
+`;
+
+const writeHook = (name, content) => {
+  const filePath = path.join(hooksDir, name);
+  fs.writeFileSync(filePath, content, "utf8");
+  fs.chmodSync(filePath, 0o755);
+  console.log(`[inferno hooks] installed ${name}`);
+};
+
+writeHook("pre-commit", preCommit);
+writeHook("pre-push", prePush);
+console.log("[inferno hooks] done");
+