@nathapp/nax 0.50.2 → 0.51.0

package/src/agents/aider/adapter.ts

@@ -1,135 +0,0 @@
-/**
- * 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/claude/adapter.ts

@@ -1,258 +0,0 @@
-/**
- * Claude Code Agent Adapter
- *
- * Main adapter class coordinating execution, completion, decomposition, and interactive modes.
- */
-
-import { resolvePermissions } from "../../config/permissions";
-import { PidRegistry } from "../../execution/pid-registry";
-import { withProcessTimeout } from "../../execution/timeout-handler";
-import { getLogger } from "../../logger";
-import { buildDecomposePrompt, parseDecomposeOutput } from "../shared/decompose";
-import type {
-  AgentAdapter,
-  AgentCapabilities,
-  AgentResult,
-  AgentRunOptions,
-  CompleteOptions,
-  DecomposeOptions,
-  DecomposeResult,
-  InteractiveRunOptions,
-  PlanOptions,
-  PlanResult,
-  PtyHandle,
-} from "../types";
-import { _completeDeps, executeComplete } from "./complete";
-import { _runOnceDeps, buildAllowedEnv, buildCommand, executeOnce } from "./execution";
-import { runInteractiveMode } from "./interactive";
-import { runPlan } from "./plan";
-
-/**
- * Injectable dependencies for decompose() — allows tests to intercept
- * Bun.spawn calls and verify correct CLI args without the claude binary.
- *
- * @internal
- */
-export const _decomposeDeps = {
-  spawn(
-    cmd: string[],
-    opts: { cwd?: string; stdout: "pipe"; stderr: "inherit" | "pipe"; env?: Record<string, string | undefined> },
-  ): {
-    stdout: ReadableStream<Uint8Array>;
-    stderr?: ReadableStream<Uint8Array>;
-    exited: Promise<number>;
-    pid: number;
-    kill(signal?: NodeJS.Signals | number): void;
-  } {
-    return Bun.spawn(cmd, opts) as unknown as {
-      stdout: ReadableStream<Uint8Array>;
-      stderr?: ReadableStream<Uint8Array>;
-      exited: Promise<number>;
-      pid: number;
-      kill(signal?: NodeJS.Signals | number): void;
-    };
-  },
-};
-
-// Re-export deps for testing
-export { _runOnceDeps, _completeDeps };
-
-/**
- * Injectable dependencies for ClaudeCodeAdapter retry loop.
- * Exported so tests can replace sleep with a no-op spy.
- *
- * @internal
- */
-export const _claudeAdapterDeps = {
-  sleep: (ms: number): Promise<void> => Bun.sleep(ms),
-};
-
-/**
- * Claude Code agent adapter implementation.
- *
- * Implements the AgentAdapter interface for Claude Code CLI,
- * supporting model routing, rate limit retry, and cost tracking.
- */
-export class ClaudeCodeAdapter implements AgentAdapter {
-  readonly name = "claude";
-  readonly displayName = "Claude Code";
-  readonly binary = "claude";
-
-  readonly capabilities: AgentCapabilities = {
-    supportedTiers: ["fast", "balanced", "powerful"],
-    maxContextTokens: 200_000,
-    features: new Set(["tdd", "review", "refactor", "batch"]),
-  };
-
-  private pidRegistries: Map<string, PidRegistry> = new Map();
-
-  private getPidRegistry(workdir: string): PidRegistry {
-    if (!this.pidRegistries.has(workdir)) {
-      this.pidRegistries.set(workdir, new PidRegistry(workdir));
-    }
-    const registry = this.pidRegistries.get(workdir);
-    if (!registry) {
-      throw new Error(`PidRegistry not found for workdir: ${workdir}`);
-    }
-    return registry;
-  }
-
-  async isInstalled(): Promise<boolean> {
-    try {
-      const proc = Bun.spawn(["which", this.binary], { stdout: "pipe", stderr: "pipe" });
-      const code = await proc.exited;
-      return code === 0;
-    } catch (error) {
-      const logger = getLogger();
-      logger?.debug("agent", "Failed to check if agent is installed", { error });
-      return false;
-    }
-  }
-
-  buildCommand(options: AgentRunOptions): string[] {
-    return buildCommand(this.binary, options);
-  }
-
-  buildAllowedEnv(options: AgentRunOptions): Record<string, string | undefined> {
-    return buildAllowedEnv(options);
-  }
-
-  async run(options: AgentRunOptions): Promise<AgentResult> {
-    const maxRetries = 3;
-    let lastError: Error | null = null;
-
-    try {
-      for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        try {
-          const pidRegistry = this.getPidRegistry(options.workdir);
-          const result = await executeOnce(this.binary, options, pidRegistry);
-
-          if (result.rateLimited && attempt < maxRetries) {
-            const backoffMs = 2 ** attempt * 1000;
-            const logger = getLogger();
-            logger.warn("agent", "Rate limited, retrying", { backoffSeconds: backoffMs / 1000, attempt, maxRetries });
-            await _claudeAdapterDeps.sleep(backoffMs);
-            continue;
-          }
-
-          return result;
-        } catch (error) {
-          lastError = error as Error;
-          const isSpawnError = lastError.message.includes("spawn") || lastError.message.includes("ENOENT");
-
-          if (isSpawnError && attempt < maxRetries) {
-            const backoffMs = 2 ** attempt * 1000;
-            const logger = getLogger();
-            logger.warn("agent", "Agent spawn error, retrying", {
-              error: lastError.message,
-              backoffSeconds: backoffMs / 1000,
-              attempt,
-              maxRetries,
-            });
-            await _claudeAdapterDeps.sleep(backoffMs);
-            continue;
-          }
-
-          throw lastError;
-        }
-      }
-
-      throw lastError || new Error("Agent execution failed after all retries");
-    } finally {
-      // Clean up pidRegistry entry for this workdir to prevent unbounded Map growth
-      this.pidRegistries.delete(options.workdir);
-    }
-  }
-
-  async complete(prompt: string, options?: CompleteOptions): Promise<string> {
-    return executeComplete(this.binary, prompt, options);
-  }
-
-  async plan(options: PlanOptions): Promise<PlanResult> {
-    const pidRegistry = this.getPidRegistry(options.workdir);
-    return runPlan(this.binary, options, pidRegistry, this.buildAllowedEnv.bind(this));
-  }
-
-  async decompose(options: DecomposeOptions): Promise<DecomposeResult> {
-    const { resolveBalancedModelDef } = await import("../shared/model-resolution");
-
-    const prompt = buildDecomposePrompt(options);
-
-    let modelDef = options.modelDef;
-    if (!modelDef) {
-      if (!options.config) {
-        throw new Error("decompose() requires either modelDef or config with models.balanced configured");
-      }
-      modelDef = resolveBalancedModelDef(options.config);
-    }
-
-    const { skipPermissions } = resolvePermissions(
-      options.config as import("../../config").NaxConfig | undefined,
-      "run",
-    );
-    const cmd = [this.binary, "--model", modelDef.model, "-p", prompt];
-    if (skipPermissions) {
-      cmd.splice(cmd.length - 2, 0, "--dangerously-skip-permissions");
-    }
-
-    const pidRegistry = this.getPidRegistry(options.workdir);
-
-    const proc = _decomposeDeps.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "inherit",
-      env: this.buildAllowedEnv({
-        workdir: options.workdir,
-        modelDef,
-        prompt: "",
-        modelTier: options.modelTier || "balanced",
-        timeoutSeconds: 600,
-      }),
-    });
-
-    await pidRegistry.register(proc.pid);
-
-    const DECOMPOSE_TIMEOUT_MS = 300_000;
-    let timedOut = false;
-
-    let exitCode: number;
-    try {
-      const timeoutResult = await withProcessTimeout(proc, DECOMPOSE_TIMEOUT_MS, {
-        graceMs: 5000,
-        onTimeout: () => {
-          timedOut = true;
-        },
-      });
-      exitCode = timeoutResult.exitCode;
-    } finally {
-      await pidRegistry.unregister(proc.pid);
-    }
-
-    if (timedOut) {
-      throw new Error(`Decompose timed out after ${DECOMPOSE_TIMEOUT_MS / 1000}s`);
-    }
-
-    let stdoutTimeoutId: ReturnType<typeof setTimeout> | undefined;
-    const stdout = await Promise.race([
-      new Response(proc.stdout).text(),
-      new Promise<string>((resolve) => {
-        stdoutTimeoutId = setTimeout(() => resolve(""), 5000);
-      }),
-    ]);
-    clearTimeout(stdoutTimeoutId);
-    const stderr = await new Response(proc.stderr).text();
-
-    if (exitCode !== 0) {
-      throw new Error(`Decompose failed with exit code ${exitCode}: ${stderr}`);
-    }
-
-    const stories = parseDecomposeOutput(stdout);
-
-    return { stories };
-  }
-
-  runInteractive(options: InteractiveRunOptions): PtyHandle {
-    const pidRegistry = this.getPidRegistry(options.workdir);
-    return runInteractiveMode(this.binary, options, pidRegistry);
-  }
-}

