@nathapp/nax 0.28.0 → 0.30.0

package/test/integration/context/context-verification-integration.test.ts

@@ -1,296 +0,0 @@
-// RE-ARCH: keep
-/**
- * Integration tests for contextFiles/expectedFiles split
- * Verifies that context builder and verification use the correct resolvers
- */
-
-import { describe, expect, test } from "bun:test";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { buildContext } from "../../../src/context/builder";
-import type { ContextBudget, StoryContext } from "../../../src/context/types";
-import { getContextFiles, getExpectedFiles } from "../../../src/prd";
-import type { PRD, UserStory } from "../../../src/prd";
-
-const createTestPRD = (stories: Partial<UserStory>[]): PRD => ({
-  project: "test-project",
-  feature: "test-feature",
-  branchName: "test-branch",
-  createdAt: new Date().toISOString(),
-  updatedAt: new Date().toISOString(),
-  userStories: stories.map((s, i) => ({
-    id: s.id || `US-${String(i + 1).padStart(3, "0")}`,
-    title: s.title || "Test Story",
-    description: s.description || "Test description",
-    acceptanceCriteria: s.acceptanceCriteria || ["AC1"],
-    dependencies: s.dependencies || [],
-    tags: s.tags || [],
-    status: s.status || "pending",
-    passes: s.passes ?? false,
-    escalations: s.escalations || [],
-    attempts: s.attempts || 0,
-    contextFiles: s.contextFiles,
-    expectedFiles: s.expectedFiles,
-    relevantFiles: s.relevantFiles,
-  })),
-});
-
-describe("Context and Verification Integration", () => {
-  test("story with contextFiles uses them for context injection", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-    try {
-      // Create test files
-      await fs.writeFile(path.join(tempDir, "src-file.ts"), 'export const src = "source";');
-      await fs.writeFile(path.join(tempDir, "dist-file.js"), 'const dist = "output";');
-
-      const prd = createTestPRD([
-        {
-          id: "US-001",
-          title: "Story with contextFiles",
-          description: "Test",
-          acceptanceCriteria: ["AC1"],
-          contextFiles: ["src-file.ts"], // Only for context
-          expectedFiles: ["dist-file.js"], // Only for verification
-        },
-      ]);
-
-      const storyContext: StoryContext = {
-        prd,
-        currentStoryId: "US-001",
-        workdir: tempDir,
-      };
-
-      const budget: ContextBudget = {
-        maxTokens: 10000,
-        reservedForInstructions: 1000,
-        availableForContext: 9000,
-      };
-
-      const built = await buildContext(storyContext, budget);
-
-      // Context should include src-file.ts (from contextFiles)
-      const fileElements = built.elements.filter((e) => e.type === "file");
-      expect(fileElements.length).toBe(1);
-      expect(fileElements[0].filePath).toBe("src-file.ts");
-      expect(fileElements[0].content).toContain("source");
-
-      // Context should NOT include dist-file.js (only in expectedFiles)
-      expect(fileElements.some((e) => e.filePath === "dist-file.js")).toBe(false);
-
-      // Verification should use expectedFiles
-      const story = prd.userStories[0];
-      const filesToVerify = getExpectedFiles(story);
-      expect(filesToVerify).toEqual(["dist-file.js"]);
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  test("story with relevantFiles uses them for context, not verification", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-    try {
-      await fs.writeFile(path.join(tempDir, "legacy.ts"), 'export const legacy = "old";');
-
-      const prd = createTestPRD([
-        {
-          id: "US-001",
-          title: "Legacy story",
-          description: "Test",
-          acceptanceCriteria: ["AC1"],
-          relevantFiles: ["legacy.ts"], // Backward compat
-        },
-      ]);
-
-      const storyContext: StoryContext = {
-        prd,
-        currentStoryId: "US-001",
-        workdir: tempDir,
-      };
-
-      const budget: ContextBudget = {
-        maxTokens: 10000,
-        reservedForInstructions: 1000,
-        availableForContext: 9000,
-      };
-
-      const built = await buildContext(storyContext, budget);
-
-      // Context should use relevantFiles as fallback
-      const contextFiles = getContextFiles(prd.userStories[0]);
-      expect(contextFiles).toEqual(["legacy.ts"]);
-
-      const fileElements = built.elements.filter((e) => e.type === "file");
-      expect(fileElements.length).toBe(1);
-      expect(fileElements[0].filePath).toBe("legacy.ts");
-
-      // Verification should NOT use relevantFiles (opt-in only)
-      const filesToVerify = getExpectedFiles(prd.userStories[0]);
-      expect(filesToVerify).toEqual([]);
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  test("story with no files specified should have empty context and verification", () => {
-    const prd = createTestPRD([
-      {
-        id: "US-001",
-        title: "Minimal story",
-        description: "Test",
-        acceptanceCriteria: ["AC1"],
-      },
-    ]);
-
-    const story = prd.userStories[0];
-
-    // Context should be empty
-    const contextFiles = getContextFiles(story);
-    expect(contextFiles).toEqual([]);
-
-    // Verification should be empty
-    const expectedFiles = getExpectedFiles(story);
-    expect(expectedFiles).toEqual([]);
-  });
-
-  test("story with contextFiles but no expectedFiles should skip verification", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-    try {
-      await fs.writeFile(path.join(tempDir, "helper.ts"), 'export const helper = "util";');
-
-      const prd = createTestPRD([
-        {
-          id: "US-001",
-          title: "Refactor story",
-          description: "Test",
-          acceptanceCriteria: ["AC1"],
-          contextFiles: ["helper.ts"], // For context only
-          // No expectedFiles - just modifying existing code
-        },
-      ]);
-
-      const storyContext: StoryContext = {
-        prd,
-        currentStoryId: "US-001",
-        workdir: tempDir,
-      };
-
-      const budget: ContextBudget = {
-        maxTokens: 10000,
-        reservedForInstructions: 1000,
-        availableForContext: 9000,
-      };
-
-      const built = await buildContext(storyContext, budget);
-
-      // Context should include helper.ts
-      const fileElements = built.elements.filter((e) => e.type === "file");
-      expect(fileElements.length).toBe(1);
-      expect(fileElements[0].filePath).toBe("helper.ts");
-
-      // Verification should be skipped (empty array)
-      const filesToVerify = getExpectedFiles(prd.userStories[0]);
-      expect(filesToVerify).toEqual([]);
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  test("story with both contextFiles and expectedFiles should use each correctly", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-    try {
-      await fs.writeFile(path.join(tempDir, "input.ts"), 'export const input = "in";');
-      await fs.writeFile(path.join(tempDir, "config.json"), '{"key": "value"}');
-      await fs.writeFile(path.join(tempDir, "output.js"), 'const output = "out";');
-
-      const prd = createTestPRD([
-        {
-          id: "US-001",
-          title: "Build story",
-          description: "Test",
-          acceptanceCriteria: ["AC1"],
-          contextFiles: ["input.ts", "config.json"], // For context
-          expectedFiles: ["output.js"], // For verification
-        },
-      ]);
-
-      const storyContext: StoryContext = {
-        prd,
-        currentStoryId: "US-001",
-        workdir: tempDir,
-      };
-
-      const budget: ContextBudget = {
-        maxTokens: 10000,
-        reservedForInstructions: 1000,
-        availableForContext: 9000,
-      };
-
-      const built = await buildContext(storyContext, budget);
-
-      // Context should include input.ts and config.json
-      const fileElements = built.elements.filter((e) => e.type === "file");
-      expect(fileElements.length).toBe(2);
-      expect(fileElements.some((e) => e.filePath === "input.ts")).toBe(true);
-      expect(fileElements.some((e) => e.filePath === "config.json")).toBe(true);
-
-      // Context should NOT include output.js (only in expectedFiles)
-      expect(fileElements.some((e) => e.filePath === "output.js")).toBe(false);
-
-      // Verification should only check output.js
-      const filesToVerify = getExpectedFiles(prd.userStories[0]);
-      expect(filesToVerify).toEqual(["output.js"]);
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  test("migration path: story with relevantFiles + new contextFiles should prefer contextFiles", async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-    try {
-      await fs.writeFile(path.join(tempDir, "new.ts"), 'export const newFile = "new";');
-      await fs.writeFile(path.join(tempDir, "old.ts"), 'export const oldFile = "old";');
-
-      const prd = createTestPRD([
-        {
-          id: "US-001",
-          title: "Migrated story",
-          description: "Test",
-          acceptanceCriteria: ["AC1"],
-          contextFiles: ["new.ts"], // New field
-          relevantFiles: ["old.ts"], // Deprecated field (kept for backward compat)
-        },
-      ]);
-
-      const storyContext: StoryContext = {
-        prd,
-        currentStoryId: "US-001",
-        workdir: tempDir,
-      };
-
-      const budget: ContextBudget = {
-        maxTokens: 10000,
-        reservedForInstructions: 1000,
-        availableForContext: 9000,
-      };
-
-      const built = await buildContext(storyContext, budget);
-
-      // Context should prefer contextFiles over relevantFiles
-      const fileElements = built.elements.filter((e) => e.type === "file");
-      expect(fileElements.length).toBe(1);
-      expect(fileElements[0].filePath).toBe("new.ts");
-      expect(fileElements[0].content).toContain("newFile");
-
-      // Old file should not be loaded
-      expect(fileElements.some((e) => e.filePath === "old.ts")).toBe(false);
-    } finally {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    }
-  });
-});

package/test/integration/context/s5-greenfield-fallback.test.ts

@@ -1,298 +0,0 @@
-// RE-ARCH: keep
-/**
- * S5: Strategy Fallback Tests
- *
- * Tests for greenfield-no-tests → test-after strategy switch.
- *
- * When a story fails with greenfield-no-tests failure category,
- * it should switch to test-after strategy (once) instead of escalating tier.
- */
-
-import { describe, expect, test } from "bun:test";
-import { resolveMaxAttemptsOutcome } from "../../../src/execution/runner";
-import type { UserStory } from "../../../src/prd";
-import type { FailureCategory } from "../../../src/tdd/types";
-
-describe("S5: greenfield-no-tests fallback", () => {
-  /**
-   * Simulates the escalation routing logic from runner.ts for test-after switch.
-   * This mirrors the exact transform applied when greenfield-no-tests fires.
-   */
-  function applyGreenfieldFallbackRouting(
-    story: UserStory,
-    escalateFailureCategory: FailureCategory | undefined,
-    nextTier: "fast" | "balanced" | "powerful",
-  ): { routing: UserStory["routing"]; attempts: number } {
-    const escalateRetryAsTestAfter = escalateFailureCategory === "greenfield-no-tests";
-    const currentTestStrategy = story.routing?.testStrategy ?? "test-after";
-    const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after";
-
-    const updatedRouting = story.routing
-      ? {
-          ...story.routing,
-          modelTier: shouldSwitchToTestAfter ? story.routing.modelTier : nextTier,
-          ...(shouldSwitchToTestAfter ? { testStrategy: "test-after" as const } : {}),
-        }
-      : undefined;
-
-    const shouldResetAttempts = shouldSwitchToTestAfter || story.routing?.modelTier !== nextTier;
-
-    return {
-      routing: updatedRouting,
-      attempts: shouldResetAttempts ? 0 : (story.attempts ?? 0) + 1,
-    };
-  }
-
-  describe("AC1: greenfield-no-tests switches to test-after on first occurrence", () => {
-    test("story on three-session-tdd switches to test-after and resets attempts", () => {
-      const story: UserStory = {
-        id: "US-001",
-        title: "Greenfield Story",
-        description: "Story with no existing tests",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 2,
-        routing: {
-          complexity: "complex",
-          modelTier: "fast",
-          testStrategy: "three-session-tdd",
-          reasoning: "complex",
-        },
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, "greenfield-no-tests", "balanced");
-
-      // Should switch to test-after WITHOUT escalating tier
-      expect(routing?.testStrategy).toBe("test-after");
-      expect(routing?.modelTier).toBe("fast"); // Tier stays the same
-      expect(attempts).toBe(0); // Attempts reset on strategy switch
-    });
-
-    test("story on three-session-tdd-lite switches to test-after", () => {
-      const story: UserStory = {
-        id: "US-002",
-        title: "Lite TDD Story",
-        description: "Story using lite mode",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 3,
-        routing: {
-          complexity: "complex",
-          modelTier: "balanced",
-          testStrategy: "three-session-tdd-lite",
-          reasoning: "complex",
-        },
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, "greenfield-no-tests", "powerful");
-
-      expect(routing?.testStrategy).toBe("test-after");
-      expect(routing?.modelTier).toBe("balanced"); // Tier stays the same
-      expect(attempts).toBe(0); // Attempts reset
-    });
-  });
-
-  describe("AC2: greenfield-no-tests on test-after proceeds with normal escalation", () => {
-    test("story already on test-after escalates tier normally", () => {
-      const story: UserStory = {
-        id: "US-003",
-        title: "Test-after Story",
-        description: "Story already using test-after",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 4,
-        routing: {
-          complexity: "simple",
-          modelTier: "fast",
-          testStrategy: "test-after",
-          reasoning: "simple",
-        },
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, "greenfield-no-tests", "balanced");
-
-      // Should NOT switch strategy (already test-after)
-      expect(routing?.testStrategy).toBe("test-after");
-      // Should escalate tier normally
-      expect(routing?.modelTier).toBe("balanced");
-      // Attempts reset on tier escalation
-      expect(attempts).toBe(0);
-    });
-
-    test("greenfield-no-tests fires twice on same story (second time escalates)", () => {
-      // First occurrence: three-session-tdd → test-after
-      let story: UserStory = {
-        id: "US-004",
-        title: "Double Greenfield",
-        description: "Story that triggers greenfield twice",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 2,
-        routing: {
-          complexity: "complex",
-          modelTier: "fast",
-          testStrategy: "three-session-tdd",
-          reasoning: "complex",
-        },
-      };
-
-      // First greenfield-no-tests: switch to test-after
-      let result = applyGreenfieldFallbackRouting(story, "greenfield-no-tests", "balanced");
-      story = {
-        ...story,
-        attempts: result.attempts,
-        routing: result.routing,
-      };
-
-      expect(story.routing?.testStrategy).toBe("test-after");
-      expect(story.routing?.modelTier).toBe("fast");
-      expect(story.attempts).toBe(0);
-
-      // Second greenfield-no-tests: already on test-after, escalate tier
-      result = applyGreenfieldFallbackRouting(story, "greenfield-no-tests", "balanced");
-      story = {
-        ...story,
-        attempts: result.attempts,
-        routing: result.routing,
-      };
-
-      expect(story.routing?.testStrategy).toBe("test-after"); // Stays test-after
-      expect(story.routing?.modelTier).toBe("balanced"); // Tier escalates
-      expect(story.attempts).toBe(0); // Attempts reset on tier change
-    });
-  });
-
-  describe("resolveMaxAttemptsOutcome for greenfield-no-tests", () => {
-    test("greenfield-no-tests returns pause (requires human review)", () => {
-      const result = resolveMaxAttemptsOutcome("greenfield-no-tests");
-      expect(result).toBe("pause");
-    });
-
-    test("greenfield-no-tests pauses only when max attempts exhausted", () => {
-      // This test documents that pause only happens AFTER the one-time switch
-      // When canEscalate=false (max attempts reached), resolveMaxAttemptsOutcome fires
-      const result = resolveMaxAttemptsOutcome("greenfield-no-tests");
-      expect(result).toBe("pause");
-    });
-  });
-
-  describe("non-greenfield-no-tests categories behave normally", () => {
-    test("isolation-violation does NOT trigger test-after switch", () => {
-      const story: UserStory = {
-        id: "US-005",
-        title: "Isolation Violation",
-        description: "Story with isolation issue",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 2,
-        routing: {
-          complexity: "complex",
-          modelTier: "fast",
-          testStrategy: "three-session-tdd",
-          reasoning: "complex",
-        },
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, "isolation-violation", "balanced");
-
-      // Should NOT switch to test-after (different failure category)
-      expect(routing?.testStrategy).toBe("three-session-tdd");
-      // Should escalate tier normally
-      expect(routing?.modelTier).toBe("balanced");
-    });
-
-    test("tests-failing does NOT trigger test-after switch", () => {
-      const story: UserStory = {
-        id: "US-006",
-        title: "Tests Failing",
-        description: "Story with failing tests",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 3,
-        routing: {
-          complexity: "complex",
-          modelTier: "fast",
-          testStrategy: "three-session-tdd",
-          reasoning: "complex",
-        },
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, "tests-failing", "balanced");
-
-      expect(routing?.testStrategy).toBe("three-session-tdd");
-      expect(routing?.modelTier).toBe("balanced");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("story without routing field handles switch gracefully", () => {
-      const story: UserStory = {
-        id: "US-007",
-        title: "No Routing",
-        description: "Story without routing",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 1,
-        routing: undefined,
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, "greenfield-no-tests", "balanced");
-
-      expect(routing).toBeUndefined();
-    });
-
-    test("undefined failure category does NOT trigger test-after switch", () => {
-      const story: UserStory = {
-        id: "US-008",
-        title: "No Category",
-        description: "Story with no failure category",
-        acceptanceCriteria: ["AC1"],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 2,
-        routing: {
-          complexity: "complex",
-          modelTier: "fast",
-          testStrategy: "three-session-tdd",
-          reasoning: "complex",
-        },
-      };
-
-      const { routing, attempts } = applyGreenfieldFallbackRouting(story, undefined, "balanced");
-
-      expect(routing?.testStrategy).toBe("three-session-tdd");
-      expect(routing?.modelTier).toBe("balanced");
-    });
-  });
-});