infernoflow 0.10.5 → 0.10.7

package/README.md

@@ -62,6 +62,12 @@ Override detected stack during adoption:
 infernoflow init --adopt --lang ts --framework angular --project-type frontend
 ```
 
+C# / ASP.NET example:
+
+```bash
+infernoflow init --adopt --lang cs --framework aspnet --project-type backend --report-human-only
+```
+
 JSON report for CI/logging:
 
 ```bash
@@ -85,6 +91,7 @@ What adoption creates:
 - `inferno/capabilities.json` (inferred registry)
 - `inferno/scenarios/adoption_baseline.json` (coverage baseline)
 - `inferno/adoption_profile.json` (detected components, display fields, external libraries, UI layout, styling hints)
+- `inferno/adoption_profile.json` (detected components, display fields, external libraries, UI layout, styling hints, API call map)
 - `inferno/context-state.json` (saved development profile: language/framework/project type)
 - `inferno/CHANGELOG.md` (adoption entry)
 
@@ -159,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 |
@@ -176,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
@@ -265,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

@@ -43,7 +43,7 @@ export function discoverCapabilities(cwd) {
 
 function collectCodeFiles(cwd) {
   const files = [];
-  const roots = ["src", "server", "app", "backend", "frontend", "api"];
+  const roots = ["src", "server", "app", "backend", "frontend", "api", "Controllers"];
   for (const r of roots) {
     const root = path.join(cwd, r);
     if (!fs.existsSync(root)) continue;
@@ -55,12 +55,19 @@ function collectCodeFiles(cwd) {
         if (entry.isDirectory()) {
           if (["node_modules", ".git", "dist", "build"].includes(entry.name)) continue;
           stack.push(p);
-        } else if (/\.(js|jsx|ts|tsx|mjs|cjs|json|md|html|htm)$/.test(entry.name)) {
+        } else if (/\.(js|jsx|ts|tsx|mjs|cjs|json|md|html|htm|cs|csproj)$/.test(entry.name)) {
           files.push(p);
         }
       }
     }
   }
+  // Include common root-level .NET entry files without scanning the whole repo.
+  for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (/^(Program\.cs|.+\.csproj)$/i.test(entry.name)) {
+      files.push(path.join(cwd, entry.name));
+    }
+  }
   return files;
 }
 
@@ -237,6 +244,21 @@ function detectDevelopmentProfile(cwd, files, externalLibraries, overrides = {})
   const autoLanguage = sortedLang[0]?.[1] > 0 ? sortedLang[0][0] : "unknown";
 
   let autoFramework = "unknown";