package/src/agents/claude/complete.ts

@@ -1,80 +0,0 @@
-/**
- * Claude Code Agent - Completion API
- *
- * Standalone completion endpoint for simple prompts.
- */
-
-import { resolvePermissions } from "../../config/permissions";
-import type { CompleteOptions } from "../types";
-import { CompleteError } from "../types";
-
-/**
- * Injectable dependencies for complete() — allows tests to intercept
- * Bun.spawn calls and verify correct CLI args without the claude binary.
- *
- * @internal
- */
-export const _completeDeps = {
-  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;
-    };
-  },
-};
-
-/**
- * Execute a simple completion request without starting a full agent session.
- *
- * @param binary - Path to claude binary
- * @param prompt - Prompt text
- * @param options - Completion options (model, tokens, format)
- * @returns Completion text output
- * @throws CompleteError if execution fails
- */
-export async function executeComplete(binary: string, prompt: string, options?: CompleteOptions): Promise<string> {
-  const cmd = [binary, "-p", prompt];
-
-  if (options?.model) {
-    cmd.push("--model", options.model);
-  }
-
-  // Note: Claude Code CLI does not support --max-tokens; the option is accepted in
-  // CompleteOptions for future use or non-Claude adapters, but is intentionally not
-  // forwarded to the claude binary here.
-
-  if (options?.jsonMode) {
-    cmd.push("--output-format", "json");
-  }
-
-  const { skipPermissions } = resolvePermissions(options?.config, "complete");
-  if (skipPermissions) {
-    cmd.push("--dangerously-skip-permissions");
-  }
-
-  const spawnOpts: { stdout: "pipe"; stderr: "pipe"; cwd?: string } = { stdout: "pipe", stderr: "pipe" };
-  if (options?.workdir) spawnOpts.cwd = options.workdir;
-  const proc = _completeDeps.spawn(cmd, spawnOpts);
-  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;
-}

