infernoflow 0.10.4 → 0.10.6

package/README.md

@@ -56,6 +56,18 @@ Non-interactive adoption:
 infernoflow init --adopt --yes
 ```
 
+Override detected stack during adoption:
+
+```bash
+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
@@ -79,6 +91,8 @@ 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)
 
 Safety:
@@ -162,6 +176,7 @@ infernoflow doc-gate --json
 infernoflow init --force       # overwrite existing files
 infernoflow init --yes         # skip prompts, use defaults
 infernoflow init --adopt       # infer baseline from existing project
+infernoflow init --adopt --lang ts --framework react --project-type frontend
 infernoflow init --adopt --report-human-only
 infernoflow suggest "..."      # describe what changed
 infernoflow implement "..." --mode both

package/bin/infernoflow.mjs

@@ -45,6 +45,9 @@ ${formatCommandsHelp()}
 
   ${bold("init options:")}
     --adopt             Infer capabilities from an existing codebase
+    --lang <name>       Override detected language (e.g. ts, js, py)
+    --framework <name>  Override detected framework (e.g. react, angular, express)
+    --project-type <t>  Override project type (frontend|backend|fullstack|cli|library)
     --report-json       Print inferred adoption report as JSON
     --report-json-only  Print JSON report only (no human-readable logs)
     --report-human-only Print only human-readable adoption report (no JSON block)

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;
 }
 
@@ -218,7 +225,248 @@ function detectUiLayout(files) {
   };
 }
 
