infernoflow 0.10.7 → 0.10.9

package/README.md

@@ -166,6 +166,7 @@ infernoflow doc-gate --json
 | `infernoflow status` | At-a-glance health of your contract |
 | `infernoflow suggest` | Generate an AI prompt, apply capability updates |
 | `infernoflow implement` | Generate implementation prompts for coding agents |
+| `infernoflow run` | One-command local-model flow with validation and rollback |
 | `infernoflow pr-impact` | Analyze changed files and infer capability/doc drift |
 | `infernoflow sync --auto` | Deterministic sync flow for agents (skeleton) |
 | `infernoflow check` | Full validation: contract, capabilities, scenarios, changelog |
@@ -185,6 +186,9 @@ infernoflow implement "..." --mode both
 infernoflow implement "..." --mode cursor
 infernoflow implement "..." --mode generic
 infernoflow implement "..." --mode both --copy
+infernoflow run "add favorite badge to tasks"
+infernoflow run "sync check" --dry-run
+infernoflow run "sync check" --json
 infernoflow pr-impact
 infernoflow pr-impact --json
 infernoflow sync --auto
@@ -232,6 +236,58 @@ Proposed Changes
 
 Works with any AI — Claude, ChatGPT, GitHub Copilot, Cursor, or your own setup.
 
+## `infernoflow run` — zero copy/paste flow
+
+Run one command and infernoflow will:
+1. Detect drift (`pr-impact`)
+2. Resolve provider (`auto` defaults to IDE agent)
+3. Generate suggestion
+4. Apply inferno updates
+5. Validate with `check`
+6. Roll back automatically if validation fails
+
+```bash
+infernoflow run "add favorite badge to tasks and filter by favorite"
+```
+
+Machine mode:
+
+```bash
+infernoflow run "sync check" --json
+```
+
+Provider options:
+
+```bash
+infernoflow run "task" --provider auto                # default (IDE agent first)
+infernoflow run "task" --provider agent --ide cursor  # require IDE agent
+infernoflow run "task" --provider local               # explicit local model
+infernoflow run "task" --provider prompt              # deterministic prompt fallback
+```
+
+IDE routing behavior:
+- `auto` + agent available -> uses IDE agent
+- `auto` + no agent -> falls back to prompt mode (`FALLBACK_PROMPT_MODE`)
+- `agent` + no agent -> exits with `EXPLICIT_AGENT_REQUIRED`
+
+Local model configuration (optional):
+
+```bash
+# local provider example: ollama
+set INFERNO_LOCAL_PROVIDER=ollama
+set INFERNO_LOCAL_ENDPOINT=http://127.0.0.1:11434/api/generate
+set INFERNO_LOCAL_MODEL=llama3.1:8b
+```
+
+Optional OpenAI-compatible local server:
+
+```bash
+set INFERNO_LOCAL_PROVIDER=openai
+set INFERNO_LOCAL_ENDPOINT=http://127.0.0.1:1234/v1/chat/completions
+set INFERNO_LOCAL_MODEL=local-model
+set INFERNO_LOCAL_API_KEY=local
+```
+
 ## `infernoflow implement` — code-agent execution prompts
 
 Generate coding prompts from your project context and inferno contract:
