infernoflow 0.10.1 → 0.10.3

package/README.md

@@ -41,6 +41,43 @@ infernoflow check
 infernoflow doc-gate
 ```
 
+## Adopt Existing Project
+
+Use this when your project already has code and you want InfernoFlow to bootstrap from current behavior.
+
+```bash
+# from existing project root
+infernoflow init --adopt
+```
+
+Non-interactive adoption:
+
+```bash
+infernoflow init --adopt --yes
+```
+
+JSON report for CI/logging:
+
+```bash
+infernoflow init --adopt --yes --report-json
+```
+
+JSON-only output (clean machine output, no text logs):
+
+```bash
+infernoflow init --adopt --yes --report-json-only
+```
+
+What adoption creates:
+- `inferno/contract.json` (inferred capability baseline)
+- `inferno/capabilities.json` (inferred registry)
+- `inferno/scenarios/adoption_baseline.json` (coverage baseline)
+- `inferno/CHANGELOG.md` (adoption entry)
+
+Safety:
+- Existing `inferno/` is not overwritten unless `--force` is provided.
+- Adoption prints an inferred capability report with source-file hints and confidence.
+
 ## Recommended Workflow
 
 ```bash
@@ -117,6 +154,7 @@ infernoflow doc-gate --json
 ```bash
 infernoflow init --force       # overwrite existing files
 infernoflow init --yes         # skip prompts, use defaults
+infernoflow init --adopt       # infer baseline from existing project
 infernoflow suggest "..."      # describe what changed
 infernoflow implement "..." --mode both
 infernoflow implement "..." --mode cursor

package/bin/infernoflow.mjs

@@ -8,7 +8,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
 const VERSION = pkg.version || "0.0.0";
 const COMMAND_DESCRIPTIONS = {
-  init: "Scaffold inferno/ in your project",
+  init: "Scaffold inferno/ in your project (or adopt existing project)",
   check: "Validate contract, capabilities, scenarios, changelog",
   status: "Show contract health at a glance",
   "doc-gate": "Fail if code changed but docs were not updated",
@@ -43,6 +43,13 @@ const HELP = `
   ${bold("Commands:")}
 ${formatCommandsHelp()}
 
+  ${bold("init options:")}
+    --adopt             Infer capabilities from an existing codebase
+    --report-json       Print inferred adoption report as JSON
+    --report-json-only  Print JSON report only (no human-readable logs)
+    --yes, -y           Skip prompts and accept inferred/default values
+    --force, -f         Overwrite existing inferno/ files
+
   ${bold("context options:")}
     --intent  "..."     What you plan to build next
     --working "..."     What you are building right now

package/lib/commands/adopt.mjs

