@nathapp/nax 0.35.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "AI Coding Agent Orchestrator \u2014 loops until done",
   "type": "module",
   "bin": {

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/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/index.ts

@@ -12,3 +12,5 @@ export {
   formatCostWithConfidence,
 } from "./cost";
 export { validateAgentForTier, validateAgentFeature, describeAgentCapabilities } from "./validation";
+export type { AgentVersionInfo } from "./version-detection";
+export { getAgentVersion, getAgentVersions } from "./version-detection";

package/src/agents/registry.ts

@@ -4,7 +4,10 @@
  * Discovers and manages available coding agents.
  */
 
+import { AiderAdapter } from "./adapters/aider";
 import { CodexAdapter } from "./adapters/codex";
+import { GeminiAdapter } from "./adapters/gemini";
+import { OpenCodeAdapter } from "./adapters/opencode";
 import { ClaudeCodeAdapter } from "./claude";
 import type { AgentAdapter } from "./types";
 
@@ -12,8 +15,9 @@ import type { AgentAdapter } from "./types";
 export const ALL_AGENTS: AgentAdapter[] = [
   new ClaudeCodeAdapter(),
   new CodexAdapter(),
-  // Future: new OpenCodeAdapter(),
-  // Future: new GeminiAdapter(),
+  new OpenCodeAdapter(),
+  new GeminiAdapter(),
+  new AiderAdapter(),
 ];
 
 /** Get all registered agent names */

package/src/agents/version-detection.ts

@@ -0,0 +1,109 @@
+/**
+ * Agent version detection utilities
+ *
+ * Extracts version information from installed agent binaries
+ * by running `<agent> --version` and parsing the output.
+ */
+
+import { getInstalledAgents } from "./registry";
+import type { AgentAdapter } from "./types";
+
+/**
+ * Information about an installed agent including its version
+ */
+export interface AgentVersionInfo {
+  /** Agent name (e.g., "codex", "aider") */
+  name: string;
+  /** Human-readable display name */
+  displayName: string;
+  /** Agent version or null if not installed/unable to detect */
+  version: string | null;
+  /** Whether the agent binary is installed */
+  installed: boolean;
+}
+
+/**
+ * Dependency injection for testability
+ */
+export const _versionDetectionDeps = {
+  spawn(
+    cmd: string[],
+    opts: { stdout: "pipe"; stderr: "pipe" },
+  ): {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    exited: Promise<number>;
+  } {
+    return Bun.spawn(cmd, opts) as unknown as {
+      stdout: ReadableStream<Uint8Array>;
+      stderr: ReadableStream<Uint8Array>;
+      exited: Promise<number>;
+    };
+  },
+};
+
+/**
+ * Get version for a single agent binary
+ *
+ * Runs `<agent> --version` and extracts version string.
+ * Returns null if agent not found or version detection fails.
+ */
+export async function getAgentVersion(binaryName: string): Promise<string | null> {
+  try {
+    const proc = _versionDetectionDeps.spawn([binaryName, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return null;
+    }
+
+    const stdout = await new Response(proc.stdout).text();
+    const versionLine = stdout.trim().split("\n")[0];
+
+    // Extract version from common formats:
+    // "tool version 1.2.3"
+    // "v1.2.3"
+    // "1.2.3"
+    const versionMatch = versionLine.match(/v?(\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?)/);
+    if (versionMatch) {
+      return versionMatch[0];
+    }
+
+    // If no version pattern matched, return the first line as-is
+    return versionLine || null;
+  } catch {
+    // Bun.spawn throws ENOENT if binary not found
+    return null;
+  }
+}
+
+/**
+ * Get version information for all configured agents
+ *
+ * Returns list of agents with their installation status and version info.
+ */
+export async function getAgentVersions(): Promise<AgentVersionInfo[]> {
+  const agents = await getInstalledAgents();
+  const agentsByName = new Map(agents.map((a) => [a.name, a]));
+
+  // Import ALL_AGENTS to include non-installed ones
+  const { ALL_AGENTS } = await import("./registry");
+
+  const versions = await Promise.all(
+    ALL_AGENTS.map(async (agent: AgentAdapter): Promise<AgentVersionInfo> => {
+      const version = agentsByName.has(agent.name) ? await getAgentVersion(agent.binary) : null;
+
+      return {
+        name: agent.name,
+        displayName: agent.displayName,
+        version,
+        installed: agentsByName.has(agent.name),
+      };
+    }),
+  );
+
+  return versions;
+}

package/src/cli/agents.ts

@@ -0,0 +1,87 @@
+/**
+ * Agents Command
+ *
+ * Lists available agents with their binary paths, versions, and health status.
+ */
+
+import { ALL_AGENTS } from "../agents/registry";
+import { getAgentVersion } from "../agents/version-detection";
+import type { NaxConfig } from "../config/schema";
+
+/**
+ * List all agents with status, version, and capabilities.
+ *
+ * @param config - nax configuration
+ * @param _workdir - Working directory (for consistency with other commands)
+ */
+export async function agentsListCommand(config: NaxConfig, _workdir: string): Promise<void> {
+  // Get version info for all agents
+  const agentVersions = await Promise.all(
+    ALL_AGENTS.map(async (agent) => ({
+      name: agent.name,
+      displayName: agent.displayName,
+      binary: agent.binary,
+      version: await getAgentVersion(agent.binary),
+      installed: await agent.isInstalled(),
+      capabilities: agent.capabilities,
+      isDefault: config.autoMode.defaultAgent === agent.name,
+    })),
+  );
+
+  // Build table rows
+  const rows = agentVersions.map((info) => {
+    const status = info.installed ? "installed" : "unavailable";
+    const versionStr = info.version || "-";
+    const defaultMarker = info.isDefault ? " (default)" : "";
+
+    return {
+      name: info.displayName + defaultMarker,
+      status,
+      version: versionStr,
+      binary: info.binary,
+      tiers: info.capabilities.supportedTiers.join(", "),
+    };
+  });
+
+  if (rows.length === 0) {
+    console.log("No agents available.");
+    return;
+  }
+
+  // Calculate column widths
+  const widths = {
+    name: Math.max(5, ...rows.map((r) => r.name.length)),
+    status: Math.max(6, ...rows.map((r) => r.status.length)),
+    version: Math.max(7, ...rows.map((r) => r.version.length)),
+    binary: Math.max(6, ...rows.map((r) => r.binary.length)),
+    tiers: Math.max(5, ...rows.map((r) => r.tiers.length)),
+  };
+
+  // Display table
+  console.log("\nAvailable Agents:\n");
+  console.log(
+    `${pad("Agent", widths.name)}  ${pad("Status", widths.status)}  ${pad("Version", widths.version)}  ${pad("Binary", widths.binary)}  ${pad("Tiers", widths.tiers)}`,
+  );
+  console.log(
+    `${"-".repeat(widths.name)}  ${"-".repeat(widths.status)}  ${"-".repeat(widths.version)}  ${"-".repeat(widths.binary)}  ${"-".repeat(widths.tiers)}`,
+  );
+
+  for (const row of rows) {
+    console.log(
+      `${pad(row.name, widths.name)}  ${pad(row.status, widths.status)}  ${pad(row.version, widths.version)}  ${pad(row.binary, widths.binary)}  ${pad(row.tiers, widths.tiers)}`,
+    );
+  }
+
+  console.log();
+}
+
+/**
+ * Pad string to width.
+ *
+ * @param str - String to pad
+ * @param width - Target width
+ * @returns Padded string
+ */
+function pad(str: string, width: number): string {
+  return str.padEnd(width);
+}