@nathapp/nax 0.50.2 → 0.51.0

package/src/agents/claude/index.ts

@@ -1,3 +0,0 @@
-// Re-export everything external callers need from claude/
-export { ClaudeCodeAdapter, _completeDeps, _claudeAdapterDeps } from "./adapter";
-export { _runOnceDeps } from "./execution";

package/src/agents/claude/interactive.ts

@@ -1,77 +0,0 @@
-/**
- * Claude Code Agent - Interactive (TUI) Mode
- *
- * Handles terminal UI interactions with the Claude agent.
- */
-
-import type { PidRegistry } from "../../execution/pid-registry";
-import { getLogger } from "../../logger";
-import type { AgentRunOptions, InteractiveRunOptions, PtyHandle } from "../types";
-import { buildAllowedEnv } from "./execution";
-
-/**
- * Run Claude agent in interactive (TTY) mode for TUI output.
- *
- * @param binary - Path to claude binary
- * @param options - Interactive run options
- * @param pidRegistry - PID registry for cleanup
- * @returns PTY handle for stdin/stdout/kill control
- */
-export function runInteractiveMode(
-  binary: string,
-  options: InteractiveRunOptions,
-  pidRegistry: PidRegistry,
-): PtyHandle {
-  const model = options.modelDef.model;
-  const cmd = [binary, "--model", model, options.prompt];
-
-  // BUN-001: Replaced node-pty with Bun.spawn (piped stdio).
-  // runInteractive() is TUI-only and currently dormant in headless nax runs.
-  // TERM + FORCE_COLOR preserve formatting output from Claude Code.
-  const allowedEnv = buildAllowedEnv(options as unknown as AgentRunOptions);
-  const proc = Bun.spawn(cmd, {
-    cwd: options.workdir,
-    env: { ...allowedEnv, TERM: "xterm-256color", FORCE_COLOR: "1" },
-    stdin: "pipe",
-    stdout: "pipe",
-    stderr: "inherit",
-  });
-
-  pidRegistry.register(proc.pid).catch(() => {});
-
-  // Stream stdout to onOutput callback
-  (async () => {
-    try {
-      for await (const chunk of proc.stdout) {
-        options.onOutput(Buffer.from(chunk));
-      }
-    } catch (err) {
-      // BUG-21: Handle stream errors to avoid unhandled rejections
-      getLogger()?.error("agent", "runInteractive stdout error", { err });
-    }
-  })();
-
-  // Fire onExit when process completes
-  proc.exited
-    .then((code) => {
-      pidRegistry.unregister(proc.pid).catch(() => {});
-      options.onExit(code ?? 1);
-    })
-    .catch((err) => {
-      // BUG-22: Guard against onExit or unregister throws
-      getLogger()?.error("agent", "runInteractive exit error", { err });
-    });
-
-  return {
-    write: (data: string) => {
-      proc.stdin.write(data);
-    },
-    resize: (_cols: number, _rows: number) => {
-      /* no-op: Bun.spawn has no PTY resize */
-    },
-    kill: () => {
-      proc.kill();
-    },
-    pid: proc.pid,
-  };
-}

package/src/agents/claude/plan.ts

