@nathapp/nax 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "AI Coding Agent Orchestrator \u2014 loops until done",
   "type": "module",
   "bin": {
@@ -20,7 +20,6 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
     "@types/react": "^19.2.14",
     "chalk": "^5.6.2",
     "commander": "^13.1.0",

package/src/agents/adapters/aider.ts

@@ -0,0 +1,135 @@
+/**
+ * Aider Agent Adapter — implements AgentAdapter interface
+ *
+ * Provides uniform interface for spawning Aider agent processes,
+ * supporting one-shot completions in headless mode.
+ */
+
+import type {
+  AgentAdapter,
+  AgentCapabilities,
+  AgentResult,
+  AgentRunOptions,
+  CompleteOptions,
+  DecomposeOptions,
+  DecomposeResult,
+  PlanOptions,
+  PlanResult,
+} from "../types";
+import { CompleteError } from "../types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Injectable dependencies — matches the _deps pattern used in other adapters
+// These are replaced in unit tests to intercept Bun.spawn and Bun.which calls.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const _aiderCompleteDeps = {
+  which(name: string): string | null {
+    return Bun.which(name);
+  },
+  spawn(
+    cmd: string[],
+    opts: { stdout: "pipe"; stderr: "pipe" | "inherit" },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    pid: number;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+      pid: number;
+    };
+  },
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// AiderAdapter implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Maximum characters to capture from agent stdout.
+ */
+const MAX_AGENT_OUTPUT_CHARS = 5000;
+
+export class AiderAdapter implements AgentAdapter {
+  readonly name = "aider";
+  readonly displayName = "Aider";
+  readonly binary = "aider";
+
+  readonly capabilities: AgentCapabilities = {
+    supportedTiers: ["balanced"],
+    maxContextTokens: 20_000,
+    features: new Set<"tdd" | "review" | "refactor" | "batch">(["refactor"]),
+  };
+
+  async isInstalled(): Promise<boolean> {
+    const path = _aiderCompleteDeps.which("aider");
+    return path !== null;
+  }
+
+  buildCommand(options: AgentRunOptions): string[] {
+    return ["aider", "--message", options.prompt, "--yes"];
+  }
+
+  async run(options: AgentRunOptions): Promise<AgentResult> {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+
+    const proc = _aiderCompleteDeps.spawn(cmd, {
+      stdout: "pipe",
+      stderr: "inherit",
+    });
+
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const durationMs = Date.now() - startTime;
+
+    return {
+      success: exitCode === 0,
+      exitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
+      rateLimited: false,
+      durationMs,
+      estimatedCost: 0,
+      pid: proc.pid,
+    };
+  }
+
+  async complete(prompt: string, options?: CompleteOptions): Promise<string> {
+    const cmd = ["aider", "--message", prompt, "--yes"];
+
+    if (options?.model) {
+      cmd.push("--model", options.model);
+    }
+
+    const proc = _aiderCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+
+    return trimmed;
+  }
+
+  async plan(_options: PlanOptions): Promise<PlanResult> {
+    throw new Error("AiderAdapter.plan() not implemented");
+  }
+
+  async decompose(_options: DecomposeOptions): Promise<DecomposeResult> {
+    throw new Error("AiderAdapter.decompose() not implemented");
+  }
+}

package/src/agents/adapters/codex.ts

@@ -0,0 +1,153 @@
+/**
+ * Codex Agent Adapter — implements AgentAdapter interface
+ *
+ * Provides uniform interface for spawning Codex agent processes,
+ * supporting one-shot completions and headless execution.
+ */
+
+import type {
+  AgentAdapter,
+  AgentCapabilities,
+  AgentResult,
+  AgentRunOptions,
+  CompleteOptions,
+  DecomposeOptions,
+  DecomposeResult,
+  PlanOptions,
+  PlanResult,
+} from "../types";
+import { CompleteError } from "../types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Injectable dependencies — matches the _deps pattern used in claude.ts
+// These are replaced in unit tests to intercept Bun.spawn calls.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const _codexRunDeps = {
+  which(name: string): string | null {
+    return Bun.which(name);
+  },
+  spawn(
+    cmd: string[],
+    opts: { cwd?: string; stdout: "pipe"; stderr: "pipe" | "inherit"; env?: Record<string, string | undefined> },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    pid: number;
+    kill(signal?: number | NodeJS.Signals): void;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+      pid: number;
+      kill(signal?: number | NodeJS.Signals): void;
+    };
+  },
+};
+
+export const _codexCompleteDeps = {
+  spawn(
+    cmd: string[],
+    opts: { stdout: "pipe"; stderr: "pipe" | "inherit" },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    pid: number;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+      pid: number;
+    };
+  },
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CodexAdapter implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Maximum characters to capture from agent stdout.
+ */
+const MAX_AGENT_OUTPUT_CHARS = 5000;
+
+export class CodexAdapter implements AgentAdapter {
+  readonly name = "codex";
+  readonly displayName = "Codex";
+  readonly binary = "codex";
+
+  readonly capabilities: AgentCapabilities = {
+    supportedTiers: ["fast", "balanced"],
+    maxContextTokens: 8_000,
+    features: new Set<"tdd" | "review" | "refactor" | "batch">(["tdd", "refactor"]),
+  };
+
+  async isInstalled(): Promise<boolean> {
+    const path = _codexRunDeps.which("codex");
+    return path !== null;
+  }
+
+  buildCommand(options: AgentRunOptions): string[] {
+    return ["codex", "-q", "--prompt", options.prompt];
+  }
+
+  async run(options: AgentRunOptions): Promise<AgentResult> {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+
+    const proc = _codexRunDeps.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "inherit",
+    });
+
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const durationMs = Date.now() - startTime;
+
+    return {
+      success: exitCode === 0,
+      exitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
+      rateLimited: false,
+      durationMs,
+      estimatedCost: 0,
+      pid: proc.pid,
+    };
+  }
+
+  async complete(prompt: string, _options?: CompleteOptions): Promise<string> {
+    const cmd = ["codex", "-q", "--prompt", prompt];
+
+    const proc = _codexCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+
+    return trimmed;
+  }
+
+  async plan(_options: PlanOptions): Promise<PlanResult> {
+    throw new Error("CodexAdapter.plan() not implemented");
+  }
+
+  async decompose(_options: DecomposeOptions): Promise<DecomposeResult> {
+    throw new Error("CodexAdapter.decompose() not implemented");
+  }
+}

