infernoflow 0.10.5 → 0.10.6

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)
 

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,175 @@ function detectDevelopmentProfile(cwd, files, externalLibraries, overrides = {})
   };
 }
 
+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();
@@ -324,6 +519,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 +621,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 +692,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

@@ -216,6 +216,7 @@ export async function initCommand(args) {
             uiLayout: signals.uiLayout,
             styling: signals.styling,
             developmentProfile: signals.developmentProfile,
+            apiCalls: signals.apiCalls,
           },
           null,
           2
@@ -240,6 +241,7 @@ export async function initCommand(args) {
               uiLayout: signals.uiLayout,
               styling: signals.styling,
               developmentProfile: signals.developmentProfile,
+              apiCalls: signals.apiCalls,
             },
             null,
             2

package/package.json

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