@@ -279,10 +335,8 @@ Recommended chain:
 
 ```yaml
 # .github/workflows/ci.yml
-- name: infernoflow impact + check
-  run: |
-    npx infernoflow pr-impact --json
-    npx infernoflow check --json
+- name: infernoflow run (headless)
+  run: npx infernoflow run "sync check" --provider prompt --json
   env:
     BASE_SHA: ${{ github.event.pull_request.base.sha }}
     HEAD_SHA: ${{ github.event.pull_request.head.sha }}

package/bin/infernoflow.mjs

@@ -13,6 +13,7 @@ const COMMAND_DESCRIPTIONS = {
   status: "Show contract health at a glance",
   "pr-impact": "Summarize PR impact on capabilities and docs",
   sync: "Run deterministic inferno sync flow",
+  run: "One-command detect/propose/apply/validate flow",
   "doc-gate": "Fail if code changed but docs were not updated",
   suggest: "Generate AI prompt + apply capability updates",
   implement: "Generate code-agent implementation prompt(s)",
@@ -25,6 +26,7 @@ const COMMAND_HANDLERS = {
   status: async (args) => (await import("../lib/commands/status.mjs")).statusCommand(args),
   "pr-impact": async (args) => (await import("../lib/commands/prImpact.mjs")).prImpactCommand(args),
   sync: async (args) => (await import("../lib/commands/syncAuto.mjs")).syncCommand(args),
+  run: async (args) => (await import("../lib/commands/run.mjs")).runCommand(args),
   suggest: async (args) => (await import("../lib/commands/suggest.mjs")).suggestCommand(args),
   implement: async (args) => (await import("../lib/commands/implement.mjs")).implementCommand(args),
   context: async (args) => (await import("../lib/commands/context.mjs")).contextCommand(args),
@@ -70,6 +72,13 @@ ${formatCommandsHelp()}
     --mode <type>       cursor | generic | both (default: both)
     --copy, -c          Copy generated prompt(s) to clipboard
 
+  ${bold("run options:")}
+    --dry-run           Execute full flow without writing files
+    --json              Emit machine-readable events and result payload
+    --no-rollback       Keep changes even if validation fails
+    --provider <type>   auto | agent | local | prompt (default: auto)
+    --ide <name>        auto | cursor | vscode | windsurf (default: auto)
+
   ${bold("Typical workflow:")}
     ${gray('1. infernoflow context --intent "what I want to build"')}
     ${gray("2. [paste inferno/CONTEXT.md into Claude / Cursor / Copilot]")}
@@ -83,6 +92,7 @@ ${formatCommandsHelp()}
     ${gray("doc-gate --json")}
     ${gray("pr-impact --json")}
     ${gray("sync --auto --json")}
+    ${gray('run "task" --json')}
 `;
 
 const [, , cmd, ...rest] = process.argv;

package/lib/ai/ideDetection.mjs

@@ -0,0 +1,31 @@
+export function detectIdeContext(preferredIde = "auto") {
+  const env = process.env;
+  const lowerPreferred = String(preferredIde || "auto").toLowerCase();
+
+  const hasCursor = !!(env.CURSOR_TRACE_ID || env.CURSOR_AGENT || env.CURSOR_SESSION_ID);
+  const hasVscode = !!(env.VSCODE_PID || env.VSCODE_CWD || env.GITHUB_COPILOT_AGENT);
+  const hasWindsurf = !!(env.WINDSURF || env.CODEIUM || env.WINDSURF_SESSION_ID);
+
+  let ideDetected = "unknown";
+  if (hasCursor) ideDetected = "cursor";
+  else if (hasVscode) ideDetected = "vscode";
+  else if (hasWindsurf) ideDetected = "windsurf";
+
+  if (lowerPreferred !== "auto" && ["cursor", "vscode", "windsurf"].includes(lowerPreferred)) {
+    ideDetected = lowerPreferred;
+  }
+
+  const explicitAgentAvailability = env.INFERNO_AGENT_AVAILABLE;
+  const agentAvailable = explicitAgentAvailability != null
+    ? explicitAgentAvailability === "1" || explicitAgentAvailability === "true"
+    : ideDetected !== "unknown";
+
+  const reasonCodes = [];
+  if (ideDetected !== "unknown") reasonCodes.push(`IDE_${ideDetected.toUpperCase()}_DETECTED`);
+  else reasonCodes.push("IDE_UNKNOWN");
+  if (agentAvailable) reasonCodes.push("IDE_AGENT_AVAILABLE");
+  else reasonCodes.push("IDE_AGENT_UNAVAILABLE");
+
+  return { ideDetected, agentAvailable, reasonCodes };
+}
+