-export function discoverProjectSignals(cwd) {
+function detectDevelopmentProfile(cwd, files, externalLibraries, overrides = {}) {
+  const extCount = { ts: 0, js: 0, py: 0, java: 0, go: 0, rb: 0, rs: 0, cs: 0, php: 0 };
+  for (const filePath of files) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".ts" || ext === ".tsx") extCount.ts += 1;
+    if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") extCount.js += 1;
+    if (ext === ".py") extCount.py += 1;
+    if (ext === ".java") extCount.java += 1;
+    if (ext === ".go") extCount.go += 1;
+    if (ext === ".rb") extCount.rb += 1;
+    if (ext === ".rs") extCount.rs += 1;
+    if (ext === ".cs") extCount.cs += 1;
+    if (ext === ".php") extCount.php += 1;
+  }
+
+  const sortedLang = Object.entries(extCount).sort((a, b) => b[1] - a[1]);
+  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";
+  else if (hasDep("vue")) autoFramework = "vue";
+  else if (hasDep("svelte")) autoFramework = "svelte";
+  else if (hasDep("next")) autoFramework = "nextjs";
+  else if (hasDep("nuxt")) autoFramework = "nuxt";
+  else if (hasDep("express")) autoFramework = "express";
+  else if (hasDep("@nestjs/core")) autoFramework = "nestjs";
+  else if (hasDep("fastify")) autoFramework = "fastify";
+  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", "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,
+    framework: overrides.framework || autoFramework,
+    projectType: overrides.projectType || autoProjectType,
+    detected: {
+      language: autoLanguage,
+      framework: autoFramework,
+      projectType: autoProjectType,
+    },
+  };
+}
+
+function detectApiCalls(cwd, files) {
+  const calls = [];
+  const seen = new Set();
+  const addCall = (call) => {
+    const key = `${call.method}|${call.endpointPattern}|${call.sourceFile}|${call.style}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    calls.push(call);
+  };
+
+  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: normalizeExpr(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: normalizeExpr(firstArg),
+        style: "fetch",
+        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, "/");
+        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();
   const addHit = (cap, filePath) => {
@@ -270,6 +518,8 @@ export function discoverProjectSignals(cwd) {
     externalLibraries,
     uiLayout: detectUiLayout(files),
     styling: detectStyling(cwd, files, externalLibraries),
+    developmentProfile: detectDevelopmentProfile(cwd, files, externalLibraries, profileOverrides),
+    apiCalls: detectApiCalls(cwd, files),
   };
 }
 
@@ -366,6 +616,19 @@ export function buildSignalsReport(signals) {
     `  - frameworks : ${(signals.styling?.cssFrameworks || []).join(", ") || "none detected"}`,
     `  - style files: ${signals.styling?.styleFileCount ?? 0}`,
     `  - tokens     : ${(signals.styling?.designTokens || []).slice(0, 8).join(", ") || "none detected"}`,
+    "Development profile",
+    "-".repeat(56),
+    `  - 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");
 }
@@ -423,6 +686,13 @@ export function writeAdoptionBaseline(infernoDir, policyId, capabilities, signal
       externalLibraries: signals.externalLibraries || [],
       uiLayout: signals.uiLayout || { layoutType: "unknown", usesGrid: false, usesFlex: false, sections: [] },
       styling: signals.styling || { cssFrameworks: [], styleFileCount: 0, styleFilesSample: [], designTokens: [] },
+      developmentProfile: signals.developmentProfile || {
+        language: "unknown",
+        framework: "unknown",
+        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

@@ -27,6 +27,14 @@ function ask(rl, question, defaultVal = "") {
   });
 }
 
+function getArgValue(args, ...flags) {
+  for (const flag of flags) {
+    const i = args.indexOf(flag);
+    if (i !== -1 && args[i + 1] && !args[i + 1].startsWith("-")) return args[i + 1];
+  }
+  return null;
+}
+
 function copyFile(src, dst, force, silent = false) {
   if (fs.existsSync(dst) && !force) {
     if (!silent) warn("Skipped (exists): " + path.relative(process.cwd(), dst));
@@ -144,6 +152,9 @@ export async function initCommand(args) {
   const reportJson = args.includes("--report-json");
   const reportJsonOnly = args.includes("--report-json-only");
   const reportHumanOnly = args.includes("--report-human-only");
+  const langOverride = getArgValue(args, "--lang");
+  const frameworkOverride = getArgValue(args, "--framework");
+  const projectTypeOverride = getArgValue(args, "--project-type");
   const silent = reportJsonOnly;
 
   if (reportJsonOnly && reportHumanOnly) {
@@ -173,7 +184,23 @@ export async function initCommand(args) {
   let capabilities = defaultCaps.split(",").map(c => c.trim());
 
   if (adopt) {
-    const signals = discoverProjectSignals(cwd);
+    const profileOverrides = {
+      language: langOverride || undefined,
+      framework: frameworkOverride || undefined,
+      projectType: projectTypeOverride || undefined,
+    };
+    let signals = discoverProjectSignals(cwd, profileOverrides);
+    if (!yes && !reportJsonOnly) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const profile = signals.developmentProfile || {};
+      const detected = profile.detected || {};
+      console.log(gray("  Review inferred development stack (press Enter to accept detected values)\n"));
+      const language = await ask(rl, "Language", profile.language || detected.language || "unknown");
+      const framework = await ask(rl, "Framework", profile.framework || detected.framework || "unknown");
+      const projectType = await ask(rl, "Project type", profile.projectType || detected.projectType || "unknown");
+      rl.close();
+      signals = discoverProjectSignals(cwd, { language, framework, projectType });
+    }
     const inferred = signals.capabilities;
     const summarized = summarizeCapabilities(inferred);
     if (reportJsonOnly) {
@@ -188,6 +215,8 @@ export async function initCommand(args) {
             externalLibraries: signals.externalLibraries,
             uiLayout: signals.uiLayout,
             styling: signals.styling,
+            developmentProfile: signals.developmentProfile,
+            apiCalls: signals.apiCalls,
           },
           null,
           2
@@ -211,6 +240,8 @@ export async function initCommand(args) {
               externalLibraries: signals.externalLibraries,
               uiLayout: signals.uiLayout,
               styling: signals.styling,
+              developmentProfile: signals.developmentProfile,
+              apiCalls: signals.apiCalls,
             },
             null,
             2
@@ -240,7 +271,11 @@ export async function initCommand(args) {
       id,
       title: id.replace(/([A-Z])/g, " $1").trim(),
     }));
-    const signals = discoverProjectSignals(cwd);
+    const signals = discoverProjectSignals(cwd, {
+      language: langOverride || undefined,
+      framework: frameworkOverride || undefined,
+      projectType: projectTypeOverride || undefined,
+    });
     writeAdoptionBaseline(infernoDir, policyId, capDetails, signals);
     if (!silent) {
       ok("Created: " + cyan("inferno/contract.json"));
@@ -271,6 +306,22 @@ export async function initCommand(args) {
 
   upsertScripts(cwd, silent);
 
+  if (adopt) {
+    const statePath = path.join(infernoDir, "context-state.json");
+    let state = {};
+    try {
+      state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    } catch {}
+    const signals = discoverProjectSignals(cwd, {
+      language: langOverride || undefined,
+      framework: frameworkOverride || undefined,
+      projectType: projectTypeOverride || undefined,
+    });
+    state.stack = signals.developmentProfile;
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+    if (!silent) ok("Created: " + cyan("inferno/context-state.json"));
+  }
+
   if (!silent) {
     done("infernoflow initialized!");
 

package/package.json

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