@@ -1,179 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-/**
- * Claude Code Plan Logic
- *
- * Extracted from claude.ts: plan(), buildPlanCommand()
- */
-
-import { resolvePermissions } from "../../config/permissions";
-import type { PidRegistry } from "../../execution/pid-registry";
-import { withProcessTimeout } from "../../execution/timeout-handler";
-import { getLogger } from "../../logger";
-import { resolveBalancedModelDef } from "../shared/model-resolution";
-import type { PlanOptions, PlanResult } from "../shared/types-extended";
-import type { AgentRunOptions } from "../types";
-
-/**
- * Build the CLI command for plan mode.
- */
-export function buildPlanCommand(binary: string, options: PlanOptions): string[] {
-  const cmd = [binary, "--permission-mode", "plan"];
-
-  // 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);
-  }
-
-  // Resolve permission mode from config
-  const { skipPermissions } = resolvePermissions(
-    options.config as import("../../config").NaxConfig | undefined,
-    "plan",
-  );
-  if (skipPermissions) {
-    cmd.push("--dangerously-skip-permissions");
-  }
-
-  // Add prompt with codebase context and input file if available
-  let fullPrompt = options.prompt;
-  if (options.codebaseContext) {
-    fullPrompt = `${options.codebaseContext}\n\n${options.prompt}`;
-  }
-
-  // For non-interactive mode, include input file content in the prompt
-  if (options.inputFile) {
-    try {
-      const inputContent = require("node:fs").readFileSync(
-        require("node:path").resolve(options.workdir, options.inputFile),
-        "utf-8",
-      );
-      fullPrompt = `${fullPrompt}\n\n## Input Requirements\n\n${inputContent}`;
-    } catch (error) {
-      throw new Error(`Failed to read input file ${options.inputFile}: ${(error as Error).message}`);
-    }
-  }
-
-  if (!options.interactive) {
-    cmd.push("-p", fullPrompt);
-  } else {
-    // Interactive mode: pass prompt as initial message, agent will ask follow-ups
-    cmd.push("-p", fullPrompt);
-  }
-
-  return cmd;
-}
-
-/**
- * Run Claude Code in plan mode to generate a feature specification.
- */
-export async function runPlan(
-  binary: string,
-  options: PlanOptions,
-  pidRegistry: PidRegistry,
-  buildAllowedEnv: (options: AgentRunOptions) => Record<string, string | undefined>,
-): Promise<PlanResult> {
-  const { resolveBalancedModelDef } = await import("../shared/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,
-    prompt: "",
-    modelTier: options.modelTier || "balanced",
-    timeoutSeconds: 600,
-  };
-
-  const PLAN_TIMEOUT_MS = 600_000; // 10 minutes
-
-  if (options.interactive) {
-    // Interactive mode: inherit stdio
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      env: buildAllowedEnv(envOptions),
-    });
-
-    // Register PID
-    await pidRegistry.register(proc.pid);
-
-    let exitCode: number;
-    try {
-      const timeoutResult = await withProcessTimeout(proc, PLAN_TIMEOUT_MS, {
-        graceMs: 5000,
-      });
-      exitCode = timeoutResult.exitCode;
-    } finally {
-      // Unregister PID after exit
-      await pidRegistry.unregister(proc.pid);
-    }
-
-    if (exitCode !== 0) {
-      throw new Error(`Plan mode failed with exit code ${exitCode}`);
-    }
-    return { specContent: "", conversationLog: "" };
-  }
-
-  // Non-interactive: redirect stdout to temp file via Bun.file()
-
-  const tempDir = mkdtempSync(join(tmpdir(), "nax-plan-"));
-  const outFile = join(tempDir, "stdout.txt");
-  const errFile = join(tempDir, "stderr.txt");
-
-  try {
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdin: "ignore",
-      stdout: Bun.file(outFile),
-      stderr: Bun.file(errFile),
-      env: buildAllowedEnv(envOptions),
-    });
-
-    // Register PID
-    await pidRegistry.register(proc.pid);
-
-    let exitCode: number;
-    try {
-      const timeoutResult = await withProcessTimeout(proc, PLAN_TIMEOUT_MS, {
-        graceMs: 5000,
-      });
-      exitCode = timeoutResult.exitCode;
-    } finally {
-      // Unregister PID after exit
-      await pidRegistry.unregister(proc.pid);
-    }
-
-    const specContent = await Bun.file(outFile).text();
-    const conversationLog = await Bun.file(errFile).text();
-
-    if (exitCode !== 0) {
-      throw new Error(`Plan mode failed with exit code ${exitCode}: ${conversationLog || "unknown error"}`);
-    }
-
-    return { specContent, conversationLog };
-  } finally {
-    try {
-      rmSync(tempDir, { recursive: true });
-    } catch (error) {
-      const logger = getLogger();
-      logger?.debug("agent", "Failed to clean up temp directory", { error, tempDir });
-    }
-  }
-}

package/src/agents/codex/adapter.ts

