imhcode 2.0.5 → 3.0.1

package/src/orchestrator/executor.ts

@@ -129,9 +129,14 @@ export class ClaudeCodeCLIAdapter implements EngineAdapter {
     const binary = resolveBinary("claude", [
       "~/.local/bin/claude",
       "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
     ]);
 
-    const args = ["-p"];
+    const args = [
+      "-p",
+      "--dangerously-skip-permissions",
+      "--no-session-persistence",
+    ];
     if (model && model !== "claude" && model !== "default") {
       args.push("--model", model);
     }
@@ -155,8 +160,9 @@ export class OpenCodeCLIAdapter implements EngineAdapter {
     if (model && model !== "opencode" && model !== "default") {
       args.push("-m", model);
     }
+    args.push(prompt);
 
-    const rawOutput = await runCliWithStdin(binary, args, prompt, "OpenCode");
+    const rawOutput = await runCliWithStdin(binary, args, "", "OpenCode");
 
     // OpenCode prints progress lines starting with "> build ·" or similar.
     // Filter these out to get a clean result.
@@ -212,28 +218,78 @@ export class CodexCLIAdapter implements EngineAdapter {
   }
 }
 
+// ─── Codex Fugu CLI Adapter ────────────────────────────────────────────────────
+
+export class CodexFuguCLIAdapter implements EngineAdapter {
+  readonly name = "codex-fugu";
+
+  async run(prompt: string, model: string): Promise<string> {
+    const binary = resolveBinary("codex-fugu", [
+      "~/.local/bin/codex-fugu",
+      "/usr/local/bin/codex-fugu",
+      "/opt/homebrew/bin/codex-fugu",
+    ]);
+
+    const tempFile = path.join(
+      process.cwd(),
+      `.codex-fugu-out-${crypto.randomBytes(6).toString("hex")}.txt`
+    );
+
+    const args = [
+      "--dangerously-bypass-approvals-and-sandbox",
+      "exec",
+      "-",
+      "-o",
+      tempFile,
+    ];
+    if (model && model !== "codex-fugu" && model !== "default") {
+      args.push("-m", model);
+    }
+
+    try {
+      await runCliWithStdin(binary, args, prompt, "Codex Fugu");
+      if (!fs.existsSync(tempFile)) {
+        throw new Error(`Codex Fugu execution succeeded but output file was not created at ${tempFile}`);
+      }
+      const output = fs.readFileSync(tempFile, "utf8");
+      return output;
+    } finally {
+      if (fs.existsSync(tempFile)) {
+        fs.unlinkSync(tempFile);
+      }
+    }
+  }
+}
+
 // ─── Antigravity CLI Adapter (agy) ────────────────────────────────────────────
 // Google Antigravity CLI — binary: `agy`
 // Docs: https://antigravity.google/docs/cli-using
 // Headless: `agy -p "<prompt>"` or via stdin with `agy -p`
 
 export class AgyCLIAdapter implements EngineAdapter {
-  readonly name = "agy";
+  readonly name: string;
+
+  constructor(name: string = "agy") {
+    this.name = name;
+  }
 
   async run(prompt: string, model: string): Promise<string> {
-    const binary = resolveBinary("agy", [
-      "~/.local/bin/agy",
-      "/usr/local/bin/agy",
-      "/opt/homebrew/bin/agy",
+    const binary = resolveBinary(this.name, [
+      `~/.local/bin/${this.name}`,
+      `/usr/local/bin/${this.name}`,
+      `/opt/homebrew/bin/${this.name}`,
     ]);
 
-    const args: string[] = [];
-    if (model && model !== "agy" && model !== "default") {
-      args.push("--model", model);
+    const args: string[] = [
+      "--dangerously-skip-permissions",
+      "-p",
+      prompt,
+    ];
+    if (model && model !== this.name && model !== "agy" && model !== "default") {
+      args.unshift("--model", model);
     }
-    args.push("-p", "-");
 
-    return await runCliWithStdin(binary, args, prompt, "Antigravity (agy)");
+    return await runCliWithStdin(binary, args, "", `Antigravity (${this.name})`);
   }
 }
 
@@ -311,8 +367,11 @@ export function getAdapter(
   if (engine === "codex") {
     return new CodexCLIAdapter();
   }
-  if (engine === "agy" || engine === "antigravity") {
-    return new AgyCLIAdapter();
+  if (engine === "codex-fugu" || engine === "codexfugu" || engine === "fugu") {
+    return new CodexFuguCLIAdapter();
+  }
+  if (engine === "agy" || engine === "antigravity" || /^agy\d+$/.test(engine)) {
+    return new AgyCLIAdapter(engine === "antigravity" ? "agy" : engine);
   }
   if (engine === "qwen" || engine === "qwencode" || engine === "qwen-code") {
     return new QwenCodeCLIAdapter();
@@ -325,6 +384,9 @@ export function getAdapter(
   if (engine.startsWith("claude")) {
     return new ClaudeCodeCLIAdapter();
   }
+  if (engine.startsWith("codex-fugu") || engine.startsWith("fugu")) {
+    return new CodexFuguCLIAdapter();
+  }
   if (engine.startsWith("gpt") || engine.startsWith("o1") || engine.startsWith("o3") || engine.startsWith("o4")) {
     return new CodexCLIAdapter();
   }
@@ -364,6 +426,9 @@ export function getAdapter(
   if (binaryExists("claude", ["~/.local/bin/claude"])) {
     return new ClaudeCodeCLIAdapter();
   }
+  if (binaryExists("codex-fugu", ["~/.local/bin/codex-fugu", "/opt/homebrew/bin/codex-fugu"])) {
+    return new CodexFuguCLIAdapter();
+  }
   if (binaryExists("codex", ["~/Library/PhpWebStudy/env/node/bin/codex"])) {
     return new CodexCLIAdapter();
   }
@@ -379,7 +444,7 @@ export function getAdapter(
 
   throw new Error(
     `❌ No active CLI agent engine could be auto-detected.\n` +
-      `  Supported engines: claude, opencode, codex, agy, qwen, mimo\n` +
+      `  Supported engines: claude, opencode, codex, codex-fugu, agy, qwen, mimo\n` +
       `  Install one and re-run, or specify with: --engine <engine-name>\n` +
       `  Run "imhcode --help" for more information.`
   );

package/src/orchestrator/index.ts

@@ -39,6 +39,7 @@ export {
   ClaudeCodeCLIAdapter,
   OpenCodeCLIAdapter,
   CodexCLIAdapter,
+  CodexFuguCLIAdapter,
   AgyCLIAdapter,
   QwenCodeCLIAdapter,
   MimoCodeCLIAdapter,
@@ -106,34 +107,6 @@ export const AGENT_CATEGORY_MAP: Record<string, string> = {
  * Model routing: recommended models per category and engine.
  * Preferences: Mimo v2.5 Pro → frontend, DeepSeek → backend,
  *              GPT → testing/review, Claude → planning, DeepSeek Flash → fast
- */
-const DEFAULT_MODEL_PREFERENCES: Record<string, { engines: string[]; models: string[] }> = {
-  frontend: {
-    engines: ["mimo", "codex", "claude", "opencode"],
-    models: ["mimo-vl-v2.5-pro", "gpt-5.5", "claude-opus-4-6", "gemini-3.5-flash"],
-  },
-  backend: {
-    engines: ["opencode", "codex", "claude", "qwen"],
-    models: ["deepseek-v4-pro", "gpt-5.5", "claude-sonnet-4-5", "qwen3-coder-max"],
-  },
-  planning: {
-    engines: ["claude", "codex", "opencode"],
-    models: ["claude-opus-4-6", "gpt-5.5", "deepseek-v4-pro"],
-  },
-  testing: {
-    engines: ["codex", "claude", "opencode"],
-    models: ["gpt-5.5", "claude-opus-4-6", "deepseek-v4-pro"],
-  },
-  review: {
-    engines: ["codex", "claude", "opencode"],
-    models: ["gpt-5.5", "claude-sonnet-4-5", "deepseek-v4"],
-  },
-  fast: {
-    engines: ["opencode", "codex", "qwen", "claude"],
-    models: ["deepseek-v4-flash", "gpt-5.4-mini", "qwen3-coder-flash", "claude-haiku-3-5"],
-  },
-};
-
 // ─── Config Loader ────────────────────────────────────────────────────────────
 
 /**
@@ -217,29 +190,7 @@ function resolveModelForTask(
     };
   }
 
-  // 2. Find best available model from installed engines
-  const prefs = DEFAULT_MODEL_PREFERENCES[effectiveCategory];
-  if (prefs && config?.available_engines) {
-    for (let i = 0; i < prefs.engines.length; i++) {
-      const preferredEngine = prefs.engines[i];
-      const preferredModel = prefs.models[i];
-      const engineData = config.available_engines[preferredEngine];
-
-      if (engineData?.models?.length > 0) {
-        // Check if preferred model is available
-        const exactMatch = engineData.models.find((m: string) =>
-          m.toLowerCase().includes(preferredModel.toLowerCase().replace(/-/g, ""))
-        );
-        if (exactMatch) {
-          return { engine: preferredEngine, model: exactMatch };
-        }
-        // Use any available model from this preferred engine
-        return { engine: preferredEngine, model: engineData.models[0] };
-      }
-    }
-  }
-
-  // 3. Fallback: use primary engine + default model
+  // 2. Fallback: use primary engine + default model
   const primaryEngine = config?.primary_engine || engine;
   const defaultModel = config?.default_model || agent.manifest.default_model;
   return { engine: primaryEngine, model: defaultModel };
@@ -295,6 +246,7 @@ export async function runAgent(
   if (resolvedEngine === "antigravity" || resolvedEngine === "antigravity-ide") resolvedEngine = "agy";
   if (resolvedEngine === "qwencode" || resolvedEngine === "qwen-code") resolvedEngine = "qwen";
   if (resolvedEngine === "mimocode" || resolvedEngine === "mimo-code") resolvedEngine = "mimo";
+  if (resolvedEngine === "codexfugu" || resolvedEngine === "fugu") resolvedEngine = "codex-fugu";
 
   // 2. Build the initial prompt (category-aware, compact context)
   const finalPrompt = buildPrompt(agent, task, acceptanceCriteria, cwd);
@@ -305,9 +257,11 @@ export async function runAgent(
   // 3. Load config for routing checks
   const config = loadConfig(cwd);
   const category = AGENT_CATEGORY_MAP[agent.manifest.id] ?? "backend";
+  const complexity = detectTaskComplexity(task);
+  const effectiveCategory = complexity === "light" ? "fast" : category;
 
   // 4. Build the failover queue of engines to try
-  const failoverQueue = getFailoverQueue(agent, config, resolvedEngine);
+  const failoverQueue = getFailoverQueue(agent, config, resolvedEngine, effectiveCategory);
 
   let currentEngineIndex = 0;
   let currentEngine = resolvedEngine;
@@ -320,7 +274,7 @@ export async function runAgent(
   while (currentEngineIndex < failoverQueue.length) {
     currentEngine = failoverQueue[currentEngineIndex];
     if (currentEngineIndex > 0) {
-      currentModel = getModelForEngine(config, currentEngine, category, agent);
+      currentModel = getModelForEngine(config, currentEngine, effectiveCategory, agent);
     } else {
       currentModel = resolvedModel;
     }
@@ -475,10 +429,11 @@ function getInstalledEngines(config: any): string[] {
 /**
  * Builds the ordered array of fallback engines to attempt during execution.
  */
-function getFailoverQueue(
+export function getFailoverQueue(
   agent: LoadedAgent,
   config: any,
-  initialEngine: string
+  initialEngine: string,
+  category?: string
 ): string[] {
   const installed = getInstalledEngines(config);
   const queue = [initialEngine];
@@ -510,13 +465,29 @@ function getFailoverQueue(
     }
   }
 
-  return queue;
+  // 4. Expand agy to include agy2, agy3, agy4... etc. right after agy
+  const expandedQueue: string[] = [];
+  for (const eng of queue) {
+    if (!expandedQueue.includes(eng)) {
+      expandedQueue.push(eng);
+    }
+    if (eng === "agy" || eng === "antigravity") {
+      for (let i = 2; i <= 10; i++) {
+        const key = `agy${i}`;
+        if (installed.includes(key) && !expandedQueue.includes(key)) {
+          expandedQueue.push(key);
+        }
+      }
+    }
+  }
+
+  return expandedQueue;
 }
 
 /**
  * Resolves the model to use for a failover engine.
  */
-function getModelForEngine(
+export function getModelForEngine(
   config: any,
   engineName: string,
   category: string,

package/src/orchestrator/types.ts

@@ -67,7 +67,7 @@ export interface LoadedAgent {
 // ─── Execution ────────────────────────────────────────────────────────────────
 
 export interface ExecutionOptions {
-  /** Override the CLI engine (claude, opencode, codex, antigravity) */
+  /** Override the CLI engine (claude, opencode, codex, codex-fugu, antigravity) */
   engine?: string;
   /** Explicitly override the model (e.g. gpt-4o, gemini-3.5-flash) */
   model?: string;