@nathapp/nax 0.45.0 → 0.46.1

package/src/precheck/checks-agents.ts

@@ -5,7 +5,7 @@
  * and checks health status for each configured agent.
  */
 
-import { getAgentVersions } from "../agents/version-detection";
+import { getAgentVersions } from "../agents/shared/version-detection";
 import type { Check } from "./types";
 
 /**

package/src/precheck/checks-git.ts

@@ -32,6 +32,25 @@ export async function checkGitRepoExists(workdir: string): Promise<Check> {
   };
 }
 
+/**
+ * nax runtime files that are allowed to be dirty without blocking the precheck.
+ * These are written during nax execution and should be gitignored by `nax init`.
+ */
+const NAX_RUNTIME_PATTERNS = [
+  /^.{2} nax\.lock$/,
+  /^.{2} nax\/metrics\.json$/,
+  /^.{2} nax\/features\/[^/]+\/status\.json$/,
+  /^.{2} nax\/features\/[^/]+\/runs\//,
+  /^.{2} nax\/features\/[^/]+\/plan\//,
+  /^.{2} nax\/features\/[^/]+\/acp-sessions\.json$/,
+  /^.{2} nax\/features\/[^/]+\/interactions\//,
+  /^.{2} nax\/features\/[^/]+\/progress\.txt$/,
+  /^.{2} nax\/features\/[^/]+\/acceptance-refined\.json$/,
+  /^.{2} \.nax-verifier-verdict\.json$/,
+  /^.{2} \.nax-pids$/,
+  /^.{2} \.nax-wt\//,
+];
+
 /** Check if working tree is clean. Uses: git status --porcelain */
 export async function checkWorkingTreeClean(workdir: string): Promise<Check> {
   const proc = Bun.spawn(["git", "status", "--porcelain"], {
@@ -42,13 +61,20 @@ export async function checkWorkingTreeClean(workdir: string): Promise<Check> {
 
   const output = await new Response(proc.stdout).text();
   const exitCode = await proc.exited;
-  const passed = exitCode === 0 && output.trim() === "";
+
+  // Split without trimming the full output — porcelain lines start with status chars
+  // including leading spaces (e.g. " M file.ts"). trim() would corrupt the first line.
+  const lines = output.trim() === "" ? [] : output.split("\n").filter(Boolean);
+  const nonNaxDirtyFiles = lines.filter((line) => !NAX_RUNTIME_PATTERNS.some((pattern) => pattern.test(line)));
+  const passed = exitCode === 0 && nonNaxDirtyFiles.length === 0;
 
   return {
     name: "working-tree-clean",
     tier: "blocker",
     passed,
-    message: passed ? "Working tree is clean" : "Uncommitted changes detected",
+    message: passed
+      ? "Working tree is clean"
+      : `Uncommitted changes detected: ${nonNaxDirtyFiles.map((l) => l.slice(3)).join(", ")}`,
   };
 }
 

package/src/precheck/checks-warnings.ts

@@ -6,6 +6,7 @@
  */
 
 import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
 import type { NaxConfig } from "../config";
 import type { PRD } from "../prd/types";
 import type { Check } from "./types";
@@ -126,7 +127,7 @@ async function hasPackageScript(workdir: string, name: string): Promise<boolean>
 
 /**
  * Check if .gitignore covers nax runtime files.
- * Patterns: nax.lock, runs/, test/tmp/
+ * Patterns: nax.lock, runs/, status.json, .nax-pids, .nax-wt/
  */
 export async function checkGitignoreCoversNax(workdir: string): Promise<Check> {
   const gitignorePath = `${workdir}/.gitignore`;
@@ -143,7 +144,14 @@ export async function checkGitignoreCoversNax(workdir: string): Promise<Check> {
 
   const file = Bun.file(gitignorePath);
   const content = await file.text();
-  const patterns = ["nax.lock", "runs/", "test/tmp/"];
+  const patterns = [
+    "nax.lock",
+    "nax/**/runs/",
+    "nax/metrics.json",
+    "nax/features/*/status.json",
+    ".nax-pids",
+    ".nax-wt/",
+  ];
   const missing = patterns.filter((pattern) => !content.includes(pattern));
   const passed = missing.length === 0;
 
@@ -191,3 +199,23 @@ export async function checkPromptOverrideFiles(config: NaxConfig, workdir: strin
 
   return checks;
 }
+
+/**
+ * Check if HOME env is set and is an absolute path.
+ * An unexpanded "~" in HOME causes agent spawns to create a literal ~/
+ * directory inside the repo cwd instead of resolving to the user home dir.
+ */
+export async function checkHomeEnvValid(): Promise<Check> {
+  const home = process.env.HOME ?? "";
+  const passed = home !== "" && isAbsolute(home);
+  return {
+    name: "home-env-valid",
+    tier: "warning",
+    passed,
+    message: passed
+      ? `HOME env is valid: ${home}`
+      : home === ""
+        ? "HOME env is not set — agent may write files to unexpected locations"
+        : `HOME env is not an absolute path ("${home}") — may cause literal "~" directories in repo`,
+  };
+}

package/src/precheck/checks.ts

@@ -28,6 +28,7 @@ export {
   checkPendingStories,
   checkOptionalCommands,
   checkGitignoreCoversNax,
+  checkHomeEnvValid,
   checkPromptOverrideFiles,
 } from "./checks-warnings";
 

package/src/precheck/index.ts

@@ -20,6 +20,7 @@ import {
   checkGitRepoExists,
   checkGitUserConfigured,
   checkGitignoreCoversNax,
+  checkHomeEnvValid,
   checkLintCommand,
   checkMultiAgentHealth,
   checkOptionalCommands,
@@ -126,6 +127,7 @@ function getEnvironmentWarnings(config: NaxConfig, workdir: string): CheckFn[] {
     () => checkDiskSpace(),
     () => checkOptionalCommands(config, workdir),
     () => checkGitignoreCoversNax(workdir),
+    () => checkHomeEnvValid(),
     () => checkPromptOverrideFiles(config, workdir),
     () => checkMultiAgentHealth(),
   ];

package/src/utils/log-test-output.ts

@@ -0,0 +1,25 @@
+import type { Logger } from "../logger";
+
+/**
+ * Log test output consistently across all pipeline stages.
+ *
+ * Summary (exitCode, storyId) is logged at the caller's level (error/warn).
+ * Raw output is logged at debug level only — last `tailLines` lines.
+ *
+ * `storyId` is optional: works for per-story verify/acceptance AND for
+ * deferred runs (deferred acceptance, deferred regression) with no story context.
+ */
+export function logTestOutput(
+  logger: Logger | null | undefined,
+  stage: string,
+  output: string | undefined,
+  opts: { storyId?: string; tailLines?: number } = {},
+): void {
+  if (!logger || !output) return;
+  const tailLines = opts.tailLines ?? 20;
+  const lines = output.split("\n").slice(-tailLines).join("\n");
+  logger.debug(stage, "Test output (tail)", {
+    ...(opts.storyId !== undefined && { storyId: opts.storyId }),
+    output: lines,
+  });
+}

package/src/agents/cost.ts

@@ -1,268 +0,0 @@
-/**
- * Cost Tracking
- *
- * Token-based cost estimation for AI coding agents.
- * Parses agent output for token usage and calculates costs.
- */
-
-import type { ModelTier } from "../config/schema";
-
-/** Cost rates per 1M tokens (USD) */
-export interface ModelCostRates {
-  inputPer1M: number;
-  outputPer1M: number;
-}
-
-/** Token usage data */
-export interface TokenUsage {
-  inputTokens: number;
-  outputTokens: number;
-}
-
-/** Cost estimate with confidence indicator */
-export interface CostEstimate {
-  cost: number;
-  confidence: "exact" | "estimated" | "fallback";
-}
-
-/** Model tier cost rates (as of 2025-01) */
-export const COST_RATES: Record<ModelTier, ModelCostRates> = {
-  fast: {
-    // Haiku 4.5
-    inputPer1M: 0.8,
-    outputPer1M: 4.0,
-  },
-  balanced: {
-    // Sonnet 4.5
-    inputPer1M: 3.0,
-    outputPer1M: 15.0,
-  },
-  powerful: {
-    // Opus 4
-    inputPer1M: 15.0,
-    outputPer1M: 75.0,
-  },
-};
-
-/**
- * Token usage with confidence indicator.
- */
-export interface TokenUsageWithConfidence {
-  inputTokens: number;
-  outputTokens: number;
-  confidence: "exact" | "estimated";
-}
-
-/**
- * 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;
-}
-
-/**
- * Estimate cost in USD based on token usage.
- *
- * Calculates total cost using tier-specific rates per 1M tokens.
- *
- * @param modelTier - Model tier (fast/balanced/powerful)
- * @param inputTokens - Number of input tokens consumed
- * @param outputTokens - Number of output tokens generated
- * @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 (caller should use fallback estimation).
- *
- * @param modelTier - Model tier for cost calculation
- * @param output - Agent stdout + stderr combined
- * @returns Cost estimate with confidence indicator, or null if unparseable
- *
- * @example
- * ```ts
- * const estimate = estimateCostFromOutput("balanced", agentOutput);
- * if (estimate) {
- *   console.log(`Cost: $${estimate.cost.toFixed(4)} (${estimate.confidence})`);
- * } else {
- *   // Fall back to duration-based estimation
- * }
- * ```
- */
-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)`;
-  }
-}