@@ -1,153 +0,0 @@
-/**
- * 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/cost/calculate.ts

@@ -1,154 +0,0 @@
-/**
- * Cost calculation functions for all agent adapters.
- */
-
-import type { ModelTier } from "../../config/schema";
-import { parseTokenUsage } from "./parse";
-import { COST_RATES, MODEL_PRICING } from "./pricing";
-import type { CostEstimate, ModelCostRates, SessionTokenUsage } from "./types";
-
-/**
- * Estimate cost in USD based on token usage and model tier.
- *
- * @param modelTier - Model tier (fast/balanced/powerful)
- * @param inputTokens - Number of input tokens consumed
- * @param outputTokens - Number of output tokens generated
- * @param customRates - Optional custom rates (overrides tier defaults)
- * @returns Total cost in USD
- *
- * @example
- * ```ts
- * const cost = estimateCost("balanced", 10000, 5000);
- * // Sonnet 4.5: (10000/1M * $3.00) + (5000/1M * $15.00) = $0.105
- * ```
- */
-export function estimateCost(
-  modelTier: ModelTier,
-  inputTokens: number,
-  outputTokens: number,
-  customRates?: ModelCostRates,
-): number {
-  const rates = customRates ?? COST_RATES[modelTier];
-  const inputCost = (inputTokens / 1_000_000) * rates.inputPer1M;
-  const outputCost = (outputTokens / 1_000_000) * rates.outputPer1M;
-  return inputCost + outputCost;
-}
-
-/**
- * Estimate cost from agent output by parsing token usage.
- *
- * Attempts to extract token counts from stdout/stderr, then calculates cost.
- * Returns null if tokens cannot be parsed.
- *
- * @param modelTier - Model tier for cost calculation
- * @param output - Agent stdout + stderr combined
- * @returns Cost estimate with confidence indicator, or null if unparseable
- */
-export function estimateCostFromOutput(modelTier: ModelTier, output: string): CostEstimate | null {
-  const usage = parseTokenUsage(output);
-  if (!usage) {
-    return null;
-  }
-  const cost = estimateCost(modelTier, usage.inputTokens, usage.outputTokens);
-  return {
-    cost,
-    confidence: usage.confidence,
-  };
-}
-
-/**
- * Fallback cost estimation based on runtime duration.
- *
- * Used when token usage cannot be parsed from agent output.
- * Provides conservative estimates using per-minute rates.
- *
- * @param modelTier - Model tier for cost calculation
- * @param durationMs - Agent runtime in milliseconds
- * @returns Cost estimate with 'fallback' confidence
- *
- * @example
- * ```ts
- * const estimate = estimateCostByDuration("balanced", 120000); // 2 minutes
- * // { cost: 0.10, confidence: 'fallback' }
- * // Sonnet: 2 min * $0.05/min = $0.10
- * ```
- */
-export function estimateCostByDuration(modelTier: ModelTier, durationMs: number): CostEstimate {
-  const costPerMinute: Record<ModelTier, number> = {
-    fast: 0.01,
-    balanced: 0.05,
-    powerful: 0.15,
-  };
-  const minutes = durationMs / 60000;
-  const cost = minutes * costPerMinute[modelTier];
-  return {
-    cost,
-    confidence: "fallback",
-  };
-}
-
-/**
- * Format cost estimate with confidence indicator for display.
- *
- * @param estimate - Cost estimate with confidence level
- * @returns Formatted cost string with confidence indicator
- *
- * @example
- * ```ts
- * formatCostWithConfidence({ cost: 0.12, confidence: 'exact' });
- * // "$0.12"
- *
- * formatCostWithConfidence({ cost: 0.15, confidence: 'estimated' });
- * // "~$0.15"
- *
- * formatCostWithConfidence({ cost: 0.05, confidence: 'fallback' });
- * // "~$0.05 (duration-based)"
- * ```
- */
-export function formatCostWithConfidence(estimate: CostEstimate): string {
-  const formattedCost = `$${estimate.cost.toFixed(2)}`;
-
-  switch (estimate.confidence) {
-    case "exact":
-      return formattedCost;
-    case "estimated":
-      return `~${formattedCost}`;
-    case "fallback":
-      return `~${formattedCost} (duration-based)`;
-  }
-}
-
-/**
- * Calculate USD cost from ACP session token counts using per-model pricing.
- *
- * @param usage - Token counts from cumulative_token_usage
- * @param model - Model identifier (e.g., 'claude-sonnet-4', 'claude-haiku-4-5')
- * @returns Estimated cost in USD
- */
-export function estimateCostFromTokenUsage(usage: SessionTokenUsage, model: string): number {
-  const pricing = MODEL_PRICING[model];
-
-  if (!pricing) {
-    // Fallback: use average rate for unknown models
-    const fallbackInputRate = 3 / 1_000_000;
-    const fallbackOutputRate = 15 / 1_000_000;
-    const inputCost = (usage.input_tokens ?? 0) * fallbackInputRate;
-    const outputCost = (usage.output_tokens ?? 0) * fallbackOutputRate;
-    const cacheReadCost = (usage.cache_read_input_tokens ?? 0) * (0.5 / 1_000_000);
-    const cacheCreationCost = (usage.cache_creation_input_tokens ?? 0) * (2 / 1_000_000);
-    return inputCost + outputCost + cacheReadCost + cacheCreationCost;
-  }
-
-  // Convert $/1M rates to $/token
-  const inputRate = pricing.input / 1_000_000;
-  const outputRate = pricing.output / 1_000_000;
-  const cacheReadRate = (pricing.cacheRead ?? pricing.input * 0.1) / 1_000_000;
-  const cacheCreationRate = (pricing.cacheCreation ?? pricing.input * 0.33) / 1_000_000;
-
-  const inputCost = (usage.input_tokens ?? 0) * inputRate;
-  const outputCost = (usage.output_tokens ?? 0) * outputRate;
-  const cacheReadCost = (usage.cache_read_input_tokens ?? 0) * cacheReadRate;
-  const cacheCreationCost = (usage.cache_creation_input_tokens ?? 0) * cacheCreationRate;
-
-  return inputCost + outputCost + cacheReadCost + cacheCreationCost;
-}