@@ -0,0 +1,193 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+
+function toCapabilityId(raw) {
+  return raw
+    .replace(/[^a-zA-Z0-9]+/g, " ")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w[0].toUpperCase() + w.slice(1))
+    .join("");
+}
+
+function capTitle(id) {
+  return id.replace(/([A-Z])/g, " $1").trim();
+}
+
+function safeRead(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+const HEURISTICS = [
+  { id: "CreateItem", title: "Create Item", regex: /\b(post|create|add)\b/i },
+  { id: "ReadItems", title: "Read Items", regex: /\b(get|read|list|fetch)\b/i },
+  { id: "UpdateItem", title: "Update Item", regex: /\b(put|patch|update|edit)\b/i },
+  { id: "DeleteItem", title: "Delete Item", regex: /\b(delete|remove)\b/i },
+  { id: "SearchItems", title: "Search Items", regex: /\bsearch\b/i },
+  { id: "FilterItems", title: "Filter Items", regex: /\bfilter\b/i },
+  { id: "SetDueDate", title: "Set Due Date", regex: /\bdueDate|deadline|due\b/i },
+  { id: "SetPriority", title: "Set Priority", regex: /\bpriority\b/i },
+  { id: "ToggleComplete", title: "Toggle Complete", regex: /\bcomplete|completed|toggle\b/i },
+  { id: "ClearCompleted", title: "Clear Completed", regex: /\bclearCompleted|clear completed\b/i },
+];
+
+export function discoverCapabilities(cwd) {
+  const files = [];
+  const roots = ["src", "server", "app", "backend", "frontend", "api"];
+  for (const r of roots) {
+    const root = path.join(cwd, r);
+    if (!fs.existsSync(root)) continue;
+    const stack = [root];
+    while (stack.length) {
+      const cur = stack.pop();
+      for (const entry of fs.readdirSync(cur, { withFileTypes: true })) {
+        const p = path.join(cur, entry.name);
+        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)) {
+          files.push(p);
+        }
+      }
+    }
+  }
+
+  const inferred = new Map();
+  const addHit = (cap, filePath) => {
+    if (!inferred.has(cap.id)) {
+      inferred.set(cap.id, {
+        id: cap.id,
+        title: cap.title,
+        reason: "Detected from code signals",
+        sourceFiles: new Set(),
+      });
+    }
+    inferred.get(cap.id).sourceFiles.add(path.relative(cwd, filePath));
+  };
+
+  for (const filePath of files) {
+    const text = safeRead(filePath);
+    for (const h of HEURISTICS) {
+      if (h.regex.test(text)) {
+        addHit(h, filePath);
+      }
+    }
+  }
+
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(safeRead(pkgPath) || "{}");
+    const name = typeof pkg.name === "string" ? pkg.name : path.basename(cwd);
+    const idHint = toCapabilityId(name);
+    if (idHint && !inferred.size) {
+      inferred.set("ReadItems", { id: "ReadItems", title: "Read Items", reason: `Fallback default for ${name}`, sourceFiles: new Set() });
+      inferred.set("CreateItem", { id: "CreateItem", title: "Create Item", reason: `Fallback default for ${name}`, sourceFiles: new Set() });
+    }
+  }
+
+  if (!inferred.size) {
+    inferred.set("CreateItem", { id: "CreateItem", title: "Create Item", reason: "Fallback default", sourceFiles: new Set() });
+    inferred.set("ReadItems", { id: "ReadItems", title: "Read Items", reason: "Fallback default", sourceFiles: new Set() });
+  }
+
+  return Array.from(inferred.values()).map((c) => ({
+    ...c,
+    sourceFiles: Array.from(c.sourceFiles || []),
+  }));
+}
+
+export async function reviewCapabilitiesInteractive(capabilities, yes = false) {
+  if (yes) return capabilities;
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const list = capabilities.map((c) => c.id).join(", ");
+  const answer = await new Promise((resolve) =>
+    rl.question(`  Inferred capabilities (${list}). Press Enter to accept or type comma list: `, resolve)
+  );
+  rl.close();
+  const trimmed = String(answer).trim();
+  if (!trimmed) return capabilities;
+  return trimmed
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((id) => ({ id, title: capTitle(id), reason: "User provided during adopt review" }));
+}
+
+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}]`);
+    if (c.signalCount > 0) {
+      const sample = c.sourceFiles.slice(0, 3).join(", ");
+      lines.push(`  sources: ${sample}`);
+    } else {
+      lines.push(`  sources: inferred fallback (no strong code signal)`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export function summarizeCapabilities(capabilities) {
+  return capabilities.map((c) => {
+    const hits = c.sourceFiles?.length || 0;
+    const confidence = hits >= 3 ? "high" : hits >= 1 ? "medium" : "low";
+    return {
+      id: c.id,
+      title: c.title,
+      reason: c.reason,
+      confidence,
+      sourceFiles: c.sourceFiles || [],
+      signalCount: hits,
+    };
+  });
+}
+
+export function writeAdoptionBaseline(infernoDir, policyId, capabilities) {
+  const capIds = capabilities.map((c) => c.id);
+  const contract = {
+    policyId,
+    policyVersion: 1,
+    capabilities: capIds,
+    rules: {
+      docsRequiredOnCapabilityChange: true,
+      requireScenarioForEachCapability: true,
+      requireChangelogOnCapabilityChange: true,
+    },
+  };
+  fs.mkdirSync(path.join(infernoDir, "scenarios"), { recursive: true });
+  fs.writeFileSync(path.join(infernoDir, "contract.json"), JSON.stringify(contract, null, 2) + "\n");
+
+  const registry = {
+    schemaVersion: 1,
+    capabilities: capabilities.map((c) => ({ id: c.id, title: c.title || capTitle(c.id), since: "0.1.0" })),
+  };
+  fs.writeFileSync(path.join(infernoDir, "capabilities.json"), JSON.stringify(registry, null, 2) + "\n");
+
+  const scenario = {
+    scenarioId: "adoption_baseline",
+    description: "Baseline inferred from existing codebase during adoption",
+    capabilitiesCovered: capIds,
+    steps: capIds.map((id) => ({ action: id, expect: `${id} behavior exists in the current project` })),
+  };
+  fs.writeFileSync(path.join(infernoDir, "scenarios", "adoption_baseline.json"), JSON.stringify(scenario, null, 2) + "\n");
+
+  const changelog = `# Changelog — ${policyId}
+
+## Unreleased
+
+- Adopted infernoflow into an existing project and generated baseline capabilities.
+
+## 0.1.0 — Adoption baseline
+
+- Initial baseline generated by infernoflow init --adopt
+`;
+  fs.writeFileSync(path.join(infernoDir, "CHANGELOG.md"), changelog, "utf8");
+}

package/lib/commands/init.mjs

@@ -3,6 +3,7 @@ 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";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -19,14 +20,14 @@ function ask(rl, question, defaultVal = "") {
   });
 }
 
-function copyFile(src, dst, force) {
+function copyFile(src, dst, force, silent = false) {
   if (fs.existsSync(dst) && !force) {
-    warn("Skipped (exists): " + path.relative(process.cwd(), dst));
+    if (!silent) warn("Skipped (exists): " + path.relative(process.cwd(), dst));
     return false;
   }
   fs.mkdirSync(path.dirname(dst), { recursive: true });
   fs.copyFileSync(src, dst);
-  ok("Created: " + cyan(path.relative(process.cwd(), dst)));
+  if (!silent) ok("Created: " + cyan(path.relative(process.cwd(), dst)));
   return true;
 }
 
@@ -40,7 +41,7 @@ function copyDirDeep(srcDir, dstDir, force) {
   }
 }
 
-function upsertScripts(cwd) {
+function upsertScripts(cwd, silent = false) {
   const pkgPath = path.join(cwd, "package.json");
   if (!fs.existsSync(pkgPath)) return;
   const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
@@ -56,7 +57,7 @@ function upsertScripts(cwd) {
   }
   if (changed) {
     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-    ok("Updated " + cyan("package.json") + " scripts");
+    if (!silent) ok("Updated " + cyan("package.json") + " scripts");
   }
 }
 
@@ -132,11 +133,20 @@ export async function initCommand(args) {
   const cwd = process.cwd();
   const force = args.includes("--force") || args.includes("-f");
   const yes = args.includes("--yes") || args.includes("-y");
+  const adopt = args.includes("--adopt");
+  const reportJson = args.includes("--report-json");
+  const reportJsonOnly = args.includes("--report-json-only");
 
-  header("init");
+  if (!reportJsonOnly) {
+    header("init");
+  }
 
   const infernoDir = path.join(cwd, "inferno");
   if (fs.existsSync(infernoDir) && !force) {
+    if (reportJsonOnly) {
+      console.log(JSON.stringify({ ok: false, error: "inferno_exists", hint: "Use --force to overwrite" }, null, 2));
+      process.exit(1);
+    }
     warn("inferno/ already exists. Use --force to overwrite.");
     console.log();
     process.exit(0);
@@ -148,7 +158,40 @@ export async function initCommand(args) {
   let policyId = detectedName;
   let capabilities = defaultCaps.split(",").map(c => c.trim());
 
-  if (!yes) {
+  if (adopt) {
+    const inferred = discoverCapabilities(cwd);
+    const summarized = summarizeCapabilities(inferred);
+    if (reportJsonOnly) {
+      console.log(
+        JSON.stringify(
+          { mode: "adopt", policyId: detectedName, inferredCapabilities: summarized },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log();
+      console.log(gray(buildAdoptionReport(inferred)));
+      console.log();
+      if (reportJson) {
+        console.log(
+          JSON.stringify(
+            {
+              mode: "adopt",
+              policyId: detectedName,
+              inferredCapabilities: summarized,
+            },
+            null,
+            2
+          )
+        );
+        console.log();
+      }
+    }
+    const reviewed = await reviewCapabilitiesInteractive(inferred, yes);
+    policyId = detectedName;
+    capabilities = reviewed.map((c) => c.id);
+  } else if (!yes) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log(gray("  Press Enter to accept defaults\n"));
     policyId = await ask(rl, "Project / policy name", detectedName);
@@ -161,33 +204,49 @@ export async function initCommand(args) {
   // Write files
   fs.mkdirSync(infernoDir, { recursive: true });
 
-  writeContract(path.join(infernoDir, "contract.json"), policyId, capabilities);
-  ok("Created: " + cyan("inferno/contract.json"));
+  if (adopt) {
+    const capDetails = capabilities.map((id) => ({
+      id,
+      title: id.replace(/([A-Z])/g, " $1").trim(),
+    }));
+    writeAdoptionBaseline(infernoDir, policyId, capDetails);
+    if (!reportJsonOnly) {
+      ok("Created: " + cyan("inferno/contract.json"));
+      ok("Created: " + cyan("inferno/capabilities.json"));
+      ok("Created: " + cyan("inferno/scenarios/adoption_baseline.json"));
+      ok("Created: " + cyan("inferno/CHANGELOG.md"));
+    }
+  } else {
+    writeContract(path.join(infernoDir, "contract.json"), policyId, capabilities);
+    if (!reportJsonOnly) ok("Created: " + cyan("inferno/contract.json"));
 
-  writeCapabilities(path.join(infernoDir, "capabilities.json"), capabilities);
-  ok("Created: " + cyan("inferno/capabilities.json"));
+    writeCapabilities(path.join(infernoDir, "capabilities.json"), capabilities);
+    if (!reportJsonOnly) ok("Created: " + cyan("inferno/capabilities.json"));
 
-  writeScenario(path.join(infernoDir, "scenarios"), capabilities);
-  ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
+    writeScenario(path.join(infernoDir, "scenarios"), capabilities);
+    if (!reportJsonOnly) ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
 
-  writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
-  ok("Created: " + cyan("inferno/CHANGELOG.md"));
+    writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
+    if (!reportJsonOnly) 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);
+  copyFile(srcScript, dstScript, force, reportJsonOnly);
 
-  upsertScripts(cwd);
+  upsertScripts(cwd, reportJsonOnly);
 
-  done("infernoflow initialized!");
+  if (!reportJsonOnly) {
+    done("infernoflow initialized!");
 
-  nextSteps([
-    cyan("infernoflow status") + "  — see your contract at a glance",
-    cyan("infernoflow check") + "   — validate everything",
-    "Edit " + yellow("inferno/capabilities.json") + " to describe each capability in detail",
-    "Add more " + yellow("inferno/scenarios/*.json") + " files for edge cases",
-    "Add " + cyan("inferno:check") + " to your CI pipeline"
-  ]);
+    nextSteps([
+      cyan("infernoflow status") + "  — see your contract at a glance",
+      cyan("infernoflow check") + "   — validate everything",
+      (adopt ? "Review inferred baseline in " : "Edit ") + yellow("inferno/capabilities.json") + (adopt ? " and refine IDs/titles" : " to describe each capability in detail"),
+      "Add more " + yellow("inferno/scenarios/*.json") + " files for edge cases",
+      "Add " + cyan("inferno:check") + " to your CI pipeline"
+    ]);
+  }
 }

package/package.json

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