@nathapp/nax 0.28.0 → 0.30.0

package/test/unit/pipeline/stages/routing-persistence.test.ts

@@ -1,380 +0,0 @@
-/**
- * Routing Stage — RRP-001: Persist initial routing to prd.json on first classification
- *
- * AC-1, AC-2, AC-3: Tests for persistence behavior, cached routing, and escalation.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { DEFAULT_CONFIG } from "../../../../src/config/defaults";
-import type { NaxConfig } from "../../../../src/config";
-import type { PRD, UserStory } from "../../../../src/prd";
-import type { PipelineContext } from "../../../../src/pipeline/types";
-import type { StoryRouting } from "../../../../src/prd/types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeStory(overrides?: Partial<UserStory>): UserStory {
-  return {
-    id: "US-001",
-    title: "Test Story",
-    description: "Test description",
-    acceptanceCriteria: [],
-    tags: [],
-    dependencies: [],
-    status: "in-progress",
-    passes: false,
-    escalations: [],
-    attempts: 0,
-    ...overrides,
-  };
-}
-
-function makePRD(story: UserStory): PRD {
-  return {
-    project: "test-project",
-    feature: "test-feature",
-    branchName: "feat/test",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    userStories: [story],
-  };
-}
-
-function makeConfig(): NaxConfig {
-  return {
-    ...DEFAULT_CONFIG,
-    tdd: {
-      ...DEFAULT_CONFIG.tdd,
-      greenfieldDetection: false,
-    },
-  };
-}
-
-function makeCtx(story: UserStory, overrides?: Partial<PipelineContext>): PipelineContext & { prdPath: string } {
-  const prd = makePRD(story);
-  return {
-    config: makeConfig(),
-    prd,
-    story,
-    stories: [story],
-    routing: {
-      complexity: "simple",
-      modelTier: "fast",
-      testStrategy: "test-after",
-      reasoning: "test",
-    },
-    workdir: "/tmp/nax-routing-test",
-    hooks: { hooks: {} },
-    prdPath: "/tmp/nax-routing-test/nax/prd.json",
-    ...overrides,
-  } as PipelineContext & { prdPath: string };
-}
-
-const FRESH_ROUTING_RESULT = {
-  complexity: "medium" as const,
-  modelTier: "balanced" as const,
-  testStrategy: "three-session-tdd" as const,
-  reasoning: "classified by routeStory",
-};
-
-// ---------------------------------------------------------------------------
-// AC-1 & AC-5: savePRD is called on first classification (story.routing undefined)
-// ---------------------------------------------------------------------------
-
-describe("routingStage - first classification persists routing to prd.json", () => {
-  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
-  let savePRDCallArgs: Array<[PRD, string]>;
-
-  beforeEach(() => {
-    savePRDCallArgs = [];
-  });
-
-  afterEach(() => {
-    mock.restore();
-    // Restore original deps after each test
-    if (origRoutingDeps) {
-      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
-      Object.assign(_routingDeps, origRoutingDeps);
-    }
-  });
-
-  test("calls savePRD with updated prd when story.routing is undefined", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock((prd: PRD, path: string) => {
-      savePRDCallArgs.push([prd, path]);
-      return Promise.resolve();
-    });
-
-    const story = makeStory({ routing: undefined });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    // savePRD must have been called exactly once
-    expect(savePRDCallArgs).toHaveLength(1);
-  });
-
-  test("persists correct prdPath to savePRD on first classification", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock((prd: PRD, path: string) => {
-      savePRDCallArgs.push([prd, path]);
-      return Promise.resolve();
-    });
-
-    const story = makeStory({ routing: undefined });
-    const prdPath = "/tmp/nax-routing-test/nax/prd.json";
-    const ctx = makeCtx(story, { prdPath } as Partial<PipelineContext>);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    const [, savedPath] = savePRDCallArgs[0];
-    expect(savedPath).toBe(prdPath);
-  });
-
-  test("story.routing is populated on prd after fresh classification", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock((prd: PRD, path: string) => {
-      savePRDCallArgs.push([prd, path]);
-      return Promise.resolve();
-    });
-
-    const story = makeStory({ routing: undefined });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    // The story in the PRD passed to savePRD must have routing populated
-    const [savedPrd] = savePRDCallArgs[0];
-    const savedStory = savedPrd.userStories.find((s) => s.id === story.id);
-    expect(savedStory?.routing).toBeDefined();
-    expect(savedStory?.routing?.complexity).toBe(FRESH_ROUTING_RESULT.complexity);
-    expect(savedStory?.routing?.testStrategy).toBe(FRESH_ROUTING_RESULT.testStrategy);
-  });
-
-  test("ctx.story.routing is set to fresh classification result", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock(() => Promise.resolve());
-
-    const story = makeStory({ routing: undefined });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    // story.routing must be populated so a crash+resume finds it
-    expect(ctx.story.routing).toBeDefined();
-    expect(ctx.story.routing?.complexity).toBe(FRESH_ROUTING_RESULT.complexity);
-    expect(ctx.story.routing?.testStrategy).toBe(FRESH_ROUTING_RESULT.testStrategy);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// AC-2: No re-classification when story.routing already exists
-// ---------------------------------------------------------------------------
-
-describe("routingStage - skips savePRD when story.routing already set", () => {
-  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
-  let savePRDCallCount: number;
-
-  beforeEach(() => {
-    savePRDCallCount = 0;
-  });
-
-  afterEach(() => {
-    mock.restore();
-    if (origRoutingDeps) {
-      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
-      Object.assign(_routingDeps, origRoutingDeps);
-    }
-  });
-
-  test("does NOT call savePRD when story.routing is already populated", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    const existingRouting: StoryRouting = {
-      complexity: "simple",
-      testStrategy: "test-after",
-      reasoning: "persisted from prior run",
-    };
-
-    _routingDeps.routeStory = mock(() =>
-      Promise.resolve({
-        complexity: "medium",
-        modelTier: "balanced",
-        testStrategy: "three-session-tdd",
-        reasoning: "re-classified",
-      }),
-    );
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock(() => {
-      savePRDCallCount++;
-      return Promise.resolve();
-    });
-
-    const story = makeStory({ routing: existingRouting });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    expect(savePRDCallCount).toBe(0);
-  });
-
-  test("uses persisted complexity/testStrategy (not re-classified values) when story.routing exists", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    const existingRouting: StoryRouting = {
-      complexity: "simple",
-      testStrategy: "test-after",
-      reasoning: "persisted",
-    };
-
-    _routingDeps.routeStory = mock(() =>
-      Promise.resolve({
-        complexity: "expert",
-        modelTier: "powerful",
-        testStrategy: "three-session-tdd",
-        reasoning: "fresh",
-      }),
-    );
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock(() => Promise.resolve());
-
-    const story = makeStory({ routing: existingRouting });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    // Should use persisted values, not re-classified ones
-    expect(ctx.routing.complexity).toBe("simple");
-    expect(ctx.routing.testStrategy).toBe("test-after");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// AC-3: Escalation still overwrites modelTier/testStrategy (not protected)
-// ---------------------------------------------------------------------------
-
-describe("routingStage - escalation overwrites modelTier even after persistence", () => {
-  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
-
-  afterEach(() => {
-    mock.restore();
-    if (origRoutingDeps) {
-      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
-      Object.assign(_routingDeps, origRoutingDeps);
-    }
-  });
-
-  test("uses escalated modelTier from story.routing when explicitly set", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    // Story has routing with escalated modelTier (set by handleTierEscalation)
-    const escalatedRouting: StoryRouting = {
-      complexity: "simple",
-      modelTier: "powerful", // escalated from "fast"
-      testStrategy: "three-session-tdd",
-      reasoning: "escalated",
-    };
-
-    _routingDeps.routeStory = mock(() =>
-      Promise.resolve({
-        complexity: "simple",
-        modelTier: "fast",
-        testStrategy: "test-after",
-        reasoning: "fresh",
-      }),
-    );
-    _routingDeps.complexityToModelTier = mock(() => "fast" as const);
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock(() => Promise.resolve());
-
-    const story = makeStory({ routing: escalatedRouting });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    // escalated modelTier must take priority (BUG-032)
-    expect(ctx.routing.modelTier).toBe("powerful");
-  });
-
-  test("savePRD is NOT called during escalation (routing already persisted)", async () => {
-    const { routingStage, _routingDeps } = await import(
-      "../../../../src/pipeline/stages/routing"
-    );
-
-    origRoutingDeps = { ..._routingDeps };
-
-    let savePRDCalled = false;
-
-    const escalatedRouting: StoryRouting = {
-      complexity: "simple",
-      modelTier: "powerful",
-      testStrategy: "three-session-tdd",
-      reasoning: "escalated",
-    };
-
-    _routingDeps.routeStory = mock(() =>
-      Promise.resolve({
-        complexity: "simple",
-        modelTier: "fast",
-        testStrategy: "test-after",
-        reasoning: "fresh",
-      }),
-    );
-    _routingDeps.complexityToModelTier = mock(() => "fast" as const);
-    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
-    _routingDeps.savePRD = mock(() => {
-      savePRDCalled = true;
-      return Promise.resolve();
-    });
-
-    const story = makeStory({ routing: escalatedRouting });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
-
-    // Routing already exists — no need to re-persist
-    expect(savePRDCalled).toBe(false);
-  });
-});

package/test/unit/pipeline/stages/verify.test.ts

@@ -1,267 +0,0 @@
-// RE-ARCH: keep
-/**
- * Verify Stage — per-story regression gate skipping (US-003)
- *
- * When regressionGate.mode is 'deferred', the verify stage must skip
- * calling regression() for each story and return { action: "continue" }.
- * The full-suite regression runs once at the end in run-completion.ts.
- *
- * These tests FAIL until verify.ts checks regressionGate.mode before
- * calling _verifyDeps.regression().
- */
-
-import { afterEach, describe, expect, mock, test } from "bun:test";
-import type { NaxConfig } from "../../../../src/config";
-import type { PRD, UserStory } from "../../../../src/prd";
-import { DEFAULT_CONFIG } from "../../../../src/config/defaults";
-import type { VerificationResult } from "../../../../src/verification";
-
-// ---------------------------------------------------------------------------
-// Test helpers
-// ---------------------------------------------------------------------------
-
-function makeStory(overrides?: Partial<UserStory>): UserStory {
-  return {
-    id: "US-001",
-    title: "Test Story",
-    description: "Test",
-    acceptanceCriteria: [],
-    tags: [],
-    dependencies: [],
-    status: "in-progress",
-    passes: false,
-    escalations: [],
-    attempts: 1,
-    ...overrides,
-  };
-}
-
-function makePRD(): PRD {
-  return {
-    project: "test",
-    feature: "test-feature",
-    branchName: "test-branch",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    userStories: [makeStory()],
-  };
-}
-
-function makeConfig(
-  regressionMode?: "deferred" | "per-story" | "disabled",
-): NaxConfig {
-  return {
-    ...DEFAULT_CONFIG,
-    quality: {
-      ...DEFAULT_CONFIG.quality,
-      requireTests: true,
-      commands: { test: "bun test" },
-    },
-    execution: {
-      ...DEFAULT_CONFIG.execution,
-      verificationTimeoutSeconds: 30,
-      regressionGate: {
-        enabled: true,
-        timeoutSeconds: 30,
-        acceptOnTimeout: true,
-        ...(regressionMode !== undefined ? { mode: regressionMode } : {}),
-      },
-    },
-  };
-}
-
-function makeContext(regressionMode?: "deferred" | "per-story" | "disabled") {
-  const story = makeStory();
-  return {
-    config: makeConfig(regressionMode),
-    prd: makePRD(),
-    story,
-    stories: [story],
-    routing: {
-      complexity: "simple" as const,
-      modelTier: "fast" as const,
-      testStrategy: "test-after" as const,
-      reasoning: "test",
-    },
-    workdir: "/tmp/nax-test-verify",
-    hooks: { hooks: {} },
-  };
-}
-
-const SUCCESS_RESULT: VerificationResult = {
-  status: "SUCCESS",
-  success: true,
-  countsTowardEscalation: true,
-};
-
-// ---------------------------------------------------------------------------
-// Per-story regression gate skipping
-// ---------------------------------------------------------------------------
-
-describe("verifyStage - deferred mode skips per-story regression", () => {
-  afterEach(() => {
-    mock.restore();
-  });
-
-  test("does not call regression() when mode is 'deferred'", async () => {
-    const { verifyStage, _verifyDeps } = await import(
-      "../../../../src/pipeline/stages/verify"
-    );
-    const { _smartRunnerDeps } = await import(
-      "../../../../src/verification/smart-runner"
-    );
-
-    let regressionCalled = false;
-    const origRegression = _verifyDeps.regression;
-    const origGetChanged = _smartRunnerDeps.getChangedSourceFiles;
-    const origMapSource = _smartRunnerDeps.mapSourceToTests;
-
-    _smartRunnerDeps.getChangedSourceFiles = mock(() => Promise.resolve([]));
-    _smartRunnerDeps.mapSourceToTests = mock(() => Promise.resolve([]));
-    _verifyDeps.regression = mock((): Promise<VerificationResult> => {
-      regressionCalled = true;
-      return Promise.resolve(SUCCESS_RESULT);
-    });
-
-    try {
-      const ctx = makeContext("deferred");
-      const result = await verifyStage.execute(ctx as Parameters<typeof verifyStage.execute>[0]);
-
-      expect(regressionCalled).toBe(false);
-      expect(result.action).toBe("continue");
-    } finally {
-      _verifyDeps.regression = origRegression;
-      _smartRunnerDeps.getChangedSourceFiles = origGetChanged;
-      _smartRunnerDeps.mapSourceToTests = origMapSource;
-    }
-  });
-
-  test("does not call regression() when mode is unset (defaults to deferred)", async () => {
-    const { verifyStage, _verifyDeps } = await import(
-      "../../../../src/pipeline/stages/verify"
-    );
-    const { _smartRunnerDeps } = await import(
-      "../../../../src/verification/smart-runner"
-    );
-
-    let regressionCalled = false;
-    const origRegression = _verifyDeps.regression;
-    const origGetChanged = _smartRunnerDeps.getChangedSourceFiles;
-    const origMapSource = _smartRunnerDeps.mapSourceToTests;
-
-    _smartRunnerDeps.getChangedSourceFiles = mock(() => Promise.resolve([]));
-    _smartRunnerDeps.mapSourceToTests = mock(() => Promise.resolve([]));
-    _verifyDeps.regression = mock((): Promise<VerificationResult> => {
-      regressionCalled = true;
-      return Promise.resolve(SUCCESS_RESULT);
-    });
-
-    try {
-      // No mode → defaults to 'deferred'
-      const ctx = makeContext(undefined);
-      const result = await verifyStage.execute(ctx as Parameters<typeof verifyStage.execute>[0]);
-
-      expect(regressionCalled).toBe(false);
-      expect(result.action).toBe("continue");
-    } finally {
-      _verifyDeps.regression = origRegression;
-      _smartRunnerDeps.getChangedSourceFiles = origGetChanged;
-      _smartRunnerDeps.mapSourceToTests = origMapSource;
-    }
-  });
-
-  test("still calls regression() when mode is 'per-story'", async () => {
-    const { verifyStage, _verifyDeps } = await import(
-      "../../../../src/pipeline/stages/verify"
-    );
-    const { _smartRunnerDeps } = await import(
-      "../../../../src/verification/smart-runner"
-    );
-
-    let regressionCalled = false;
-    const origRegression = _verifyDeps.regression;
-    const origGetChanged = _smartRunnerDeps.getChangedSourceFiles;
-    const origMapSource = _smartRunnerDeps.mapSourceToTests;
-
-    _smartRunnerDeps.getChangedSourceFiles = mock(() => Promise.resolve([]));
-    _smartRunnerDeps.mapSourceToTests = mock(() => Promise.resolve([]));
-    _verifyDeps.regression = mock((): Promise<VerificationResult> => {
-      regressionCalled = true;
-      return Promise.resolve(SUCCESS_RESULT);
-    });
-
-    try {
-      const ctx = makeContext("per-story");
-      await verifyStage.execute(ctx as Parameters<typeof verifyStage.execute>[0]);
-
-      expect(regressionCalled).toBe(true);
-    } finally {
-      _verifyDeps.regression = origRegression;
-      _smartRunnerDeps.getChangedSourceFiles = origGetChanged;
-      _smartRunnerDeps.mapSourceToTests = origMapSource;
-    }
-  });
-
-  test("still calls regression() when mode is 'disabled' (disabled = deferred gate disabled, not per-story)", async () => {
-    const { verifyStage, _verifyDeps } = await import(
-      "../../../../src/pipeline/stages/verify"
-    );
-    const { _smartRunnerDeps } = await import(
-      "../../../../src/verification/smart-runner"
-    );
-
-    let regressionCalled = false;
-    const origRegression = _verifyDeps.regression;
-    const origGetChanged = _smartRunnerDeps.getChangedSourceFiles;
-    const origMapSource = _smartRunnerDeps.mapSourceToTests;
-
-    _smartRunnerDeps.getChangedSourceFiles = mock(() => Promise.resolve([]));
-    _smartRunnerDeps.mapSourceToTests = mock(() => Promise.resolve([]));
-    _verifyDeps.regression = mock((): Promise<VerificationResult> => {
-      regressionCalled = true;
-      return Promise.resolve(SUCCESS_RESULT);
-    });
-
-    try {
-      const ctx = makeContext("disabled");
-      await verifyStage.execute(ctx as Parameters<typeof verifyStage.execute>[0]);
-
-      expect(regressionCalled).toBe(true);
-    } finally {
-      _verifyDeps.regression = origRegression;
-      _smartRunnerDeps.getChangedSourceFiles = origGetChanged;
-      _smartRunnerDeps.mapSourceToTests = origMapSource;
-    }
-  });
-
-  test("deferred mode returns continue even without running any tests", async () => {
-    const { verifyStage, _verifyDeps } = await import(
-      "../../../../src/pipeline/stages/verify"
-    );
-    const { _smartRunnerDeps } = await import(
-      "../../../../src/verification/smart-runner"
-    );
-
-    const origRegression = _verifyDeps.regression;
-    const origGetChanged = _smartRunnerDeps.getChangedSourceFiles;
-    const origMapSource = _smartRunnerDeps.mapSourceToTests;
-
-    _smartRunnerDeps.getChangedSourceFiles = mock(() => Promise.resolve([]));
-    _smartRunnerDeps.mapSourceToTests = mock(() => Promise.resolve([]));
-    // regression throws to ensure it's truly not called
-    _verifyDeps.regression = mock((): Promise<VerificationResult> => {
-      throw new Error("regression() must not be called in deferred mode");
-    });
-
-    try {
-      const ctx = makeContext("deferred");
-      const result = await verifyStage.execute(ctx as Parameters<typeof verifyStage.execute>[0]);
-      // Should reach here without throwing
-      expect(result.action).toBe("continue");
-    } finally {
-      _verifyDeps.regression = origRegression;
-      _smartRunnerDeps.getChangedSourceFiles = origGetChanged;
-      _smartRunnerDeps.mapSourceToTests = origMapSource;
-    }
-  });
-});