imhcode 2.0.5 → 3.0.0

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,
@@ -121,12 +122,12 @@ const DEFAULT_MODEL_PREFERENCES: Record<string, { engines: string[]; models: str
     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"],
+    engines: ["codex-fugu", "codex", "claude", "opencode"],
+    models: ["fugu-ultra", "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"],
+    engines: ["codex-fugu", "codex", "claude", "opencode"],
+    models: ["fugu-ultra", "gpt-5.5", "claude-sonnet-4-5", "deepseek-v4"],
   },
   fast: {
     engines: ["opencode", "codex", "qwen", "claude"],
@@ -295,6 +296,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 +307,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 +324,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,15 +479,27 @@ 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];
 
-  // 1. Add preferred engines from manifest
+  // 1. Add category preferred engines from DEFAULT_MODEL_PREFERENCES
+  const prefs = DEFAULT_MODEL_PREFERENCES[category];
+  if (prefs) {
+    for (const eng of prefs.engines) {
+      const clean = eng.toLowerCase().trim();
+      if (!queue.includes(clean) && installed.includes(clean)) {
+        queue.push(clean);
+      }
+    }
+  }
+
+  // 2. Add preferred engines from manifest
   if (agent.manifest.preferred_engines) {
     for (const eng of agent.manifest.preferred_engines) {
       const clean = eng.toLowerCase().trim();
@@ -493,7 +509,7 @@ function getFailoverQueue(
     }
   }
 
-  // 2. Add fallback engines from manifest
+  // 3. Add fallback engines from manifest
   if (agent.manifest.fallback_engines) {
     for (const eng of agent.manifest.fallback_engines) {
       const clean = eng.toLowerCase().trim();
@@ -503,20 +519,36 @@ function getFailoverQueue(
     }
   }
 
-  // 3. Add any other installed engines as a last resort
+  // 4. Add any other installed engines as a last resort
   for (const eng of installed) {
     if (!queue.includes(eng)) {
       queue.push(eng);
     }
   }
 
-  return queue;
+  // 5. 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,
@@ -527,6 +559,23 @@ function getModelForEngine(
     return config.model_routing[category].model;
   }
 
+  // Check if there is a category preferred model for this engine in DEFAULT_MODEL_PREFERENCES
+  const lookupEngine = (engineName.startsWith("agy") || engineName === "antigravity") ? "agy" : engineName;
+  const prefs = DEFAULT_MODEL_PREFERENCES[category];
+  if (prefs) {
+    const engineIdx = prefs.engines.indexOf(lookupEngine);
+    if (engineIdx >= 0) {
+      const preferredMdl = prefs.models[engineIdx];
+      const engineData = config?.available_engines?.[engineName];
+      if (engineData?.models?.length > 0) {
+        const exactMatch = engineData.models.find((m: string) =>
+          m.toLowerCase().includes(preferredMdl.toLowerCase().replace(/-/g, ""))
+        );
+        if (exactMatch) return exactMatch;
+      }
+    }
+  }
+
   // Check available models in config for this engine
   const engineData = config?.available_engines?.[engineName];
   if (engineData?.models?.length > 0) {

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;