+  let hasDotnetWebSdk = false;
+  let hasMinimalApi = false;
+  let hasBlazor = false;
+  for (const filePath of files) {
+    const base = path.basename(filePath).toLowerCase();
+    if (base.endsWith(".csproj")) {
+      const text = safeRead(filePath);
+      if (/Microsoft\.NET\.Sdk\.Web/i.test(text)) hasDotnetWebSdk = true;
+      if (/Blazor/i.test(text) || /Microsoft\.AspNetCore\.Components/i.test(text)) hasBlazor = true;
+    }
+    if (base === "program.cs") {
+      const text = safeRead(filePath);
+      if (/app\.Map(Get|Post|Put|Delete|Patch)\s*\(/i.test(text)) hasMinimalApi = true;
+    }
+  }
   const hasDep = (name) => externalLibraries.includes(name);
   if (externalLibraries.some((d) => d.startsWith("@angular/"))) autoFramework = "angular";
   else if (hasDep("react")) autoFramework = "react";
@@ -250,14 +272,18 @@ function detectDevelopmentProfile(cwd, files, externalLibraries, overrides = {})
   else if (hasDep("flask")) autoFramework = "flask";
   else if (hasDep("django")) autoFramework = "django";
   else if (hasDep("spring-boot")) autoFramework = "spring";
+  else if (hasBlazor) autoFramework = "blazor";
+  else if (hasMinimalApi) autoFramework = "minimalapi";
+  else if (hasDotnetWebSdk || extCount.cs > 0) autoFramework = "aspnet";
 
   let autoProjectType = "fullstack";
   const hasClientRoots = ["src", "frontend", "app"].some((d) => fs.existsSync(path.join(cwd, d)));
   const hasServerRoots = ["server", "backend", "api"].some((d) => fs.existsSync(path.join(cwd, d)));
   if (["react", "angular", "vue", "svelte", "nextjs", "nuxt"].includes(autoFramework)) autoProjectType = "frontend";
-  if (["express", "nestjs", "fastify", "flask", "django", "spring"].includes(autoFramework)) autoProjectType = "backend";
+  if (["express", "nestjs", "fastify", "flask", "django", "spring", "aspnet", "minimalapi"].includes(autoFramework)) autoProjectType = "backend";
   if (hasClientRoots && hasServerRoots) autoProjectType = "fullstack";
   if (!hasClientRoots && !hasServerRoots) autoProjectType = "library";
+  if (autoFramework === "blazor") autoProjectType = "frontend";
 
   return {
     language: overrides.language || autoLanguage,
@@ -271,6 +297,231 @@ 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 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, endpointPattern });
+  };
+
+  for (const filePath of files) {
+    if (!/\.(ts|tsx|js|jsx|mjs|cjs|cs)$/i.test(filePath)) continue;
+    const rel = path.relative(cwd, filePath);
+    const text = safeRead(filePath);
+    const looksLikeService = /service|api|client|controller|program\.cs/i.test(rel) || /HttpClient|fetch\(|app\.Map(Get|Post|Put|Delete|Patch)\(/i.test(text);
+    if (!looksLikeService) continue;
+
+    const normalized = text.replace(/\r\n/g, "\n");
+
+    const constStrings = {};
+    const normalizeExpr = (expr) => {
+      let out = String(expr || "").trim();
+      if (!out) return "";
+      out = out.replace(/;+$/, "").trim();
+      out = out.replace(/\(\s*$/, ""); // e.g. "this._nextPage("
+      // unwrap surrounding quotes/templates
+      while ((out.startsWith("'") && out.endsWith("'")) || (out.startsWith('"') && out.endsWith('"')) || (out.startsWith("`") && out.endsWith("`"))) {
+        out = out.slice(1, -1).trim();
+      }
+      return out;
+    };
+    const isLikelyEndpoint = (value) => {
+      const v = String(value || "").trim();
+      if (!v) return false;
+      if (/^https?:\/\//i.test(v)) return true;
+      if (v.startsWith("/")) return true;
+      if (/\bapi\b/i.test(v)) return true;
+      if (/\$\{[^}]+\}/.test(v)) return true;
+      if (/\?[^=\s]+=?/.test(v)) return true;
+      if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_./${}-]+$/.test(v)) return true;
+      return false;
+    };
+    const storeConst = (name, raw) => {
+      if (!name || !raw) return;
+      constStrings[name] = normalizeExpr(raw);
+    };
+
+    const constPattern = /(?:const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]*?);/g;
+    for (const m of normalized.matchAll(constPattern)) {
+      storeConst(m[1], m[2]);
+    }
+    const readonlyPattern =
+      /(?:public|private|protected)?\s*(?:readonly\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]*?);/g;
+    for (const m of normalized.matchAll(readonlyPattern)) {
+      storeConst(m[1], m[2]);
+    }
+
+    const resolveExpr = (expr) => {
+      const trimmed = normalizeExpr(expr);
+      if (!trimmed) return "";
+      if (/^['"`][\s\S]*['"`]$/.test(trimmed)) {
+        return trimmed.replace(/^['"`]|['"`]$/g, "");
+      }
+      if (constStrings[trimmed] && isLikelyEndpoint(constStrings[trimmed])) return constStrings[trimmed];
+      const thisRef = trimmed.match(/^this\.([A-Za-z_][A-Za-z0-9_]*)$/);
+      if (thisRef && constStrings[thisRef[1]] && isLikelyEndpoint(constStrings[thisRef[1]])) return constStrings[thisRef[1]];
+      const parts = trimmed.split("+").map((s) => s.trim()).filter(Boolean);
+      if (parts.length > 1) {
+        const rebuilt = parts
+          .map((p) => {
+            if (/^['"`][\s\S]*['"`]$/.test(p)) return p.replace(/^['"`]|['"`]$/g, "");
+            if (constStrings[p] && isLikelyEndpoint(constStrings[p])) return constStrings[p];
+            const thisP = p.match(/^this\.([A-Za-z_][A-Za-z0-9_]*)$/);
+            if (thisP && constStrings[thisP[1]] && isLikelyEndpoint(constStrings[thisP[1]])) return constStrings[thisP[1]];
+            return `{${p}}`;
+          })
+          .join("");
+        if (rebuilt) return rebuilt;
+      }
+      const ternary = trimmed.match(/^(.+?)\?(.+?):(.+)$/s);
+      if (ternary) {
+        const left = resolveExpr(ternary[2]);
+        const right = resolveExpr(ternary[3]);
+        if (left || right) return `${left || "{optionA}"} | ${right || "{optionB}"}`;
+      }
+      return trimmed;
+    };
+
+    const httpClientPattern =
+      /\.\s*(get|post|put|patch|delete)\s*(?:<[\s\S]*?>)?\s*\(\s*([\s\S]*?)(?:,|\))/gi;
+    for (const m of normalized.matchAll(httpClientPattern)) {
+      const method = m[1].toUpperCase();
+      const raw = resolveExpr(m[2]);
+      if (!raw || !isLikelyEndpoint(raw)) continue;
+      addCall({
+        method,
+        endpointPattern: raw,
+        style: "httpClient",
+        sourceFile: rel,
+      });
+    }
+
+    const fetchPattern = /\bfetch\s*\(\s*([\s\S]*?)(?:,|\))/gi;
+    for (const m of normalized.matchAll(fetchPattern)) {
+      const firstArg = resolveExpr(m[1]);
+      if (!firstArg || !isLikelyEndpoint(firstArg)) continue;
+      const fromIdx = m.index || 0;
+      const lookahead = normalized.slice(fromIdx, fromIdx + 260);
+      const methodMatch = /method\s*:\s*["'](GET|POST|PUT|PATCH|DELETE)["']/i.exec(lookahead);
+      const method = (methodMatch?.[1] || "GET").toUpperCase();
+      addCall({
+        method,
+        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)) {
+        addCall({
+          method: m[1].toUpperCase(),
+          endpointPattern: m[2],
+          style: "csharp-map",
+          sourceFile: rel,
+        });
+      }
+
+      const classRouteMatch = /\[Route\("([^"]+)"\)\][\s\S]*?class\s+\w+/i.exec(normalized);
+      const classRoute = classRouteMatch ? classRouteMatch[1] : "";
+      const attrPattern = /\[(HttpGet|HttpPost|HttpPut|HttpDelete|HttpPatch)(?:\("([^"]*)"\))?\]/gi;
+      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, "/").replace(/\[controller\]/gi, "{controller}");
+        addCall({
+          method,
+          endpointPattern: endpoint || classRoute || "{controller-route}",
+          style: "csharp-controller",
+          sourceFile: rel,
+        });
+      }
+
+      const httpClientPattern = /\b(GetAsync|PostAsync|PutAsync|DeleteAsync|SendAsync)\s*\(\s*"([^"]+)"/gi;
+      for (const m of normalized.matchAll(httpClientPattern)) {
+        const method = m[1].replace("Async", "").replace("Send", "SEND").toUpperCase();
+        addCall({
+          method,
+          endpointPattern: m[2],
+          style: "csharp-httpclient",
+          sourceFile: rel,
+        });
+      }
+    }
+  }
+
+  const byMethod = calls.reduce((acc, c) => {
+    acc[c.method] = (acc[c.method] || 0) + 1;
+    return acc;
+  }, {});
+
+  return {
+    totalCalls: calls.length,
+    byMethod,
+    calls: calls.slice(0, 80),
+  };
+}
+
 export function discoverProjectSignals(cwd, profileOverrides = {}) {
   const files = collectCodeFiles(cwd);
   const inferred = new Map();
@@ -324,6 +575,7 @@ export function discoverProjectSignals(cwd, profileOverrides = {}) {
     uiLayout: detectUiLayout(files),
     styling: detectStyling(cwd, files, externalLibraries),
     developmentProfile: detectDevelopmentProfile(cwd, files, externalLibraries, profileOverrides),
+    apiCalls: detectApiCalls(cwd, files),
   };
 }
 