package/src/agents/cost/index.ts

@@ -1,10 +0,0 @@
-export type { ModelCostRates, TokenUsage, CostEstimate, TokenUsageWithConfidence, SessionTokenUsage } from "./types";
-export { COST_RATES, MODEL_PRICING } from "./pricing";
-export { parseTokenUsage } from "./parse";
-export {
-  estimateCost,
-  estimateCostFromOutput,
-  estimateCostByDuration,
-  formatCostWithConfidence,
-  estimateCostFromTokenUsage,
-} from "./calculate";

package/src/agents/cost/parse.ts

@@ -1,97 +0,0 @@
-/**
- * Token usage parsing from raw agent output strings.
- */
-
-import type { TokenUsageWithConfidence } from "./types";
-
-/**
- * Parse Claude Code output for token usage.
- *
- * Supports multiple formats with varying confidence levels:
- * - JSON structured output → "exact" confidence
- * - Markdown/plain text patterns → "estimated" confidence
- *
- * Uses specific regex patterns to reduce false positives.
- *
- * @param output - Agent stdout + stderr combined
- * @returns Token usage with confidence indicator, or null if tokens cannot be parsed
- *
- * @example
- * ```ts
- * // JSON format (exact)
- * const usage1 = parseTokenUsage('{"usage": {"input_tokens": 1234, "output_tokens": 5678}}');
- * // { inputTokens: 1234, outputTokens: 5678, confidence: 'exact' }
- *
- * // Markdown format (estimated)
- * const usage2 = parseTokenUsage('Input tokens: 1234\nOutput tokens: 5678');
- * // { inputTokens: 1234, outputTokens: 5678, confidence: 'estimated' }
- *
- * // Unparseable
- * const usage3 = parseTokenUsage('No token data here');
- * // null
- * ```
- */
-export function parseTokenUsage(output: string): TokenUsageWithConfidence | null {
-  // Try JSON format first (most reliable) - confidence: exact
-  try {
-    const jsonMatch = output.match(
-      /\{[^}]*"usage"\s*:\s*\{[^}]*"input_tokens"\s*:\s*(\d+)[^}]*"output_tokens"\s*:\s*(\d+)[^}]*\}[^}]*\}/,
-    );
-    if (jsonMatch) {
-      return {
-        inputTokens: Number.parseInt(jsonMatch[1], 10),
-        outputTokens: Number.parseInt(jsonMatch[2], 10),
-        confidence: "exact",
-      };
-    }
-
-    // Try parsing as full JSON object
-    const lines = output.split("\n");
-    for (const line of lines) {
-      if (line.trim().startsWith("{")) {
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed.usage?.input_tokens && parsed.usage?.output_tokens) {
-            return {
-              inputTokens: parsed.usage.input_tokens,
-              outputTokens: parsed.usage.output_tokens,
-              confidence: "exact",
-            };
-          }
-        } catch {
-          // Not valid JSON, continue
-        }
-      }
-    }
-  } catch {
-    // JSON parsing failed, try regex patterns
-  }
-
-  // Try specific markdown-style patterns (more specific to reduce false positives)
-  // Match "Input tokens: 1234" or "input_tokens: 1234" or "INPUT TOKENS: 1234"
-  // Use word boundary at start, require colon or space after keyword, then digits
-  // confidence: estimated (regex-based)
-  const inputMatch = output.match(/\b(?:input|input_tokens)\s*:\s*(\d{2,})|(?:input)\s+(?:tokens?)\s*:\s*(\d{2,})/i);
-  const outputMatch = output.match(
-    /\b(?:output|output_tokens)\s*:\s*(\d{2,})|(?:output)\s+(?:tokens?)\s*:\s*(\d{2,})/i,
-  );
-
-  if (inputMatch && outputMatch) {
-    // Extract token counts (may be in capture group 1 or 2)
-    const inputTokens = Number.parseInt(inputMatch[1] || inputMatch[2], 10);
-    const outputTokens = Number.parseInt(outputMatch[1] || outputMatch[2], 10);
-
-    // Sanity check: reject if tokens seem unreasonably large (> 1M each)
-    if (inputTokens > 1_000_000 || outputTokens > 1_000_000) {
-      return null;
-    }
-
-    return {
-      inputTokens,
-      outputTokens,
-      confidence: "estimated",
-    };
-  }
-
-  return null;
-}