package/src/agents/adapters/gemini.ts

@@ -0,0 +1,177 @@
+/**
+ * Gemini CLI Agent Adapter — implements AgentAdapter interface
+ *
+ * Provides uniform interface for spawning Gemini CLI processes,
+ * supporting one-shot completions via 'gemini -p' and Google auth detection.
+ */
+
+import type {
+  AgentAdapter,
+  AgentCapabilities,
+  AgentResult,
+  AgentRunOptions,
+  CompleteOptions,
+  DecomposeOptions,
+  DecomposeResult,
+  PlanOptions,
+  PlanResult,
+} from "../types";
+import { CompleteError } from "../types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Injectable dependencies — follows the _deps pattern
+// Replaced in unit tests to intercept Bun.spawn/Bun.which calls.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const _geminiRunDeps = {
+  which(name: string): string | null {
+    return Bun.which(name);
+  },
+  spawn(
+    cmd: string[],
+    opts: { cwd?: string; stdout: "pipe"; stderr: "pipe" | "inherit"; env?: Record<string, string | undefined> },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    pid: number;
+    kill(signal?: number | NodeJS.Signals): void;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+      pid: number;
+      kill(signal?: number | NodeJS.Signals): void;
+    };
+  },
+};
+
+export const _geminiCompleteDeps = {
+  spawn(
+    cmd: string[],
+    opts: { stdout: "pipe"; stderr: "pipe" | "inherit" },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    pid: number;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+      pid: number;
+    };
+  },
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// GeminiAdapter implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+const MAX_AGENT_OUTPUT_CHARS = 5000;
+
+export class GeminiAdapter implements AgentAdapter {
+  readonly name = "gemini";
+  readonly displayName = "Gemini CLI";
+  readonly binary = "gemini";
+
+  readonly capabilities: AgentCapabilities = {
+    supportedTiers: ["fast", "balanced", "powerful"],
+    maxContextTokens: 1_000_000,
+    features: new Set<"tdd" | "review" | "refactor" | "batch">(["tdd", "review", "refactor"]),
+  };
+
+  async isInstalled(): Promise<boolean> {
+    const path = _geminiRunDeps.which("gemini");
+    if (path === null) {
+      return false;
+    }
+
+    // Check Google auth — run 'gemini' with a flag that shows auth status
+    try {
+      const proc = _geminiRunDeps.spawn(["gemini", "--version"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        return false;
+      }
+
+      const stdout = await new Response(proc.stdout).text();
+      const lowerOut = stdout.toLowerCase();
+
+      // If output explicitly says "not logged in", auth has failed
+      if (lowerOut.includes("not logged in")) {
+        return false;
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  buildCommand(options: AgentRunOptions): string[] {
+    return ["gemini", "-p", options.prompt];
+  }
+
+  async run(options: AgentRunOptions): Promise<AgentResult> {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+
+    const proc = _geminiRunDeps.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "inherit",
+    });
+
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const durationMs = Date.now() - startTime;
+
+    return {
+      success: exitCode === 0,
+      exitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
+      rateLimited: false,
+      durationMs,
+      estimatedCost: 0,
+      pid: proc.pid,
+    };
+  }
+
+  async complete(prompt: string, _options?: CompleteOptions): Promise<string> {
+    const cmd = ["gemini", "-p", prompt];
+
+    const proc = _geminiCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+
+    return trimmed;
+  }
+
+  async plan(_options: PlanOptions): Promise<PlanResult> {
+    throw new Error("GeminiAdapter.plan() not implemented");
+  }
+
+  async decompose(_options: DecomposeOptions): Promise<DecomposeResult> {
+    throw new Error("GeminiAdapter.decompose() not implemented");
+  }
+}

package/src/agents/adapters/opencode.ts

@@ -0,0 +1,106 @@
+/**
+ * OpenCode Agent Adapter — implements AgentAdapter interface
+ *
+ * Provides uniform interface for spawning OpenCode agent processes,
+ * supporting one-shot completions.
+ */
+
+import type {
+  AgentAdapter,
+  AgentCapabilities,
+  AgentResult,
+  AgentRunOptions,
+  CompleteOptions,
+  DecomposeOptions,
+  DecomposeResult,
+  PlanOptions,
+  PlanResult,
+} from "../types";
+import { CompleteError } from "../types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Injectable dependencies — matches the _deps pattern used in claude.ts
+// These are replaced in unit tests to intercept Bun.spawn calls.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const _opencodeCompleteDeps = {
+  which(name: string): string | null {
+    return Bun.which(name);
+  },
+  spawn(
+    cmd: string[],
+    opts: { stdout: "pipe"; stderr: "pipe" | "inherit" },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+    pid: number;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+      pid: number;
+    };
+  },
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenCodeAdapter implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+export class OpenCodeAdapter implements AgentAdapter {
+  readonly name = "opencode";
+  readonly displayName = "OpenCode";
+  readonly binary = "opencode";
+
+  readonly capabilities: AgentCapabilities = {
+    supportedTiers: ["fast", "balanced"],
+    maxContextTokens: 8_000,
+    features: new Set<"tdd" | "review" | "refactor" | "batch">(["tdd", "refactor"]),
+  };
+
+  async isInstalled(): Promise<boolean> {
+    const path = _opencodeCompleteDeps.which("opencode");
+    return path !== null;
+  }
+
+  buildCommand(_options: AgentRunOptions): string[] {
+    throw new Error("OpenCodeAdapter.buildCommand() not implemented");
+  }
+
+  async run(_options: AgentRunOptions): Promise<AgentResult> {
+    throw new Error("OpenCodeAdapter.run() not implemented");
+  }
+
+  async complete(prompt: string, _options?: CompleteOptions): Promise<string> {
+    const cmd = ["opencode", "--prompt", prompt];
+
+    const proc = _opencodeCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+
+    return trimmed;
+  }
+
+  async plan(_options: PlanOptions): Promise<PlanResult> {
+    throw new Error("OpenCodeAdapter.plan() not implemented");
+  }
+
+  async decompose(_options: DecomposeOptions): Promise<DecomposeResult> {
+    throw new Error("OpenCodeAdapter.decompose() not implemented");
+  }
+}

package/src/agents/claude-plan.ts

@@ -9,6 +9,7 @@ import { join } from "node:path";
 
 import type { PidRegistry } from "../execution/pid-registry";
 import { getLogger } from "../logger";
+import { resolveBalancedModelDef } from "./model-resolution";
 import type { AgentRunOptions } from "./types";
 import type { PlanOptions, PlanResult } from "./types-extended";
 
@@ -18,9 +19,14 @@ import type { PlanOptions, PlanResult } from "./types-extended";
 export function buildPlanCommand(binary: string, options: PlanOptions): string[] {
   const cmd = [binary, "--permission-mode", "plan"];
 
-  // Add model if specified
-  if (options.modelDef) {
-    cmd.push("--model", options.modelDef.model);
+  // Add model if specified (explicit or resolved from config)
+  let modelDef = options.modelDef;
+  if (!modelDef && options.config) {
+    modelDef = resolveBalancedModelDef(options.config);
+  }
+
+  if (modelDef) {
+    cmd.push("--model", modelDef.model);
   }
 
   // Add dangerously-skip-permissions for automation
@@ -64,13 +70,24 @@ export async function runPlan(
   pidRegistry: PidRegistry,
   buildAllowedEnv: (options: AgentRunOptions) => Record<string, string | undefined>,
 ): Promise<PlanResult> {
+  const { resolveBalancedModelDef } = await import("./model-resolution");
+
   const cmd = buildPlanCommand(binary, options);
 
+  // Resolve model: explicit modelDef > config.models.balanced > throw
+  let modelDef = options.modelDef;
+  if (!modelDef) {
+    if (!options.config) {
+      throw new Error("runPlan() requires either modelDef or config with models.balanced configured");
+    }
+    modelDef = resolveBalancedModelDef(options.config);
+  }
+
   const envOptions: AgentRunOptions = {
     workdir: options.workdir,
-    modelDef: options.modelDef || { provider: "anthropic", model: "claude-sonnet-4-5", env: {} },
+    modelDef,
     prompt: "",
-    modelTier: "balanced",
+    modelTier: options.modelTier || "balanced",
     timeoutSeconds: 600,
   };