@@ -425,6 +677,14 @@ export function buildSignalsReport(signals) {
     `  - language    : ${signals.developmentProfile?.language || "unknown"} (auto: ${signals.developmentProfile?.detected?.language || "unknown"})`,
     `  - framework   : ${signals.developmentProfile?.framework || "unknown"} (auto: ${signals.developmentProfile?.detected?.framework || "unknown"})`,
     `  - project type: ${signals.developmentProfile?.projectType || "unknown"} (auto: ${signals.developmentProfile?.detected?.projectType || "unknown"})`,
+    "API calls",
+    "-".repeat(56),
+    `  - total calls : ${signals.apiCalls?.totalCalls ?? 0}`,
+    `  - by method   : ${Object.entries(signals.apiCalls?.byMethod || {}).map(([k, v]) => `${k}:${v}`).join(", ") || "none"}`,
+    ...(signals.apiCalls?.calls || []).slice(0, 6).map((c) => `  - ${c.method} ${c.endpointPattern} [${c.style}] (${c.sourceFile})`),
+    ...((signals.apiCalls?.calls || []).length > 6
+      ? [`  - ... +${(signals.apiCalls?.calls || []).length - 6} more`]
+      : []),
     "=".repeat(56),
   ].join("\n");
 }
@@ -488,6 +748,7 @@ export function writeAdoptionBaseline(infernoDir, policyId, capabilities, signal
         projectType: "unknown",
         detected: { language: "unknown", framework: "unknown", projectType: "unknown" },
       },
+      apiCalls: signals.apiCalls || { totalCalls: 0, byMethod: {}, calls: [] },
     };
     fs.writeFileSync(path.join(infernoDir, "adoption_profile.json"), JSON.stringify(profile, null, 2) + "\n");
   }

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));
@@ -216,6 +220,7 @@ export async function initCommand(args) {
             uiLayout: signals.uiLayout,
             styling: signals.styling,
             developmentProfile: signals.developmentProfile,
+            apiCalls: signals.apiCalls,
           },
           null,
           2
@@ -240,6 +245,7 @@ export async function initCommand(args) {
               uiLayout: signals.uiLayout,
               styling: signals.styling,
               developmentProfile: signals.developmentProfile,
+              apiCalls: signals.apiCalls,
             },
             null,
             2
@@ -301,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.5",
+  "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");
+