infernoflow 0.10.3 → 0.10.5

package/README.md

@@ -56,6 +56,12 @@ Non-interactive adoption:
 infernoflow init --adopt --yes
 ```
 
+Override detected stack during adoption:
+
+```bash
+infernoflow init --adopt --lang ts --framework angular --project-type frontend
+```
+
 JSON report for CI/logging:
 
 ```bash
@@ -68,10 +74,18 @@ JSON-only output (clean machine output, no text logs):
 infernoflow init --adopt --yes --report-json-only
 ```
 
+Human-only output (visual report only, no JSON block):
+
+```bash
+infernoflow init --adopt --yes --report-human-only
+```
+
 What adoption creates:
 - `inferno/contract.json` (inferred capability baseline)
 - `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/context-state.json` (saved development profile: language/framework/project type)
 - `inferno/CHANGELOG.md` (adoption entry)
 
 Safety:
@@ -155,6 +169,8 @@ 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
 infernoflow implement "..." --mode cursor

package/bin/infernoflow.mjs

@@ -45,8 +45,12 @@ ${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)
     --yes, -y           Skip prompts and accept inferred/default values
     --force, -f         Overwrite existing inferno/ files
 

package/lib/commands/adopt.mjs

@@ -38,6 +38,10 @@ const HEURISTICS = [
 ];
 
 export function discoverCapabilities(cwd) {
+  return discoverProjectSignals(cwd).capabilities;
+}
+
+function collectCodeFiles(cwd) {
   const files = [];
   const roots = ["src", "server", "app", "backend", "frontend", "api"];
   for (const r of roots) {
@@ -51,13 +55,224 @@ export function discoverCapabilities(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)$/.test(entry.name)) {
+        } else if (/\.(js|jsx|ts|tsx|mjs|cjs|json|md|html|htm)$/.test(entry.name)) {
           files.push(p);
         }
       }
     }
   }
+  return files;
+}
+
+function detectComponents(files, cwd) {
+  const names = new Set();
+  for (const filePath of files) {
+    const rel = path.relative(cwd, filePath);
+    const text = safeRead(filePath);
+    const classMatches = text.matchAll(/\bclass\s+([A-Z][A-Za-z0-9_]*?(?:Component|Page|View|Widget|Card))\b/g);
+    for (const m of classMatches) names.add(m[1]);
+    const selectorMatches = text.matchAll(/\bselector\s*:\s*["']([^"']+)["']/g);
+    for (const m of selectorMatches) names.add(m[1]);
+    const reactFnMatches = text.matchAll(/\bfunction\s+([A-Z][A-Za-z0-9_]*)\s*\(/g);
+    for (const m of reactFnMatches) {
+      if (/component|page|view|card|chart|dashboard/i.test(m[1])) names.add(m[1]);
+    }
+    const relMatch = rel.match(/([^/\\]+)\.(component|page|view|widget|card)\.(ts|tsx|js|jsx)$/i);
+    if (relMatch) names.add(relMatch[1]);
+  }
+  return Array.from(names).sort();
+}
+
+function detectDisplayFields(files) {
+  const fields = new Set();
+  const methodNames = new Set();
+  const stopWords = new Set([
+    "if", "for", "while", "const", "let", "var", "return", "function", "class", "import", "export",
+    "null", "undefined", "true", "false", "string", "number", "boolean", "any", "unknown", "never",
+    "selector", "templateUrl", "styleUrl", "standalone", "imports", "providers", "providedIn",
+    "options", "scales", "responsive", "display", "title", "type", "label",
+    "component", "service", "routes", "appConfig", "ApplicationConfig",
+  ]);
+  const add = (v) => {
+    if (!v) return;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(v)) return;
+    if (v.length <= 1) return;
+    if (stopWords.has(v)) return;
+    if (/^[A-Z0-9_]+$/.test(v)) return;
+    fields.add(v);
+  };
+  for (const filePath of files) {
+    const text = safeRead(filePath);
+    if (/\.(html|htm)$/i.test(filePath)) {
+      const angularInterpolations = text.matchAll(/\{\{\s*(?:this\.)?([a-zA-Z_][a-zA-Z0-9_]*)/g);
+      for (const m of angularInterpolations) add(m[1]);
+      const ngModels = text.matchAll(/\[\(ngModel\)\]\s*=\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']/g);
+      for (const m of ngModels) add(m[1]);
+      const ngInputs = text.matchAll(/\[[a-zA-Z0-9_-]+\]\s*=\s*["'](?:this\.)?([a-zA-Z_][a-zA-Z0-9_]*)["']/g);
+      for (const m of ngInputs) add(m[1]);
+      const ngIfs = text.matchAll(/\*ngIf\s*=\s*["'](?:this\.)?([a-zA-Z_][a-zA-Z0-9_]*)/g);
+      for (const m of ngIfs) add(m[1]);
+    }
+    if (/\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath)) {
+      const methodDecl = text.matchAll(
+        /(?:^|\n)\s*(?:public|private|protected)?\s*(?:async\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*\([^)]*\)\s*\{/g
+      );
+      for (const m of methodDecl) methodNames.add(m[1]);
+
+      const thisRefs = text.matchAll(/\bthis\.([a-zA-Z_][a-zA-Z0-9_]*)\b/g);
+      for (const m of thisRefs) add(m[1]);
+
+      const classProps = text.matchAll(
+        /(?:^|\n)\s*(?:public|private|protected)?\s*(?:readonly\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*(?::|=)/g
+      );
+      for (const m of classProps) {
+        add(m[1]);
+      }
+
+      const inputProps = text.matchAll(/@Input\([^)]*\)\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*[:=]/g);
+      for (const m of inputProps) add(m[1]);
+
+      const forEachParams = text.matchAll(/forEach\(\((\w+)\)\s*=>/g);
+      for (const m of forEachParams) {
+        const item = m[1];
+        const propAccess = new RegExp(`\\b${item}\\.([a-zA-Z_][a-zA-Z0-9_]*)\\b`, "g");
+        for (const p of text.matchAll(propAccess)) add(p[1]);
+      }
+    }
+  }
+  return Array.from(fields)
+    .filter((name) => !methodNames.has(name))
+    .sort()
+    .slice(0, 80);
+}
+
+function detectExternalLibraries(cwd) {
+  const libs = new Set();
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(safeRead(pkgPath) || "{}");
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    for (const name of Object.keys(deps)) libs.add(name);
+  } catch {}
+  return Array.from(libs).sort();
+}
+
+function detectStyling(cwd, files, externalLibraries) {
+  const styleFiles = files
+    .filter((f) => /\.(css|scss|sass|less|styl)$/i.test(f))
+    .map((f) => path.relative(cwd, f))
+    .sort();
+
+  const frameworks = [];
+  const hasDep = (name) => externalLibraries.includes(name);
+  if (hasDep("tailwindcss")) frameworks.push("Tailwind CSS");
+  if (hasDep("bootstrap")) frameworks.push("Bootstrap");
+  if (externalLibraries.some((lib) => lib.startsWith("@angular/material"))) frameworks.push("Angular Material");
+  if (hasDep("antd")) frameworks.push("Ant Design");
+  if (hasDep("styled-components")) frameworks.push("styled-components");
+  if (hasDep("emotion") || hasDep("@emotion/react")) frameworks.push("Emotion");
+
+  const tokenVars = new Set();
+  for (const filePath of files) {
+    if (!/\.(css|scss|sass|less|styl|html|htm|ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath)) continue;
+    const text = safeRead(filePath);
+    for (const m of text.matchAll(/--([a-zA-Z][a-zA-Z0-9_-]*)/g)) tokenVars.add(`--${m[1]}`);
+  }
+
+  return {
+    cssFrameworks: frameworks,
+    styleFileCount: styleFiles.length,
+    styleFilesSample: styleFiles.slice(0, 12),
+    designTokens: Array.from(tokenVars).sort().slice(0, 24),
+  };
+}
+
+function detectUiLayout(files) {
+  let usesGrid = false;
+  let usesFlex = false;
+  const sections = new Set();
+
+  for (const filePath of files) {
+    if (!/\.(html|htm|tsx|jsx|ts|js|mjs|cjs)$/i.test(filePath)) continue;
+    const text = safeRead(filePath);
+
+    if (/\bgrid\b|grid-template|grid-cols-|display:\s*grid/i.test(text)) usesGrid = true;
+    if (/\bflex\b|display:\s*flex|flex-row|flex-col|justify-|items-/i.test(text)) usesFlex = true;
+
+    for (const m of text.matchAll(/<(main|header|footer|section|aside|nav)\b/gi)) {
+      sections.add(m[1].toLowerCase());
+    }
+    for (const m of text.matchAll(/class(?:Name)?\s*=\s*["'`][^"'`]*(dashboard|chart|card|sidebar|content|toolbar|filter|panel|table)[^"'`]*["'`]/gi)) {
+      const hit = m[1].toLowerCase();
+      sections.add(hit === "filter" ? "filters" : hit);
+    }
+  }
 
+  const layoutType = usesGrid && usesFlex ? "mixed" : usesGrid ? "grid" : usesFlex ? "flex" : "unknown";
+  return {
+    layoutType,
+    usesGrid,
+    usesFlex,
+    sections: Array.from(sections).sort(),
+  };
+}
+
+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";
+  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";
+
+  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 (hasClientRoots && hasServerRoots) autoProjectType = "fullstack";
+  if (!hasClientRoots && !hasServerRoots) autoProjectType = "library";
+
+  return {
+    language: overrides.language || autoLanguage,
+    framework: overrides.framework || autoFramework,
+    projectType: overrides.projectType || autoProjectType,
+    detected: {
+      language: autoLanguage,
+      framework: autoFramework,
+      projectType: autoProjectType,
+    },
+  };
+}
+
+export function discoverProjectSignals(cwd, profileOverrides = {}) {
+  const files = collectCodeFiles(cwd);
   const inferred = new Map();
   const addHit = (cap, filePath) => {
     if (!inferred.has(cap.id)) {
@@ -96,10 +311,20 @@ export function discoverCapabilities(cwd) {
     inferred.set("ReadItems", { id: "ReadItems", title: "Read Items", reason: "Fallback default", sourceFiles: new Set() });
   }
 
-  return Array.from(inferred.values()).map((c) => ({
+  const capabilities = Array.from(inferred.values()).map((c) => ({
     ...c,
     sourceFiles: Array.from(c.sourceFiles || []),
   }));
+  const externalLibraries = detectExternalLibraries(cwd);
+  return {
+    capabilities,
+    components: detectComponents(files, cwd),
+    displayFields: detectDisplayFields(files),
+    externalLibraries,
+    uiLayout: detectUiLayout(files),
+    styling: detectStyling(cwd, files, externalLibraries),
+    developmentProfile: detectDevelopmentProfile(cwd, files, externalLibraries, profileOverrides),
+  };
 }
 
 export async function reviewCapabilitiesInteractive(capabilities, yes = false) {
@@ -122,19 +347,88 @@ export async function reviewCapabilitiesInteractive(capabilities, yes = false) {
 
 export function buildAdoptionReport(capabilities) {
   if (!capabilities.length) return "No capabilities inferred.";
-  const lines = ["Inferred capabilities report:"];
-  for (const c of summarizeCapabilities(capabilities)) {
-    lines.push(`- ${c.id} (${c.title})  [confidence: ${c.confidence}]`);
+  const summarized = summarizeCapabilities(capabilities);
+  const totalSignals = summarized.reduce((acc, c) => acc + c.signalCount, 0);
+  const byConfidence = {
+    high: summarized.filter((c) => c.confidence === "high").length,
+    medium: summarized.filter((c) => c.confidence === "medium").length,
+    low: summarized.filter((c) => c.confidence === "low").length,
+  };
+
+  const lines = [];
+  lines.push("Adoption Analysis");
+  lines.push("=".repeat(56));
+  lines.push(`Capabilities detected : ${summarized.length}`);
+  lines.push(`Signal hits total     : ${totalSignals}`);
+  lines.push(
+    `Confidence mix        : high=${byConfidence.high}, medium=${byConfidence.medium}, low=${byConfidence.low}`
+  );
+  lines.push("-".repeat(56));
+  lines.push("Capability Breakdown");
+  lines.push("-".repeat(56));
+  lines.push("Confidence  Signals  Capability");
+  lines.push("-".repeat(56));
+  for (const c of summarized) {
+    const confidence = c.confidence.toUpperCase().padEnd(10, " ");
+    const signals = String(c.signalCount).padEnd(7, " ");
+    lines.push(`${confidence}  ${signals}  ${c.id} (${c.title})`);
     if (c.signalCount > 0) {
       const sample = c.sourceFiles.slice(0, 3).join(", ");
       lines.push(`  sources: ${sample}`);
+      if (c.sourceFiles.length > 3) {
+        lines.push(`  more   : +${c.sourceFiles.length - 3} additional files`);
+      }
     } else {
-      lines.push(`  sources: inferred fallback (no strong code signal)`);
+      lines.push("  sources: inferred fallback (no strong code signal)");
     }
   }
+  lines.push("=".repeat(56));
   return lines.join("\n");
 }
 
+export function buildSignalsReport(signals) {
+  const formatList = (title, items, limit = 10) => {
+    const lines = [`${title} (${items.length})`];
+    lines.push("-".repeat(56));
+    if (!items.length) {
+      lines.push("  - none");
+      return lines.join("\n");
+    }
+    for (const item of items.slice(0, limit)) {
+      lines.push(`  - ${item}`);
+    }
+    if (items.length > limit) {
+      lines.push(`  - ... +${items.length - limit} more`);
+    }
+    return lines.join("\n");
+  };
+
+  return [
+    "Project Structure Signals",
+    "=".repeat(56),
+    formatList("Components", signals.components || []),
+    formatList("Display fields", signals.displayFields || []),
+    formatList("External libraries", signals.externalLibraries || []),
+    "UI layout",
+    "-".repeat(56),
+    `  - layout type: ${signals.uiLayout?.layoutType || "unknown"}`,
+    `  - uses grid : ${signals.uiLayout?.usesGrid ? "yes" : "no"}`,
+    `  - uses flex : ${signals.uiLayout?.usesFlex ? "yes" : "no"}`,
+    `  - sections  : ${(signals.uiLayout?.sections || []).slice(0, 10).join(", ") || "none"}`,
+    "Styling",
+    "-".repeat(56),
+    `  - 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"})`,
+    "=".repeat(56),
+  ].join("\n");
+}
+
 export function summarizeCapabilities(capabilities) {
   return capabilities.map((c) => {
     const hits = c.sourceFiles?.length || 0;
@@ -150,7 +444,7 @@ export function summarizeCapabilities(capabilities) {
   });
 }
 
-export function writeAdoptionBaseline(infernoDir, policyId, capabilities) {
+export function writeAdoptionBaseline(infernoDir, policyId, capabilities, signals = null) {
   const capIds = capabilities.map((c) => c.id);
   const contract = {
     policyId,
@@ -179,11 +473,31 @@ export function writeAdoptionBaseline(infernoDir, policyId, capabilities) {
   };
   fs.writeFileSync(path.join(infernoDir, "scenarios", "adoption_baseline.json"), JSON.stringify(scenario, null, 2) + "\n");
 
+  if (signals) {
+    const profile = {
+      profileId: "adoption_profile",
+      generatedAt: new Date().toISOString(),
+      components: signals.components || [],
+      displayFields: signals.displayFields || [],
+      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" },
+      },
+    };
+    fs.writeFileSync(path.join(infernoDir, "adoption_profile.json"), JSON.stringify(profile, null, 2) + "\n");
+  }
+
   const changelog = `# Changelog — ${policyId}
 
 ## Unreleased
 
 - Adopted infernoflow into an existing project and generated baseline capabilities.
+- Captured detected components, display fields, and external libraries in adoption profile.
 
 ## 0.1.0 — Adoption baseline
 

package/lib/commands/init.mjs

@@ -3,7 +3,14 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { header, ok, warn, done, nextSteps, cyan, yellow, gray } from "../ui/output.mjs";
-import { discoverCapabilities, reviewCapabilitiesInteractive, writeAdoptionBaseline, buildAdoptionReport, summarizeCapabilities } from "./adopt.mjs";
+import {
+  discoverProjectSignals,
+  reviewCapabilitiesInteractive,
+  writeAdoptionBaseline,
+  buildAdoptionReport,
+  summarizeCapabilities,
+  buildSignalsReport,
+} from "./adopt.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -20,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));
@@ -136,14 +151,24 @@ export async function initCommand(args) {
   const adopt = args.includes("--adopt");
   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) {
+    console.error("Error: --report-json-only and --report-human-only cannot be used together.");
+    process.exit(1);
+  }
 
-  if (!reportJsonOnly) {
+  if (!silent) {
     header("init");
   }
 
   const infernoDir = path.join(cwd, "inferno");
   if (fs.existsSync(infernoDir) && !force) {
-    if (reportJsonOnly) {
+    if (silent) {
       console.log(JSON.stringify({ ok: false, error: "inferno_exists", hint: "Use --force to overwrite" }, null, 2));
       process.exit(1);
     }
@@ -159,12 +184,39 @@ export async function initCommand(args) {
   let capabilities = defaultCaps.split(",").map(c => c.trim());
 
   if (adopt) {
-    const inferred = discoverCapabilities(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) {
       console.log(
         JSON.stringify(
-          { mode: "adopt", policyId: detectedName, inferredCapabilities: summarized },
+          {
+            mode: "adopt",
+            policyId: detectedName,
+            inferredCapabilities: summarized,
+            components: signals.components,
+            displayFields: signals.displayFields,
+            externalLibraries: signals.externalLibraries,
+            uiLayout: signals.uiLayout,
+            styling: signals.styling,
+            developmentProfile: signals.developmentProfile,
+          },
           null,
           2
         )
@@ -173,13 +225,21 @@ export async function initCommand(args) {
       console.log();
       console.log(gray(buildAdoptionReport(inferred)));
       console.log();
-      if (reportJson) {
+      console.log(gray(buildSignalsReport(signals)));
+      console.log();
+      if (reportJson && !reportHumanOnly) {
         console.log(
           JSON.stringify(
             {
               mode: "adopt",
               policyId: detectedName,
               inferredCapabilities: summarized,
+              components: signals.components,
+              displayFields: signals.displayFields,
+              externalLibraries: signals.externalLibraries,
+              uiLayout: signals.uiLayout,
+              styling: signals.styling,
+              developmentProfile: signals.developmentProfile,
             },
             null,
             2
@@ -209,36 +269,58 @@ export async function initCommand(args) {
       id,
       title: id.replace(/([A-Z])/g, " $1").trim(),
     }));
-    writeAdoptionBaseline(infernoDir, policyId, capDetails);
-    if (!reportJsonOnly) {
+    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"));
       ok("Created: " + cyan("inferno/capabilities.json"));
       ok("Created: " + cyan("inferno/scenarios/adoption_baseline.json"));
+      ok("Created: " + cyan("inferno/adoption_profile.json"));
       ok("Created: " + cyan("inferno/CHANGELOG.md"));
     }
   } else {
     writeContract(path.join(infernoDir, "contract.json"), policyId, capabilities);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/contract.json"));
+    if (!silent) ok("Created: " + cyan("inferno/contract.json"));
 
     writeCapabilities(path.join(infernoDir, "capabilities.json"), capabilities);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/capabilities.json"));
+    if (!silent) ok("Created: " + cyan("inferno/capabilities.json"));
 
     writeScenario(path.join(infernoDir, "scenarios"), capabilities);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
+    if (!silent) ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
 
     writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/CHANGELOG.md"));
+    if (!silent) ok("Created: " + cyan("inferno/CHANGELOG.md"));
   }
 
   // Copy doc-gate script
   const templates = getTemplatesRoot();
   const srcScript = path.join(templates, "scripts", "inferno-doc-gate.mjs");
   const dstScript = path.join(cwd, "scripts", "inferno-doc-gate.mjs");
-  copyFile(srcScript, dstScript, force, reportJsonOnly);
+  copyFile(srcScript, dstScript, force, silent);
+
+  upsertScripts(cwd, silent);
 
-  upsertScripts(cwd, reportJsonOnly);
+  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 (!reportJsonOnly) {
+  if (!silent) {
     done("infernoflow initialized!");
 
     nextSteps([

package/package.json

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