@nathapp/nax 0.50.3 → 0.51.0

package/src/verification/executor.ts

@@ -1,250 +0,0 @@
-/**
- * Test Execution Core
- *
- * Unified test execution logic with timeout handling and process cleanup.
- * Extracted from execution/verification.ts to eliminate duplication.
- */
-
-import type { Subprocess } from "bun";
-import { errorMessage } from "../utils/errors";
-import type { TestExecutionResult } from "./types";
-
-/** Injectable deps for testability — mock _executorDeps.spawn instead of global Bun.spawn */
-export const _executorDeps = { spawn: Bun.spawn as typeof Bun.spawn };
-
-/**
- * Drain stdout+stderr from a killed Bun subprocess with a hard deadline.
- *
- * Bun doesn't close piped streams when a child process is killed (unlike Node).
- * `await new Response(proc.stdout).text()` hangs forever. This races the read
- * against a timeout so we get whatever output was buffered without blocking.
- */
-async function drainWithDeadline(proc: Subprocess, deadlineMs: number): Promise<string> {
-  const EMPTY = Symbol("timeout");
-  const race = <T>(p: Promise<T>) => {
-    // BUG-039: Store timer handle so it can be cleared after race resolves (prevent leak)
-    let timerId: ReturnType<typeof setTimeout>;
-    const timeoutPromise = new Promise<typeof EMPTY>((r) => {
-      timerId = setTimeout(() => r(EMPTY), deadlineMs);
-    });
-    return Promise.race([p, timeoutPromise]).finally(() => clearTimeout(timerId));
-  };
-
-  let out = "";
-  try {
-    const stdout = race(new Response(proc.stdout as ReadableStream).text());
-    const stderr = race(new Response(proc.stderr as ReadableStream).text());
-    const [o, e] = await Promise.all([stdout, stderr]);
-    if (o !== EMPTY) out += o;
-    if (e !== EMPTY) out += (out ? "\n" : "") + e;
-  } catch (error) {
-    // Expected: streams destroyed after kill (e.g. TypeError from closed ReadableStream)
-    const isExpectedStreamError =
-      error instanceof TypeError ||
-      (error instanceof Error && /abort|cancel|close|destroy|locked/i.test(error.message));
-    if (!isExpectedStreamError) {
-      const { getSafeLogger } = await import("../logger");
-      getSafeLogger()?.debug("executor", "Unexpected error draining process output", {
-        error: errorMessage(error),
-      });
-    }
-  }
-  return out;
-}
-
-/**
- * Normalize environment variables for verification subprocess.
- *
- * Force standard output mode during orchestrator-controlled test runs by
- * unsetting AI-optimized env vars (CLAUDECODE, REPL_ID, AGENT).
- */
-const DEFAULT_STRIP_ENV_VARS = ["CLAUDECODE", "REPL_ID", "AGENT"];
-
-export function normalizeEnvironment(
-  env: Record<string, string | undefined>,
-  stripVars?: string[],
-): Record<string, string | undefined> {
-  const normalized = { ...env };
-  const varsToStrip = stripVars ?? DEFAULT_STRIP_ENV_VARS;
-
-  for (const varName of varsToStrip) {
-    delete normalized[varName];
-  }
-
-  return normalized;
-}
-
-/**
- * Execute test command with hard timeout and process cleanup.
- *
- * Prevents zombie processes by sending SIGTERM, waiting for grace period,
- * then SIGKILL to entire process group.
- */
-export async function executeWithTimeout(
-  command: string,
-  timeoutSeconds: number,
-  env?: Record<string, string | undefined>,
-  options?: {
-    shell?: string;
-    gracePeriodMs?: number;
-    drainTimeoutMs?: number;
-    cwd?: string;
-  },
-): Promise<TestExecutionResult> {
-  const shell = options?.shell ?? "/bin/sh";
-  const gracePeriodMs = options?.gracePeriodMs ?? 5000;
-  const drainTimeoutMs = options?.drainTimeoutMs ?? 2000;
-
-  const proc = _executorDeps.spawn([shell, "-c", command], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: env || normalizeEnvironment(process.env as Record<string, string | undefined>),
-    cwd: options?.cwd,
-  });
-
-  const timeoutMs = timeoutSeconds * 1000;
-
-  let timedOut = false;
-  const timer = { id: undefined as ReturnType<typeof setTimeout> | undefined };
-
-  const timeoutPromise = new Promise<void>((resolve) => {
-    timer.id = setTimeout(() => {
-      timedOut = true;
-      resolve();
-    }, timeoutMs);
-  });
-
-  const processPromise = proc.exited;
-
-  const raceResult = await Promise.race([processPromise, timeoutPromise]);
-  clearTimeout(timer.id);
-
-  if (timedOut) {
-    const pid = proc.pid;
-
-    // Send SIGTERM to process group (negative PID) to kill children too
-    try {
-      process.kill(-pid, "SIGTERM");
-    } catch (error) {
-      // Fallback: kill direct process if process group kill fails
-      try {
-        proc.kill("SIGTERM");
-      } catch (fallbackError) {
-        // Process may have already exited
-      }
-    }
-
-    // Wait for graceful shutdown
-    await Bun.sleep(gracePeriodMs);
-
-    // Force SIGKILL entire process group if still running
-    try {
-      process.kill(-pid, "SIGKILL");
-    } catch (error) {
-      try {
-        proc.kill("SIGKILL");
-      } catch (fallbackError) {
-        // Process may have already exited
-      }
-    }
-
-    // Bun bug workaround: piped streams don't close after kill
-    const partialOutput = await drainWithDeadline(proc, drainTimeoutMs);
-
-    return {
-      success: false,
-      timeout: true,
-      killed: true,
-      childProcessesKilled: true,
-      output: partialOutput || undefined,
-      error: `EXECUTION_TIMEOUT: Verification process exceeded ${timeoutSeconds}s. Process group (PID ${pid}) killed.`,
-      countsTowardEscalation: false, // Timeout is environmental, not code failure
-    };
-  }
-
-  const exitCode = raceResult as number;
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const output = `${stdout}\n${stderr}`;
-
-  return {
-    success: exitCode === 0,
-    timeout: false,
-    exitCode,
-    output,
-    countsTowardEscalation: true,
-  };
-}
-
-/**
- * Check if a test command already includes --detectOpenHandles.
- */
-function detectOpenHandlesFlag(command: string): boolean {
-  return command.includes("--detectOpenHandles");
-}
-
-/**
- * Append --detectOpenHandles to a test command for diagnostic retry.
- */
-export function appendOpenHandlesFlag(command: string): string {
-  if (detectOpenHandlesFlag(command)) return command;
-  return appendFlag(command, "--detectOpenHandles");
-}
-
-/**
- * Check if a test command already includes --forceExit.
- */
-function forceExitFlag(command: string): boolean {
-  return command.includes("--forceExit");
-}
-
-/**
- * Append --forceExit to a test command to force process exit after tests.
- */
-export function appendForceExitFlag(command: string): string {
-  if (forceExitFlag(command)) return command;
-  return appendFlag(command, "--forceExit");
-}
-
-/**
- * Append a flag to a command, inserting before any pipe/redirect.
- */
-function appendFlag(command: string, flag: string): string {
-  const pipeIndex = command.search(/[|>]/);
-  if (pipeIndex > 0) {
-    return `${command.slice(0, pipeIndex).trimEnd()} ${flag} ${command.slice(pipeIndex)}`;
-  }
-  return `${command} ${flag}`;
-}
-
-/**
- * Build the final test command based on quality config and retry state.
- */
-export function buildTestCommand(
-  baseCommand: string,
-  options: {
-    forceExit?: boolean;
-    detectOpenHandles?: boolean;
-    detectOpenHandlesRetries?: number;
-    timeoutRetryCount?: number;
-  },
-): string {
-  let command = baseCommand;
-
-  const { forceExit = false, detectOpenHandles = true, detectOpenHandlesRetries = 1, timeoutRetryCount = 0 } = options;
-
-  // If we've exhausted detectOpenHandles retries, force exit as last resort
-  const exhaustedDiagnosticRetries = timeoutRetryCount > detectOpenHandlesRetries;
-
-  // Apply --forceExit if configured or if diagnostic retries exhausted
-  if (forceExit || exhaustedDiagnosticRetries) {
-    command = appendForceExitFlag(command);
-  }
-
-  // Apply --detectOpenHandles on timeout retries (within cap)
-  if (detectOpenHandles && timeoutRetryCount > 0 && timeoutRetryCount <= detectOpenHandlesRetries) {
-    command = appendOpenHandlesFlag(command);
-  }
-
-  return command;
-}