package/lib/ai/localProvider.mjs

@@ -0,0 +1,88 @@
+const DEFAULT_TIMEOUT_MS = 45000;
+
+function withTimeout(ms) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+  return { controller, timer };
+}
+
+async function callOllama(prompt, timeoutMs) {
+  const endpoint = process.env.INFERNO_LOCAL_ENDPOINT || "http://127.0.0.1:11434/api/generate";
+  const model = process.env.INFERNO_LOCAL_MODEL || "llama3.1:8b";
+  const { controller, timer } = withTimeout(timeoutMs);
+  try {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      signal: controller.signal,
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: false,
+      }),
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`local_model_http_${res.status}: ${body.slice(0, 240)}`);
+    }
+    const data = await res.json();
+    if (!data?.response || typeof data.response !== "string") {
+      throw new Error("local_model_invalid_response");
+    }
+    return data.response.trim();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function callOpenAICompat(prompt, timeoutMs) {
+  const endpoint = process.env.INFERNO_LOCAL_ENDPOINT || "http://127.0.0.1:1234/v1/chat/completions";
+  const model = process.env.INFERNO_LOCAL_MODEL || "local-model";
+  const apiKey = process.env.INFERNO_LOCAL_API_KEY || "local";
+  const { controller, timer } = withTimeout(timeoutMs);
+  try {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      signal: controller.signal,
+      body: JSON.stringify({
+        model,
+        temperature: 0.1,
+        messages: [
+          { role: "system", content: "Return JSON only." },
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`local_model_http_${res.status}: ${body.slice(0, 240)}`);
+    }
+    const data = await res.json();
+    const text = data?.choices?.[0]?.message?.content;
+    if (!text || typeof text !== "string") {
+      throw new Error("local_model_invalid_response");
+    }
+    return text.trim();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function generateWithLocalModel(prompt, options = {}) {
+  if (process.env.INFERNO_LOCAL_MOCK_RESPONSE) {
+    return process.env.INFERNO_LOCAL_MOCK_RESPONSE;
+  }
+
+  const provider = (process.env.INFERNO_LOCAL_PROVIDER || "ollama").toLowerCase();
+  const timeoutMs = Number(options.timeoutMs || process.env.INFERNO_LOCAL_TIMEOUT_MS || DEFAULT_TIMEOUT_MS);
+
+  if (provider === "openai") {
+    return callOpenAICompat(prompt, timeoutMs);
+  }
+  return callOllama(prompt, timeoutMs);
+}
+

package/lib/ai/providerRouter.mjs

@@ -0,0 +1,73 @@
+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,
+    };
+  }
+
+  if (providerRequested === "prompt") {
+    reasonCodes.push("PROMPT_PROVIDER_SELECTED");
+    return {
+      providerRequested,
+      providerResolved: "prompt",
+      ideDetected: ide.ideDetected,
+      agentAvailable: ide.agentAvailable,
+      reasonCodes,
+    };
+  }
+
+  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",
+      };
+    }
+    reasonCodes.push("IDE_AGENT_SELECTED");
+    return {
+      providerRequested,
+      providerResolved: "agent",
+      ideDetected: ide.ideDetected,
+      agentAvailable: ide.agentAvailable,
+      reasonCodes,
+    };
+  }
+
+  // auto
+  if (ide.agentAvailable) {
+    reasonCodes.push("IDE_AGENT_SELECTED");
+    return {
+      providerRequested: "auto",
+      providerResolved: "agent",
+      ideDetected: ide.ideDetected,
+      agentAvailable: ide.agentAvailable,
+      reasonCodes,
+    };
+  }
+
+  reasonCodes.push("FALLBACK_PROMPT_MODE");
+  return {
+    providerRequested: "auto",
+    providerResolved: "prompt",
+    ideDetected: ide.ideDetected,
+    agentAvailable: ide.agentAvailable,
+    reasonCodes,
+  };
+}
+