@nathapp/nax 0.20.0 → 0.22.0

package/test/unit/verification/smart-runner-discovery.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Smart Test Runner — 3-Pass Discovery Tests
  *
@@ -115,7 +116,7 @@ describe("Pass 2: importGrepFallback", () => {
   test("matches test file that imports the source by basename path", async () => {
     mockGlob(["test/unit/routing.test.ts"]);
     mockFileContent({
-      "/repo/test/unit/routing.test.ts": `import { route } from "../../src/routing/strategies/llm";`,
+      "/repo/test/unit/routing.test.ts": `import { route } from "../../../src/routing/strategies/llm";`,
     });
 
     const result = await importGrepFallback(
@@ -145,7 +146,7 @@ describe("Pass 2: importGrepFallback", () => {
   test("does not match test file with no import reference", async () => {
     mockGlob(["test/unit/other.test.ts"]);
     mockFileContent({
-      "/repo/test/unit/other.test.ts": `import { something } from "../../src/other/module";`,
+      "/repo/test/unit/other.test.ts": `import { something } from "../../../src/other/module";`,
     });
 
     const result = await importGrepFallback(
@@ -160,8 +161,8 @@ describe("Pass 2: importGrepFallback", () => {
   test("returns multiple matching test files", async () => {
     mockGlob(["test/unit/a.test.ts", "test/unit/b.test.ts"]);
     mockFileContent({
-      "/repo/test/unit/a.test.ts": `import { fn } from "../src/utils/helper";`,
-      "/repo/test/unit/b.test.ts": `import { fn } from "../../src/utils/helper";`,
+      "/repo/test/unit/a.test.ts": `import { fn } from "../../../src/utils/helper";`,
+      "/repo/test/unit/b.test.ts": `import { fn } from "../../../src/utils/helper";`,
     });
 
     const result = await importGrepFallback(
@@ -182,7 +183,7 @@ describe("Pass 2: importGrepFallback", () => {
       exists: () => Promise.resolve(true),
       text: () => {
         if (path.includes("broken")) throw new Error("read error");
-        return Promise.resolve(`import { fn } from "../src/utils/helper";`);
+        return Promise.resolve(`import { fn } from "../../../src/utils/helper";`);
       },
     });
 
@@ -200,7 +201,7 @@ describe("Pass 2: importGrepFallback", () => {
     mockGlob(["test/unit/routing.test.ts"]);
     // Content contains both "/llm" and "routing/strategies/llm"
     mockFileContent({
-      "/repo/test/unit/routing.test.ts": `import { classify } from "../../src/routing/strategies/llm";`,
+      "/repo/test/unit/routing.test.ts": `import { classify } from "../../../src/routing/strategies/llm";`,
     });
 
     const result = await importGrepFallback(
@@ -273,7 +274,7 @@ describe("Pass 3: full-suite fallback (empty return from both passes)", () => {
     };
     // biome-ignore lint/suspicious/noExplicitAny: mocking
     (Bun as any).file = (_path: string) => ({
-      text: () => Promise.resolve(`import { x } from "../src/completely/different";`),
+      text: () => Promise.resolve(`import { x } from "../../../src/completely/different";`),
     });
 
     const result = await importGrepFallback(

package/test/unit/verification/strategies/acceptance.test.ts

@@ -0,0 +1,33 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { AcceptanceStrategy } from "../../../../src/verification/strategies/acceptance";
+import type { VerifyContext } from "../../../../src/verification/orchestrator-types";
+
+function makeCtx(overrides: Partial<VerifyContext> = {}): VerifyContext {
+  return {
+    workdir: "/tmp/test-repo",
+    testCommand: "bun test",
+    timeoutSeconds: 60,
+    storyId: "US-001",
+    ...overrides,
+  };
+}
+
+describe("AcceptanceStrategy", () => {
+  test("name is acceptance", () => {
+    expect(new AcceptanceStrategy().name).toBe("acceptance");
+  });
+
+  test("returns SKIPPED when no acceptanceTestPath", async () => {
+    const result = await new AcceptanceStrategy().execute(makeCtx());
+    expect(result.status).toBe("SKIPPED");
+    expect(result.success).toBe(true);
+  });
+
+  test("returns SKIPPED when test file does not exist", async () => {
+    const result = await new AcceptanceStrategy().execute(
+      makeCtx({ acceptanceTestPath: "/nonexistent/path/acceptance.test.ts" }),
+    );
+    expect(result.status).toBe("SKIPPED");
+  });
+});

package/test/unit/verification/strategies/regression.test.ts

@@ -0,0 +1,87 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { RegressionStrategy, _regressionStrategyDeps } from "../../../../src/verification/strategies/regression";
+import type { VerifyContext } from "../../../../src/verification/orchestrator-types";
+import { DEFAULT_CONFIG } from "../../../../src/config";
+
+function makeCtx(overrides: Partial<VerifyContext> = {}): VerifyContext {
+  return {
+    workdir: "/tmp/test-repo",
+    testCommand: "bun test",
+    timeoutSeconds: 120,
+    storyId: "US-001",
+    acceptOnTimeout: true,
+    config: DEFAULT_CONFIG,
+    ...overrides,
+  };
+}
+
+describe("RegressionStrategy", () => {
+  test("name is regression", () => {
+    expect(new RegressionStrategy().name).toBe("regression");
+  });
+
+  test("returns SKIPPED when gate disabled", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      execution: {
+        ...DEFAULT_CONFIG.execution,
+        regressionGate: { enabled: false, timeoutSeconds: 120, mode: "inline" as const },
+      },
+    };
+    const result = await new RegressionStrategy().execute(makeCtx({ config }));
+    expect(result.status).toBe("SKIPPED");
+    expect(result.success).toBe(true);
+  });
+
+  test("returns PASS when tests pass", async () => {
+    const saved = { ...(_regressionStrategyDeps as any) };
+    _regressionStrategyDeps.runVerification = async () => ({
+      success: true,
+      status: "SUCCESS" as const,
+      countsTowardEscalation: false,
+      output: "10 pass",
+    });
+
+    const result = await new RegressionStrategy().execute(makeCtx());
+
+    Object.assign(_regressionStrategyDeps, saved);
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe("PASS");
+    expect(result.strategy).toBe("regression");
+  });
+
+  test("accepts TIMEOUT as pass when acceptOnTimeout=true", async () => {
+    const saved = { ...(_regressionStrategyDeps as any) };
+    _regressionStrategyDeps.runVerification = async () => ({
+      success: false,
+      status: "TIMEOUT" as const,
+      countsTowardEscalation: false,
+    });
+
+    const result = await new RegressionStrategy().execute(makeCtx({ acceptOnTimeout: true }));
+
+    Object.assign(_regressionStrategyDeps, saved);
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe("PASS");
+  });
+
+  test("returns TEST_FAILURE when tests fail", async () => {
+    const saved = { ...(_regressionStrategyDeps as any) };
+    _regressionStrategyDeps.runVerification = async () => ({
+      success: false,
+      status: "TEST_FAILURE" as const,
+      countsTowardEscalation: true,
+      output: "(fail) x > y\n2 fail",
+    });
+
+    const result = await new RegressionStrategy().execute(makeCtx({ acceptOnTimeout: false }));
+
+    Object.assign(_regressionStrategyDeps, saved);
+
+    expect(result.success).toBe(false);
+    expect(result.status).toBe("TEST_FAILURE");
+  });
+});

package/test/unit/verification/strategies/scoped.test.ts

@@ -0,0 +1,100 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { ScopedStrategy, _scopedDeps } from "../../../../src/verification/strategies/scoped";
+import type { VerifyContext } from "../../../../src/verification/orchestrator-types";
+
+function makeCtx(overrides: Partial<VerifyContext> = {}): VerifyContext {
+  return {
+    workdir: "/tmp/test-repo",
+    testCommand: "bun test",
+    timeoutSeconds: 60,
+    storyId: "US-001",
+    storyGitRef: "abc123",
+    regressionMode: "deferred",
+    acceptOnTimeout: true,
+    ...overrides,
+  };
+}
+
+describe("ScopedStrategy", () => {
+  test("name is scoped", () => {
+    expect(new ScopedStrategy().name).toBe("scoped");
+  });
+
+  test("returns SKIPPED when deferred mode and no mapped tests", async () => {
+    const saved = { ..._scopedDeps };
+    _scopedDeps.getChangedSourceFiles = async () => [];
+    _scopedDeps.mapSourceToTests = async () => [];
+    _scopedDeps.importGrepFallback = async () => [];
+
+    const result = await new ScopedStrategy().execute(makeCtx({ regressionMode: "deferred" }));
+
+    Object.assign(_scopedDeps, saved);
+
+    expect(result.status).toBe("SKIPPED");
+    expect(result.success).toBe(true);
+    expect(result.countsTowardEscalation).toBe(false);
+  });
+
+  test("runs full suite when inline mode and no mapped tests", async () => {
+    const saved = { ..._scopedDeps };
+    _scopedDeps.getChangedSourceFiles = async () => [];
+    _scopedDeps.mapSourceToTests = async () => [];
+    _scopedDeps.importGrepFallback = async () => [];
+    _scopedDeps.regression = async () => ({
+      success: true,
+      status: "SUCCESS" as const,
+      countsTowardEscalation: false,
+      output: "1 pass",
+    });
+
+    const result = await new ScopedStrategy().execute(makeCtx({ regressionMode: "inline" }));
+
+    Object.assign(_scopedDeps, saved);
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe("PASS");
+  });
+
+  test("returns PASS when tests pass", async () => {
+    const saved = { ..._scopedDeps };
+    _scopedDeps.getChangedSourceFiles = async () => ["src/foo.ts"];
+    _scopedDeps.mapSourceToTests = async () => ["test/unit/foo.test.ts"];
+    _scopedDeps.buildSmartTestCommand = (_files: string[], cmd: string) => `${cmd} test/unit/foo.test.ts`;
+    _scopedDeps.regression = async () => ({
+      success: true,
+      status: "SUCCESS" as const,
+      countsTowardEscalation: false,
+      output: "5 pass\n0 fail",
+    });
+
+    const result = await new ScopedStrategy().execute(makeCtx());
+
+    Object.assign(_scopedDeps, saved);
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe("PASS");
+    expect(result.strategy).toBe("scoped");
+  });
+
+  test("returns TEST_FAILURE when tests fail", async () => {
+    const saved = { ..._scopedDeps };
+    _scopedDeps.getChangedSourceFiles = async () => ["src/foo.ts"];
+    _scopedDeps.mapSourceToTests = async () => ["test/unit/foo.test.ts"];
+    _scopedDeps.buildSmartTestCommand = (_files: string[], cmd: string) => cmd;
+    _scopedDeps.regression = async () => ({
+      success: false,
+      status: "TEST_FAILURE" as const,
+      countsTowardEscalation: true,
+      output: "(fail) foo > bar\n1 fail",
+    });
+
+    const result = await new ScopedStrategy().execute(makeCtx());
+
+    Object.assign(_scopedDeps, saved);
+
+    expect(result.success).toBe(false);
+    expect(result.status).toBe("TEST_FAILURE");
+    expect(result.countsTowardEscalation).toBe(true);
+  });
+});

package/test/unit/worktree-manager.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/worktree/manager.ts
  *

package/src/execution/lifecycle/story-hooks.ts

@@ -1,38 +0,0 @@
-/**
- * Story Lifecycle Hooks
- *
- * Centralizes reporter notification boilerplate for story lifecycle events:
- * - onStoryComplete (completed/paused/skipped/failed)
- */
-
-import { getSafeLogger } from "../../logger";
-import type { IReporter } from "../../plugins/types";
-
-export interface StoryCompleteEvent {
-  runId: string;
-  storyId: string;
-  status: "completed" | "paused" | "skipped" | "failed";
-  durationMs: number;
-  cost: number;
-  tier: string;
-  testStrategy: string;
-}
-
-/**
- * Emit onStoryComplete event to all reporters
- *
- * Handles error recovery for individual reporter failures.
- */
-export async function emitStoryComplete(reporters: IReporter[], event: StoryCompleteEvent): Promise<void> {
-  const logger = getSafeLogger();
-
-  for (const reporter of reporters) {
-    if (reporter.onStoryComplete) {
-      try {
-        await reporter.onStoryComplete(event);
-      } catch (error) {
-        logger?.warn("plugins", `Reporter '${reporter.name}' onStoryComplete failed`, { error });
-      }
-    }
-  }
-}

package/src/execution/post-verify.ts

@@ -1,193 +0,0 @@
-/**
- * Post-Agent Verification (ADR-003)
- *
- * Runs verification after the agent completes, reverts story state on failure.
- */
-
-import type { NaxConfig } from "../config";
-import { getSafeLogger } from "../logger";
-import type { StoryMetrics } from "../metrics";
-import type { PRD, StructuredFailure, UserStory, VerificationStage } from "../prd";
-import { getExpectedFiles, savePRD } from "../prd";
-import type { VerificationResult } from "../verification";
-import { parseBunTestOutput } from "../verification";
-import { revertStoriesOnFailure, runRectificationLoop } from "./post-verify-rectification";
-import { runVerification } from "./verification";
-
-/** Build a StructuredFailure from verification result and test output. */
-function buildStructuredFailure(
-  story: UserStory,
-  stage: VerificationStage,
-  verificationResult: VerificationResult,
-  summary: string,
-): StructuredFailure {
-  const testFailures =
-    verificationResult.status === "TEST_FAILURE" && verificationResult.output
-      ? _postVerifyDeps.parseBunTestOutput(verificationResult.output).failures.map((f) => ({
-          file: f.file,
-          testName: f.testName,
-          error: f.error,
-          stackTrace: f.stackTrace,
-        }))
-      : undefined;
-
-  return {
-    attempt: (story.attempts ?? 0) + 1,
-    modelTier: story.routing?.modelTier ?? "unknown",
-    stage,
-    summary,
-    testFailures: testFailures && testFailures.length > 0 ? testFailures : undefined,
-    timestamp: new Date().toISOString(),
-  };
-}
-
-export interface PostVerifyOptions {
-  config: NaxConfig;
-  prd: PRD;
-  prdPath: string;
-  workdir: string;
-  featureDir?: string;
-  story: UserStory;
-  storiesToExecute: UserStory[];
-  allStoryMetrics: StoryMetrics[];
-  timeoutRetryCountMap: Map<string, number>;
-}
-
-export interface PostVerifyResult {
-  passed: boolean;
-  prd: PRD;
-}
-
-/**
- * Run post-agent verification and handle failure state.
- *
- * @design Shell command in config.quality.commands.test is operator-controlled,
- * not user/PRD input. No shell injection risk from untrusted sources.
- */
-export async function runPostAgentVerification(opts: PostVerifyOptions): Promise<PostVerifyResult> {
-  const { config, prd, prdPath, workdir, featureDir, story, storiesToExecute, allStoryMetrics } = opts;
-
-  if (!config.quality.commands.test) return { passed: true, prd };
-
-  const rectificationEnabled = config.execution.rectification?.enabled ?? false;
-  const regressionMode = config.execution.regressionGate?.mode;
-
-  // Skip per-story regression gate only when explicitly set to deferred
-  if (regressionMode === "deferred") {
-    return { passed: true, prd };
-  }
-
-  // Run full-suite regression gate (per-story mode)
-  const regressionGateResult = await runRegressionGate(config, workdir, story, rectificationEnabled);
-
-  if (regressionGateResult.status === "passed" || regressionGateResult.status === "skipped") {
-    return { passed: true, prd };
-  }
-
-  // Regression failed -- build StructuredFailure and revert stories
-  // verificationResult is always set when status === "failed" (see RegressionGateResult)
-  const regressionVerificationResult = regressionGateResult.verificationResult ?? {
-    status: "TEST_FAILURE" as const,
-    success: false,
-    countsTowardEscalation: true,
-  };
-  const regressionFailure = buildStructuredFailure(
-    story,
-    "regression",
-    regressionVerificationResult,
-    "Full-suite regression detected",
-  );
-  const updatedPrd = await _postVerifyDeps.revertStoriesOnFailure({
-    prd,
-    prdPath,
-    story,
-    storiesToExecute,
-    allStoryMetrics,
-    featureDir,
-    diagnosticContext: "REGRESSION: full-suite regression detected",
-    countsTowardEscalation: true,
-    priorFailure: regressionFailure,
-  });
-  return { passed: false, prd: updatedPrd };
-}
-
-interface RegressionGateResult {
-  status: "passed" | "skipped" | "failed";
-  verificationResult?: VerificationResult;
-}
-
-/** Run full-suite regression gate. */
-async function runRegressionGate(
-  config: NaxConfig,
-  workdir: string,
-  story: UserStory,
-  rectificationEnabled: boolean,
-): Promise<RegressionGateResult> {
-  const logger = getSafeLogger();
-  const regressionGateEnabled = config.execution.regressionGate?.enabled ?? true;
-
-  if (!regressionGateEnabled) {
-    return { status: "skipped" };
-  }
-
-  logger?.info("regression-gate", "Running full-suite regression gate");
-  const fullSuiteCommand = config.quality.commands.test ?? "bun test";
-  const regressionResult = await _postVerifyDeps.runVerification({
-    workingDirectory: workdir,
-    expectedFiles: _postVerifyDeps.getExpectedFiles(story),
-    command: fullSuiteCommand,
-    timeoutSeconds: config.execution.regressionGate.timeoutSeconds,
-    forceExit: config.quality.forceExit,
-    detectOpenHandles: config.quality.detectOpenHandles,
-    detectOpenHandlesRetries: config.quality.detectOpenHandlesRetries,
-    timeoutRetryCount: 0,
-    gracePeriodMs: config.quality.gracePeriodMs,
-    drainTimeoutMs: config.quality.drainTimeoutMs,
-    shell: config.quality.shell,
-    stripEnvVars: config.quality.stripEnvVars,
-  });
-
-  if (regressionResult.success) {
-    logger?.info("regression-gate", "Full-suite regression gate passed");
-    return { status: "passed" };
-  }
-
-  // Handle timeout: accept as pass if configured (BUG-026)
-  const acceptOnTimeout = config.execution.regressionGate?.acceptOnTimeout ?? true;
-  if (regressionResult.status === "TIMEOUT" && acceptOnTimeout) {
-    logger?.warn("regression-gate", "[BUG-026] Full-suite regression gate timed out (accepted as pass)");
-    return { status: "passed" };
-  }
-
-  logger?.warn("regression-gate", "Full-suite regression detected", { status: regressionResult.status });
-
-  // Attempt rectification on regression failures
-  const isTestFailure = regressionResult.status === "TEST_FAILURE" && regressionResult.output;
-  if (rectificationEnabled && isTestFailure && regressionResult.output) {
-    const fixed = await _postVerifyDeps.runRectificationLoop({
-      config,
-      workdir,
-      story,
-      testCommand: fullSuiteCommand,
-      timeoutSeconds: config.execution.regressionGate.timeoutSeconds,
-      testOutput: regressionResult.output,
-      promptPrefix:
-        "# REGRESSION: Full-Suite Test Failures\n\nYour changes broke tests in the full suite. Fix these regressions.",
-    });
-    if (fixed) return { status: "passed" };
-  }
-
-  return { status: "failed", verificationResult: regressionResult };
-}
-
-/**
- * Swappable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
- */
-export const _postVerifyDeps = {
-  parseBunTestOutput,
-  runVerification,
-  getExpectedFiles,
-  savePRD,
-  revertStoriesOnFailure,
-  runRectificationLoop,
-};

package/src/execution/rectification.ts

@@ -1,13 +0,0 @@
-/**
- * Rectification Core Logic (v0.11)
- *
- * DEPRECATED: Use src/verification/rectification.ts instead.
- * This file is kept for backward compatibility only.
- */
-
-// Re-export from unified verification layer
-export {
-  type RectificationState,
-  shouldRetryRectification,
-  createRectificationPrompt,
-} from "../verification/rectification";

package/src/execution/verification.ts

@@ -1,72 +0,0 @@
-/**
- * ADR-003: Robust Orchestration Feedback Loop - Verification Module
- *
- * DEPRECATED: Use src/verification/ unified layer instead.
- * This file is kept for backward compatibility only.
- *
- * Implements Decisions 3-6:
- * - Pre-Flight Asset Verification
- * - Execution Guard (Verification Timeout)
- * - Smart Exit-Code Analysis
- * - Environment Normalization
- */
-
-// Re-export from unified verification layer
-export {
-  type AssetVerificationResult,
-  type TestExecutionResult as TimeoutExecutionResult,
-  type TestOutputAnalysis,
-  type VerificationResult,
-  type VerificationStatus,
-  verifyAssets,
-  executeWithTimeout,
-  parseTestOutput,
-  getEnvironmentalEscalationThreshold,
-  normalizeEnvironment,
-  appendOpenHandlesFlag,
-  appendForceExitFlag,
-  buildTestCommand,
-} from "../verification";
-
-// Adapter function for backward compatibility
-import { fullSuite } from "../verification";
-import type { VerificationGateOptions } from "../verification/types";
-
-/**
- * Run complete verification flow with all ADR-003 safety checks.
- *
- * @deprecated Use fullSuite() from src/verification/gate.ts instead
- */
-export async function runVerification(options: {
-  workingDirectory: string;
-  expectedFiles?: string[];
-  command: string;
-  timeoutSeconds: number;
-  forceExit?: boolean;
-  detectOpenHandles?: boolean;
-  detectOpenHandlesRetries?: number;
-  timeoutRetryCount?: number;
-  gracePeriodMs?: number;
-  drainTimeoutMs?: number;
-  shell?: string;
-  stripEnvVars?: string[];
-  cwd?: string;
-}) {
-  // Map old options to new VerificationGateOptions
-  const gateOptions: VerificationGateOptions = {
-    workdir: options.workingDirectory,
-    expectedFiles: options.expectedFiles,
-    command: options.command,
-    timeoutSeconds: options.timeoutSeconds,
-    forceExit: options.forceExit,
-    detectOpenHandles: options.detectOpenHandles,
-    detectOpenHandlesRetries: options.detectOpenHandlesRetries,
-    timeoutRetryCount: options.timeoutRetryCount,
-    gracePeriodMs: options.gracePeriodMs,
-    drainTimeoutMs: options.drainTimeoutMs,
-    shell: options.shell,
-    stripEnvVars: options.stripEnvVars,
-  };
-
-  return fullSuite(gateOptions);
-}