package/src/verification/index.ts

@@ -1,12 +0,0 @@
-/**
- * Unified Verification Layer
- *
- * Central module for test execution, parsing, and verification gates.
- * Eliminates duplication across execution/, tdd/, and pipeline/stages/.
- */
-
-export * from "./types";
-export * from "./executor";
-export * from "./parser";
-export * from "./runners";
-export * from "./rectification";

package/src/verification/orchestrator-types.ts

@@ -1,154 +0,0 @@
-// RE-ARCH: keep
-/**
- * Unified Verification Orchestrator Types (ADR-005, Phase 1)
- *
- * Defines the shared types used by the VerificationOrchestrator and all
- * verification strategies. Coexists with existing types.ts — these types
- * are additive and do not replace existing interfaces until Phase 3.
- */
-
-import type { NaxConfig } from "../config";
-import type { SmartTestRunnerConfig } from "../config/types";
-
-// ---------------------------------------------------------------------------
-// Strategy enum
-// ---------------------------------------------------------------------------
-
-export type VerifyStrategy = "scoped" | "regression" | "deferred-regression" | "acceptance";
-
-// ---------------------------------------------------------------------------
-// Input context
-// ---------------------------------------------------------------------------
-
-export interface VerifyContext {
-  workdir: string;
-  testCommand: string;
-  /** Scoped test command template with {{files}} placeholder — overrides buildSmartTestCommand heuristic */
-  testScopedTemplate?: string;
-  timeoutSeconds: number;
-  storyId: string;
-  storyGitRef?: string;
-  smartRunnerConfig?: SmartTestRunnerConfig;
-  regressionMode?: string;
-  acceptOnTimeout?: boolean;
-  acceptanceTestPath?: string;
-  config?: NaxConfig;
-}
-
-// ---------------------------------------------------------------------------
-// Structured failure
-// ---------------------------------------------------------------------------
-
-export interface StructuredTestFailure {
-  file: string;
-  testName: string;
-  error: string;
-  stackTrace: string[];
-}
-
-// ---------------------------------------------------------------------------
-// Result
-// ---------------------------------------------------------------------------
-
-export type VerifyStatus =
-  | "PASS"
-  | "TEST_FAILURE"
-  | "TIMEOUT"
-  | "BUILD_ERROR"
-  | "SKIPPED"
-  | "ASSET_CHECK_FAILED"
-  | "RUNTIME_CRASH";
-
-export interface VerifyResult {
-  success: boolean;
-  status: VerifyStatus;
-  storyId: string;
-  strategy: VerifyStrategy;
-  passCount: number;
-  failCount: number;
-  totalCount: number;
-  failures: StructuredTestFailure[];
-  rawOutput?: string;
-  durationMs: number;
-  countsTowardEscalation: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Strategy interface
-// ---------------------------------------------------------------------------
-
-export interface IVerificationStrategy {
-  readonly name: VerifyStrategy;
-  execute(ctx: VerifyContext): Promise<VerifyResult>;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-export function makeSkippedResult(storyId: string, strategy: VerifyStrategy): VerifyResult {
-  return {
-    success: true,
-    status: "SKIPPED",
-    storyId,
-    strategy,
-    passCount: 0,
-    failCount: 0,
-    totalCount: 0,
-    failures: [],
-    durationMs: 0,
-    countsTowardEscalation: false,
-  };
-}
-
-export function makeFailResult(
-  storyId: string,
-  strategy: VerifyStrategy,
-  status: VerifyStatus,
-  opts: {
-    rawOutput?: string;
-    failures?: StructuredTestFailure[];
-    passCount?: number;
-    failCount?: number;
-    durationMs?: number;
-    countsTowardEscalation?: boolean;
-  } = {},
-): VerifyResult {
-  return {
-    success: false,
-    status,
-    storyId,
-    strategy,
-    passCount: opts.passCount ?? 0,
-    failCount: opts.failCount ?? 0,
-    totalCount: (opts.passCount ?? 0) + (opts.failCount ?? 0),
-    failures: opts.failures ?? [],
-    rawOutput: opts.rawOutput,
-    durationMs: opts.durationMs ?? 0,
-    countsTowardEscalation: opts.countsTowardEscalation ?? true,
-  };
-}
-
-export function makePassResult(
-  storyId: string,
-  strategy: VerifyStrategy,
-  opts: {
-    rawOutput?: string;
-    passCount?: number;
-    durationMs?: number;
-  } = {},
-): VerifyResult {
-  return {
-    success: true,
-    status: "PASS",
-    storyId,
-    strategy,
-    passCount: opts.passCount ?? 0,
-    failCount: 0,
-    totalCount: opts.passCount ?? 0,
-    failures: [],
-    rawOutput: opts.rawOutput,
-    durationMs: opts.durationMs ?? 0,
-    countsTowardEscalation: false,
-  };
-}

package/src/verification/orchestrator.ts

@@ -1,76 +0,0 @@
-// RE-ARCH: keep
-/**
- * Verification Orchestrator (ADR-005, Phase 1)
- *
- * Single entry point for all test verification. Selects and delegates to the
- * appropriate strategy based on context. Additive — existing code paths are
- * unchanged until Phase 3.
- *
- * Usage:
- *   const result = await verificationOrchestrator.verify(ctx, "scoped");
- */
-
-import type { IVerificationStrategy, VerifyContext, VerifyResult, VerifyStrategy } from "./orchestrator-types";
-import { makeSkippedResult } from "./orchestrator-types";
-import { AcceptanceStrategy } from "./strategies/acceptance";
-import { DeferredRegressionStrategy, RegressionStrategy } from "./strategies/regression";
-import { ScopedStrategy } from "./strategies/scoped";
-
-export class VerificationOrchestrator {
-  private readonly strategies: Map<VerifyStrategy, IVerificationStrategy>;
-
-  constructor(overrides?: Partial<Record<VerifyStrategy, IVerificationStrategy>>) {
-    this.strategies = new Map([
-      ["scoped", overrides?.scoped ?? new ScopedStrategy()],
-      ["regression", overrides?.regression ?? new RegressionStrategy()],
-      ["deferred-regression", overrides?.["deferred-regression"] ?? new DeferredRegressionStrategy()],
-      ["acceptance", overrides?.acceptance ?? new AcceptanceStrategy()],
-    ]);
-  }
-
-  /**
-   * Run verification using the specified strategy.
-   *
-   * @param ctx     - Context with workdir, testCommand, storyId, etc.
-   * @param strategy - Which strategy to use
-   * @returns Unified VerifyResult
-   */
-  async verify(ctx: VerifyContext, strategy: VerifyStrategy): Promise<VerifyResult> {
-    const impl = this.strategies.get(strategy);
-    if (!impl) {
-      return makeSkippedResult(ctx.storyId, strategy);
-    }
-    return impl.execute(ctx);
-  }
-
-  /**
-   * Run scoped verification (smart-runner selects test files).
-   */
-  async verifyScoped(ctx: VerifyContext): Promise<VerifyResult> {
-    return this.verify(ctx, "scoped");
-  }
-
-  /**
-   * Run full-suite regression gate.
-   */
-  async verifyRegression(ctx: VerifyContext): Promise<VerifyResult> {
-    return this.verify(ctx, "regression");
-  }
-
-  /**
-   * Run deferred regression gate (same as regression — caller decides timing).
-   */
-  async verifyDeferredRegression(ctx: VerifyContext): Promise<VerifyResult> {
-    return this.verify(ctx, "deferred-regression");
-  }
-
-  /**
-   * Run acceptance tests from feature directory.
-   */
-  async verifyAcceptance(ctx: VerifyContext): Promise<VerifyResult> {
-    return this.verify(ctx, "acceptance");
-  }
-}
-
-/** Singleton instance for production use. */
-export const verificationOrchestrator = new VerificationOrchestrator();

package/src/verification/parser.ts

@@ -1,220 +0,0 @@
-/**
- * Test Output Parsing
- *
- * Unified test output parsing logic for Bun test framework.
- * Extracted from execution/test-output-parser.ts and execution/verification.ts.
- */
-
-import type { TestFailure, TestOutputAnalysis, TestSummary } from "./types";
-
-/**
- * Parse Bun test output into structured failure objects.
- *
- * Example output format:
- * ```
- * bun test v1.0.0
- *
- * test/example.test.ts:
- * ✓ passing test [0.5ms]
- * ✗ failing test [1.2ms]
- *
- * (fail) describe block > nested block > test name [1.2ms]
- * Error: Expected 1 to equal 2
- *   at /path/to/file.ts:10:15
- *   at Object.test (/path/to/file.ts:8:3)
- * ```
- */
-export function parseBunTestOutput(output: string): TestSummary {
-  const lines = output.split("\n");
-  const failures: TestFailure[] = [];
-  let passed = 0;
-  let failed = 0;
-  let currentFile = "";
-  let i = 0;
-
-  while (i < lines.length) {
-    const line = lines[i];
-
-    // Extract file path from headers like "test/example.test.ts:"
-    if (line.trim().endsWith(".test.ts:") || line.trim().endsWith(".test.js:")) {
-      currentFile = line.trim().replace(/:$/, "");
-      i++;
-      continue;
-    }
-
-    // Count passed tests (✓ or ✔)
-    if (line.includes("✓") || line.includes("✔")) {
-      passed++;
-      i++;
-      continue;
-    }
-
-    // Count failed tests (✗ or ✘)
-    if (line.includes("✗") || line.includes("✘")) {
-      failed++;
-      i++;
-      continue;
-    }
-
-    // Parse failure line: "(fail) TestName > nested > name [duration]"
-    const failMatch = line.match(/^\(fail\)\s+(.+?)\s+\[[\d.]+m?s\]/);
-    if (failMatch) {
-      const testName = failMatch[1].trim();
-      i++;
-
-      // Extract error message and stack trace
-      let error = "";
-      const stackTrace: string[] = [];
-      let stackLineCount = 0;
-
-      // Read lines until we hit a blank line or another test result
-      while (i < lines.length && stackLineCount < 5) {
-        const nextLine = lines[i];
-
-        // Stop at blank line or next test result
-        if (!nextLine.trim() || nextLine.includes("(fail)") || nextLine.includes("✓") || nextLine.includes("✗")) {
-          break;
-        }
-
-        // First non-blank line is typically the error message
-        if (!error && nextLine.trim()) {
-          error = nextLine.trim();
-          i++;
-          continue;
-        }
-
-        // Subsequent lines starting with "at" are stack trace
-        if (nextLine.trim().startsWith("at ")) {
-          stackTrace.push(nextLine.trim());
-          stackLineCount++;
-        }
-        i++;
-      }
-
-      failures.push({
-        file: currentFile || "unknown",
-        testName,
-        error: error || "Unknown error",
-        stackTrace,
-      });
-      continue;
-    }
-
-    i++;
-  }
-
-  return { passed, failed, failures };
-}
-
-/**
- * Format failure summary for agent feedback.
- *
- * Format:
- * ```
- * 1. file.test.ts > TestName > nested
- *    Error: message
- *    at file.ts:10:15
- *
- * 2. another.test.ts > OtherTest
- *    Error: another error
- *    at other.ts:20:10
- * ```
- */
-export function formatFailureSummary(failures: TestFailure[], maxChars = 2000): string {
-  if (failures.length === 0) {
-    return "No test failures";
-  }
-
-  const lines: string[] = [];
-  let totalChars = 0;
-
-  for (let i = 0; i < failures.length; i++) {
-    const failure = failures[i];
-    const num = i + 1;
-
-    // Format: "1. file.test.ts > TestName"
-    const header = `${num}. ${failure.file} > ${failure.testName}`;
-    const errorLine = `   Error: ${failure.error}`;
-
-    // Add first stack trace line if available
-    const stackLine = failure.stackTrace.length > 0 ? `   ${failure.stackTrace[0]}` : "";
-
-    const blockLines = [header, errorLine];
-    if (stackLine) {
-      blockLines.push(stackLine);
-    }
-    blockLines.push(""); // blank line separator
-
-    const block = blockLines.join("\n");
-    const blockLength = block.length;
-
-    // Check if adding this block would exceed maxChars
-    if (totalChars + blockLength > maxChars && lines.length > 0) {
-      const remaining = failures.length - i;
-      lines.push(`\n... and ${remaining} more failure(s) (truncated)`);
-      break;
-    }
-
-    lines.push(...blockLines);
-    totalChars += blockLength;
-  }
-
-  return lines.join("\n").trim();
-}
-
-/**
- * Parse test output to detect environmental failures.
- *
- * When exit code != 0 but all tests pass, classifies as ENVIRONMENTAL_FAILURE
- * instead of TEST_FAILURE.
- */
-export function parseTestOutput(output: string, exitCode: number): TestOutputAnalysis {
-  // Regex patterns for different test frameworks
-  const patterns = [
-    /(\d+)\s+pass(?:ed)?(?:,\s+|\s+)(\d+)\s+fail/i, // "5 pass, 0 fail" or "5 passed 0 fail"
-    /Tests:\s+(\d+)\s+passed,\s+(\d+)\s+failed/i, // Jest format
-    /(\d+)\s+pass/i, // Bun format (just pass count)
-  ];
-
-  let passCount = 0;
-  let failCount = 0;
-
-  for (const pattern of patterns) {
-    // Match ALL occurrences — use the LAST one (final summary line)
-    const matches = Array.from(output.matchAll(new RegExp(pattern, "gi")));
-    if (matches.length > 0) {
-      const lastMatch = matches[matches.length - 1];
-      passCount = Number.parseInt(lastMatch[1], 10);
-      // Some formats only show pass count
-      failCount = lastMatch[2] ? Number.parseInt(lastMatch[2], 10) : 0;
-      break;
-    }
-  }
-
-  // Check for explicit fail count if not found
-  if (failCount === 0) {
-    const failMatches = Array.from(output.matchAll(/(\d+)\s+fail/gi));
-    if (failMatches.length > 0) {
-      failCount = Number.parseInt(failMatches[failMatches.length - 1][1], 10);
-    }
-  }
-
-  const allTestsPassed = passCount > 0 && failCount === 0;
-  const isEnvironmentalFailure = allTestsPassed && exitCode !== 0;
-
-  const result: TestOutputAnalysis = {
-    allTestsPassed,
-    passCount,
-    failCount,
-    isEnvironmentalFailure,
-  };
-
-  if (isEnvironmentalFailure) {
-    result.error = `ENVIRONMENTAL_FAILURE: All ${passCount} tests passed but exit code was ${exitCode}. Check linter/typecheck/missing files.`;
-  }
-
-  return result;
-}
-
-// Re-export types for consumers that import from this module
-export type { TestFailure, TestSummary } from "./types";