package/src/agents/claude/cost.ts

@@ -1,16 +0,0 @@
-/**
- * Cost Tracking — re-exports from the shared src/agents/cost/ module.
- *
- * Kept for zero-breakage backward compatibility.
- * Import directly from src/agents/cost for new code.
- */
-
-export type { ModelCostRates, TokenUsage, CostEstimate, TokenUsageWithConfidence } from "../cost";
-export {
-  COST_RATES,
-  parseTokenUsage,
-  estimateCost,
-  estimateCostFromOutput,
-  estimateCostByDuration,
-  formatCostWithConfidence,
-} from "../cost";

package/src/agents/claude/execution.ts

@@ -1,215 +0,0 @@
-/**
- * Claude Code Agent - Execution Layer
- *
- * Handles building commands, preparing environment, and process execution.
- */
-
-import { homedir } from "node:os";
-import { isAbsolute } from "node:path";
-import { resolvePermissions } from "../../config/permissions";
-import type { PidRegistry } from "../../execution/pid-registry";
-import { withProcessTimeout } from "../../execution/timeout-handler";
-import { getLogger } from "../../logger";
-import type { AgentResult, AgentRunOptions } from "../types";
-import { estimateCostByDuration, estimateCostFromOutput } from "./cost";
-
-/**
- * Maximum characters to capture from agent stdout.
- */
-const MAX_AGENT_OUTPUT_CHARS = 5000;
-
-/**
- * Maximum characters to capture from agent stderr.
- */
-const MAX_AGENT_STDERR_CHARS = 1000;
-
-/**
- * Grace period in ms between SIGTERM and SIGKILL on timeout.
- */
-const SIGKILL_GRACE_PERIOD_MS = 5000;
-
-/**
- * Injectable dependencies for runOnce() — allows tests to verify
- * that PID cleanup (unregister) always runs even if kill() throws.
- *
- * @internal
- */
-export const _runOnceDeps = {
-  killProc(proc: { kill(signal?: number | NodeJS.Signals): void }, signal: NodeJS.Signals): void {
-    proc.kill(signal);
-  },
-  buildCmd(binary: string, options: AgentRunOptions): string[] {
-    return buildCommand(binary, options);
-  },
-};
-
-/**
- * Build Claude Code command with model and permissions.
- *
- * @param binary - Path to claude binary
- * @param options - Agent run options
- * @returns Command array for Bun.spawn()
- */
-export function buildCommand(binary: string, options: AgentRunOptions): string[] {
-  const model = options.modelDef.model;
-  const { skipPermissions } = resolvePermissions(options.config, options.pipelineStage ?? "run");
-  const permArgs = skipPermissions ? ["--dangerously-skip-permissions"] : [];
-  return [binary, "--model", model, ...permArgs, "-p", options.prompt];
-}
-
-/**
- * Build allowed environment variables for spawned agents.
- * SEC-4: Only pass essential env vars to prevent leaking sensitive data.
- *
- * @param options - Agent run options
- * @returns Filtered environment variables
- */
-export function buildAllowedEnv(options: AgentRunOptions): Record<string, string | undefined> {
-  const allowed: Record<string, string | undefined> = {};
-
-  const essentialVars = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
-  for (const varName of essentialVars) {
-    if (process.env[varName]) {
-      allowed[varName] = process.env[varName];
-    }
-  }
-
-  // Sanitize HOME — must be absolute path. Unexpanded "~" causes literal ~/dir in cwd.
-  const rawHome = process.env.HOME ?? "";
-  const safeHome = rawHome && isAbsolute(rawHome) ? rawHome : homedir();
-  if (rawHome !== safeHome) {
-    const logger = getLogger();
-    logger.warn("env", `HOME env is not absolute ("${rawHome}"), falling back to os.homedir(): ${safeHome}`);
-  }
-  allowed.HOME = safeHome;
-
-  const apiKeyVars = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
-  for (const varName of apiKeyVars) {
-    if (process.env[varName]) {
-      allowed[varName] = process.env[varName];
-    }
-  }
-
-  const allowedPrefixes = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_"];
-  for (const [key, value] of Object.entries(process.env)) {
-    if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
-      allowed[key] = value;
-    }
-  }
-
-  if (options.modelDef.env) {
-    Object.assign(allowed, options.modelDef.env);
-  }
-
-  if (options.env) {
-    Object.assign(allowed, options.env);
-  }
-
-  return allowed;
-}
-
-/**
- * Execute agent process once with timeout and signal handling.
- *
- * @param binary - Path to claude binary
- * @param options - Agent run options
- * @param pidRegistry - PID registry for cleanup
- * @returns Agent execution result
- *
- * @internal
- */
-export async function executeOnce(
-  binary: string,
-  options: AgentRunOptions,
-  pidRegistry: PidRegistry,
-): Promise<AgentResult> {
-  const cmd = _runOnceDeps.buildCmd(binary, options);
-  const startTime = Date.now();
-
-  // Log session-related options for traceability. CLI adapter doesn't use sessions,
-  // but the pipeline passes these uniformly. Logged so future CLI session support
-  // can verify they're threaded correctly.
-  if (options.sessionRole || options.acpSessionName || options.keepSessionOpen) {
-    const logger = getLogger();
-    logger.debug("agent", "CLI mode: session options received (unused)", {
-      sessionRole: options.sessionRole,
-      acpSessionName: options.acpSessionName,
-      keepSessionOpen: options.keepSessionOpen,
-      featureName: options.featureName,
-      storyId: options.storyId,
-    });
-  }
-
-  const proc = Bun.spawn(cmd, {
-    cwd: options.workdir,
-    stdout: "pipe",
-    stderr: "inherit",
-    env: buildAllowedEnv(options),
-  });
-
-  const processPid = proc.pid;
-  await pidRegistry.register(processPid);
-
-  let timedOut = false;
-  let exitCode: number;
-  try {
-    const timeoutResult = await withProcessTimeout(proc, options.timeoutSeconds * 1000, {
-      graceMs: SIGKILL_GRACE_PERIOD_MS,
-      onTimeout: () => {
-        timedOut = true;
-      },
-      killFn: (p, signal) => _runOnceDeps.killProc(p, signal),
-    });
-    exitCode = timeoutResult.exitCode;
-    timedOut = timeoutResult.timedOut;
-  } finally {
-    await pidRegistry.unregister(processPid);
-  }
-
-  let stdoutTimeoutId: ReturnType<typeof setTimeout> | undefined;
-  const stdout = await Promise.race([
-    new Response(proc.stdout).text(),
-    new Promise<string>((resolve) => {
-      stdoutTimeoutId = setTimeout(() => resolve(""), 5000);
-    }),
-  ]);
-  clearTimeout(stdoutTimeoutId); // prevent leaked timer when stdout resolves first
-  const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
-  const durationMs = Date.now() - startTime;
-
-  const fullOutput = stdout + stderr;
-  const rateLimited =
-    fullOutput.toLowerCase().includes("rate limit") ||
-    fullOutput.includes("429") ||
-    fullOutput.toLowerCase().includes("too many requests");
-
-  let costEstimate = estimateCostFromOutput(options.modelTier, fullOutput);
-  const logger = getLogger();
-  if (!costEstimate) {
-    const fallbackEstimate = estimateCostByDuration(options.modelTier, durationMs);
-    costEstimate = {
-      cost: fallbackEstimate.cost * 1.5,
-      confidence: "fallback",
-    };
-    logger.warn("agent", "Cost estimation fallback (duration-based)", {
-      modelTier: options.modelTier,
-      cost: costEstimate.cost,
-    });
-  } else if (costEstimate.confidence === "estimated") {
-    logger.warn("agent", "Cost estimation using regex parsing (estimated confidence)", { cost: costEstimate.cost });
-  }
-  const cost = costEstimate.cost;
-
-  const actualExitCode = timedOut ? 124 : exitCode;
-
-  return {
-    success: exitCode === 0 && !timedOut,
-    exitCode: actualExitCode,
-    output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
-    stderr: stderr.slice(-MAX_AGENT_STDERR_CHARS),
-    rateLimited,
-    durationMs,
-    estimatedCost: cost,
-    pid: processPid,
-  };
-}