infernoflow 0.20.0 → 0.22.0

package/dist/bin/infernoflow.mjs

@@ -49,6 +49,11 @@ const COMMAND_DESCRIPTIONS = {
   export:  "Export contract to OpenAPI, Backstage catalog-info.yaml, CSV, or Markdown",
   snapshot: "Save/diff/restore named snapshots of the capability contract",
   health:  "Compute a 0–100 health score across coverage, docs, freshness, completeness, drift",
+  vibe:    "Vibe coding mode — watches files, auto-syncs contract, regenerates context on every save",
+  adopt:   "Interactive wizard to adopt infernoflow in an existing project (detect → review → wire up)",
+  doctor:  "Diagnose your infernoflow setup — checks Node, git, contract, AI providers, MCP, hooks",
+  coverage: "Map test files to capabilities — show which caps have test coverage and which don't",
+  review:  "AI-powered capability impact review for staged or recent git changes",
 };
 
 const COMMAND_HANDLERS = {
@@ -91,6 +96,11 @@ const COMMAND_HANDLERS = {
   export:   async (args) => (await import("../lib/commands/export.mjs")).exportCommand(args),
   snapshot: async (args) => (await import("../lib/commands/snapshot.mjs")).snapshotCommand(args),
   health:   async (args) => (await import("../lib/commands/health.mjs")).healthCommand(args),
+  vibe:     async (args) => (await import("../lib/commands/vibe.mjs")).vibeCommand(args),
+  adopt:    async (args) => (await import("../lib/commands/adoptWizard.mjs")).adoptWizardCommand(args),
+  doctor:   async (args) => (await import("../lib/commands/doctor.mjs")).doctorCommand(args),
+  coverage: async (args) => (await import("../lib/commands/coverage.mjs")).coverageCommand(args),
+  review:   async (args) => (await import("../lib/commands/review.mjs")).reviewCommand(args),
 };
 
 function formatCommandsHelp() {
@@ -287,6 +297,26 @@ ${formatCommandsHelp()}
     --fail-on high|medium     Exit 1 if unreviewed caps at given severity exist
     --json                    Machine-readable output
 
+  ${bold("vibe options:")}
+    --dir <dirs>              Comma-separated directories to watch (default: auto-detected)
+    --no-suggest              Disable automatic contract sync on file save
+    --no-context              Disable CONTEXT.md regeneration
+    --interval <secs>         Debounce seconds between saves (default: 4)
+    --port <n>                Also run a mini status dashboard on localhost:<n>
+    --silent                  Suppress all terminal output (pure background mode)
+
+  ${bold("adopt options:")}
+    --dir <dirs>              Source directories to scan (default: src,lib,app,api,routes,controllers)
+    --yes, -y                 Auto-approve all candidates (non-interactive)
+    --json                    Machine-readable output, implies --yes
+
+  ${bold("init --template options:")}
+    --template rest-api       REST API (Express/Fastify/Hono) starter
+    --template nextjs         Next.js fullstack app starter
+    --template cli            CLI tool (Node.js/Python) starter
+    --template graphql        GraphQL API (Apollo/Pothos) starter
+    --template monorepo       Monorepo workspace starter
+
   ${bold("scout options:")}
     --dir <dirs>              Comma-separated directories to scan (default: src,lib,app,api,routes)
     --apply                   Write discovered capabilities to the contract file
@@ -315,6 +345,22 @@ ${formatCommandsHelp()}
     --interval <secs>         Watch interval in seconds (default: 30)
     --json                    Machine-readable score + breakdown
 
+  ${bold("doctor options:")}
+    --fix                     Auto-fix common issues (installs hooks, runs init, etc.)
+    --json                    Machine-readable list of pass/warn/fail results
+
+  ${bold("coverage options:")}
+    --dir <path>              Extra directory to scan for test files (repeatable)
+    --threshold <0-1>         Minimum fuzzy-match score to count a test (default: 0.25)
+    --fail-below <pct>        Exit 1 if coverage percentage is below this value (CI gate)
+    --json                    Machine-readable coverage breakdown
+
+  ${bold("review options:")}
+    --unstaged                Review all working-tree changes (not just staged)
+    --last                    Review last commit (git diff HEAD~1)
+    --dry-run                 Print the AI prompt only — no API call made
+    --json                    Machine-readable output (affectedCaps, summary, provider)
+
   ${bold("Machine output:")}
     ${gray("status --json")}
     ${gray("check --json")}

package/dist/lib/ai/providerRouter.mjs

@@ -1,73 +1,236 @@
-import { detectIdeContext } from "./ideDetection.mjs";
-
-export async function resolveProvider(requestedProvider = "auto", preferredIde = "auto") {
-  const providerRequested = String(requestedProvider || "auto").toLowerCase();
-  const ide = detectIdeContext(preferredIde);
-  const reasonCodes = [...ide.reasonCodes];
-
-  if (providerRequested === "local") {
-    reasonCodes.push("LOCAL_PROVIDER_SELECTED");
-    return {
-      providerRequested,
-      providerResolved: "local",
-      ideDetected: ide.ideDetected,
-      agentAvailable: ide.agentAvailable,
-      reasonCodes,
-    };
-  }
+/**
+ * infernoflow AI provider router
+ *
+ * Tries providers in order until one works:
+ *   Tier 1 — VS Code Language Model API (vscode.lm — any Copilot model: Gemini, Claude, GPT)
+ *   Tier 2 — Direct API: Anthropic, OpenAI, Google AI (Gemini), OpenRouter
+ *   Tier 3 — Ollama (local, free, offline)
+ *   Tier 4 — Prompt fallback (print prompt, no AI call)
+ *
+ * Config sources (in priority order):
+ *   1. Environment variables
+ *   2. inferno/integrations.json
+ *   3. Auto-detection (Ollama running locally, etc.)
+ */
 
-  if (providerRequested === "prompt") {
-    reasonCodes.push("PROMPT_PROVIDER_SELECTED");
-    return {
-      providerRequested,
-      providerResolved: "prompt",
-      ideDetected: ide.ideDetected,
-      agentAvailable: ide.agentAvailable,
-      reasonCodes,
-    };
-  }
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+import * as http  from "node:http";
+
+// ── Config reader ─────────────────────────────────────────────────────────────
+
+export function readAiConfig(cwd) {
+  const p = path.join(cwd, "inferno", "integrations.json");
+  if (!fs.existsSync(p)) return {};
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return {}; }
+}
+
+// ── HTTP helpers ──────────────────────────────────────────────────────────────
+
+function post(url, headers, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const lib    = parsed.protocol === "https:" ? https : http;
+    const data   = JSON.stringify(body);
+
+    const req = lib.request({
+      hostname: parsed.hostname,
+      port:     parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+      path:     parsed.pathname + (parsed.search || ""),
+      method:   "POST",
+      headers:  { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data), ...headers },
+    }, (res) => {
+      let raw = "";
+      res.on("data", d => (raw += d));
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(raw) }); }
+        catch { resolve({ status: res.statusCode, body: raw }); }
+      });
+    });
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+// ── Tier 2: Direct API providers ─────────────────────────────────────────────
+
+async function callAnthropic(prompt, config) {
+  const apiKey = process.env.ANTHROPIC_API_KEY || config.anthropic?.apiKey;
+  if (!apiKey) return null;
 
-  if (providerRequested === "agent") {
-    if (!ide.agentAvailable) {
-      reasonCodes.push("EXPLICIT_AGENT_REQUIRED");
-      return {
-        providerRequested,
-        providerResolved: "none",
-        ideDetected: ide.ideDetected,
-        agentAvailable: ide.agentAvailable,
-        reasonCodes,
-        error: "agent_unavailable",
-      };
+  const model = config.anthropic?.model || process.env.ANTHROPIC_MODEL || "claude-sonnet-4-6";
+
+  try {
+    const res = await post(
+      "https://api.anthropic.com/v1/messages",
+      { "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
+      {
+        model,
+        max_tokens: 1024,
+        messages: [{ role: "user", content: prompt }],
+      }
+    );
+    if (res.status === 200 && res.body?.content?.[0]?.text) {
+      return { text: res.body.content[0].text, provider: "anthropic", model };
     }
-    reasonCodes.push("IDE_AGENT_SELECTED");
-    return {
-      providerRequested,
-      providerResolved: "agent",
-      ideDetected: ide.ideDetected,
-      agentAvailable: ide.agentAvailable,
-      reasonCodes,
-    };
-  }
+  } catch {}
+  return null;
+}
+
+async function callOpenAI(prompt, config) {
+  const apiKey   = process.env.OPENAI_API_KEY || config.openai?.apiKey;
+  const endpoint = process.env.OPENAI_ENDPOINT || config.openai?.endpoint || "https://api.openai.com/v1/chat/completions";
+  if (!apiKey) return null;
+
+  const model = config.openai?.model || process.env.OPENAI_MODEL || "gpt-4o";
+
+  try {
+    const res = await post(
+      endpoint,
+      { "Authorization": `Bearer ${apiKey}` },
+      {
+        model,
+        max_tokens: 1024,
+        messages: [{ role: "user", content: prompt }],
+      }
+    );
+    if (res.status === 200 && res.body?.choices?.[0]?.message?.content) {
+      return { text: res.body.choices[0].message.content, provider: "openai", model };
+    }
+  } catch {}
+  return null;
+}
+
+async function callGemini(prompt, config) {
+  const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GEMINI_API_KEY || config.gemini?.apiKey;
+  if (!apiKey) return null;
+
+  const model = config.gemini?.model || process.env.GEMINI_MODEL || "gemini-2.0-flash";
 
-  // auto
-  if (ide.agentAvailable) {
-    reasonCodes.push("IDE_AGENT_SELECTED");
-    return {
-      providerRequested: "auto",
-      providerResolved: "agent",
-      ideDetected: ide.ideDetected,
-      agentAvailable: ide.agentAvailable,
-      reasonCodes,
-    };
+  try {
+    const res = await post(
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+      {},
+      { contents: [{ parts: [{ text: prompt }] }] }
+    );
+    const text = res.body?.candidates?.[0]?.content?.parts?.[0]?.text;
+    if (res.status === 200 && text) {
+      return { text, provider: "gemini", model };
+    }
+  } catch {}
+  return null;
+}
+
+async function callOpenRouter(prompt, config) {
+  const apiKey = process.env.OPENROUTER_API_KEY || config.openrouter?.apiKey;
+  if (!apiKey) return null;
+
+  const model = config.openrouter?.model || process.env.OPENROUTER_MODEL || "anthropic/claude-sonnet-4-6";
+
+  try {
+    const res = await post(
+      "https://openrouter.ai/api/v1/chat/completions",
+      { "Authorization": `Bearer ${apiKey}`, "HTTP-Referer": "https://infernoflow.dev" },
+      {
+        model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: 1024,
+      }
+    );
+    if (res.status === 200 && res.body?.choices?.[0]?.message?.content) {
+      return { text: res.body.choices[0].message.content, provider: "openrouter", model };
+    }
+  } catch {}
+  return null;
+}
+
+// ── Tier 3: Ollama (local) ────────────────────────────────────────────────────
+
+async function callOllama(prompt, config) {
+  const host  = process.env.OLLAMA_HOST || config.ollama?.host || "http://localhost:11434";
+  const model = process.env.OLLAMA_MODEL || config.ollama?.model || "llama3";
+
+  // Quick liveness check
+  try {
+    await new Promise((res, rej) => {
+      const u = new URL(host);
+      http.get({ hostname: u.hostname, port: u.port || 11434, path: "/api/tags", timeout: 1500 },
+        r => res(r)).on("error", rej);
+    });
+  } catch { return null; }
+
+  try {
+    const res = await post(
+      `${host}/api/generate`,
+      {},
+      { model, prompt, stream: false }
+    );
+    if (res.status === 200 && res.body?.response) {
+      return { text: res.body.response, provider: "ollama", model };
+    }
+  } catch {}
+  return null;
+}
+
+// ── Main router ───────────────────────────────────────────────────────────────
+
+/**
+ * Call the best available AI provider with a prompt.
+ *
+ * @param {string} prompt  - The full prompt text
+ * @param {object} opts
+ *   opts.cwd      - Project root (for reading integrations.json)
+ *   opts.provider - Force a specific provider: anthropic|openai|gemini|openrouter|ollama|prompt
+ *   opts.silent   - Don't print "using provider X" message
+ * @returns {{ text: string, provider: string, model: string } | null}
+ *   null means no provider was available → caller should use prompt fallback
+ */
+export async function callAI(prompt, opts = {}) {
+  const cwd      = opts.cwd || process.cwd();
+  const config   = readAiConfig(cwd);
+  const forced   = (opts.provider || "auto").toLowerCase();
+  const silent   = opts.silent ?? true;
+
+  const providers = [
+    // Tier 2 — direct API (Tier 1 vscode.lm is handled in the VS Code extension)
+    ["anthropic",   () => callAnthropic(prompt, config)],
+    ["openai",      () => callOpenAI(prompt, config)],
+    ["gemini",      () => callGemini(prompt, config)],
+    ["openrouter",  () => callOpenRouter(prompt, config)],
+    // Tier 3 — local
+    ["ollama",      () => callOllama(prompt, config)],
+  ];
+
+  // If a specific provider is forced, only try that one
+  const toTry = forced === "auto" || forced === "prompt"
+    ? providers
+    : providers.filter(([name]) => name === forced);
+
+  for (const [name, fn] of toTry) {
+    try {
+      const result = await fn();
+      if (result) {
+        if (!silent) process.stderr.write(`  [infernoflow ai] using ${name}:${result.model}\n`);
+        return result;
+      }
+    } catch {}
   }
 
-  reasonCodes.push("FALLBACK_PROMPT_MODE");
+  return null; // No provider → fallback to prompt output
+}
+
+/**
+ * Detect which providers are configured (for doctor command).
+ */
+export function detectAvailableProviders(cwd) {
+  const config = readAiConfig(cwd);
   return {
-    providerRequested: "auto",
-    providerResolved: "prompt",
-    ideDetected: ide.ideDetected,
-    agentAvailable: ide.agentAvailable,
-    reasonCodes,
+    anthropic:  !!(process.env.ANTHROPIC_API_KEY  || config.anthropic?.apiKey),
+    openai:     !!(process.env.OPENAI_API_KEY      || config.openai?.apiKey),
+    gemini:     !!(process.env.GOOGLE_AI_API_KEY   || process.env.GEMINI_API_KEY || config.gemini?.apiKey),
+    openrouter: !!(process.env.OPENROUTER_API_KEY  || config.openrouter?.apiKey),
+    ollama:     false, // checked async — doctor runs its own check
   };
 }
-