@nathapp/nax 0.18.1

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

@@ -0,0 +1,297 @@
+/**
+ * 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");
+    });
+  });
+});

package/test/integration/status-file-integration.test.ts

@@ -0,0 +1,325 @@
+/**
+ * Integration Tests: Status File — runner + CLI (T2)
+ *
+ * Verifies:
+ * - RunOptions.statusFile?: string exists
+ * - Status file written at all 4 write points (dry-run path)
+ * - Status file NOT written when statusFile omitted
+ * - Valid JSON at each stage, NaxStatusFile schema correct
+ * - completed status, progress counts, null current at end
+ * - --status-file CLI option wiring (type-level)
+ */
+
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
+import * as nodeFs from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ALL_AGENTS } from "../../src/agents/registry";
+import type {
+  AgentAdapter,
+  AgentCapabilities,
+  AgentResult,
+  AgentRunOptions,
+  DecomposeOptions,
+  DecomposeResult,
+  PlanOptions,
+  PlanResult,
+} from "../../src/agents/types";
+import { DEFAULT_CONFIG } from "../../src/config";
+import type { NaxConfig } from "../../src/config";
+import { run } from "../../src/execution/runner";
+import type { RunOptions } from "../../src/execution/runner";
+import type { NaxStatusFile } from "../../src/execution/status-file";
+import type { PRD } from "../../src/prd/types";
+
+// ============================================================================
+// Mock agent (satisfies agent installation check in runner)
+// ============================================================================
+class MockAgentAdapter implements AgentAdapter {
+  readonly name = "mock";
+  readonly displayName = "Mock Agent";
+  readonly binary = "mock-agent";
+  readonly capabilities: AgentCapabilities = {
+    supportedTiers: ["fast", "balanced", "powerful"],
+    maxContextTokens: 200_000,
+    features: new Set(["tdd", "review", "refactor", "batch"]),
+  };
+  async isInstalled(): Promise<boolean> {
+    return true;
+  }
+  buildCommand(_o: AgentRunOptions): string[] {
+    return [this.binary];
+  }
+  async run(_o: AgentRunOptions): Promise<AgentResult> {
+    return { success: true, exitCode: 0, output: "", durationMs: 10, estimatedCost: 0 };
+  }
+  async plan(_o: PlanOptions): Promise<PlanResult> {
+    return { specContent: "# Feature\n", success: true };
+  }
+  async decompose(_o: DecomposeOptions): Promise<DecomposeResult> {
+    return { stories: [], success: true };
+  }
+}
+
+let cleanupAgent: () => void;
+beforeAll(() => {
+  const adapter = new MockAgentAdapter();
+  ALL_AGENTS.push(adapter);
+  cleanupAgent = () => {
+    const idx = ALL_AGENTS.findIndex((a) => a.name === "mock");
+    if (idx !== -1) ALL_AGENTS.splice(idx, 1);
+  };
+});
+afterAll(() => {
+  cleanupAgent?.();
+});
+
+// ============================================================================
+// Helpers
+// ============================================================================
+function createTestConfig(): NaxConfig {
+  return {
+    ...DEFAULT_CONFIG,
+    autoMode: { ...DEFAULT_CONFIG.autoMode, defaultAgent: "mock" },
+    execution: { ...DEFAULT_CONFIG.execution, maxIterations: 20, maxStoriesPerFeature: 500 },
+    review: { ...DEFAULT_CONFIG.review, enabled: false },
+    acceptance: { ...DEFAULT_CONFIG.acceptance, enabled: false },
+  };
+}
+
+function makePRD(feature: string, storyCount = 2): PRD {
+  return {
+    project: "test-project",
+    feature,
+    branchName: `feat/${feature}`,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: Array.from({ length: storyCount }, (_, i) => ({
+      id: `US-${String(i + 1).padStart(3, "0")}`,
+      title: `Story ${i + 1}`,
+      description: `Desc ${i + 1}`,
+      acceptanceCriteria: [`AC: works`],
+      tags: [],
+      dependencies: [],
+      status: "pending" as const,
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    })),
+  };
+}
+
+async function setupDir(feature: string, storyCount = 2) {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-sf-int-"));
+  const naxDir = path.join(tmpDir, "nax");
+  const featureDir = path.join(naxDir, "features", feature);
+  nodeFs.mkdirSync(path.join(featureDir, "runs"), { recursive: true });
+  const prdPath = path.join(featureDir, "prd.json");
+  await Bun.write(prdPath, JSON.stringify(makePRD(feature, storyCount), null, 2));
+  return { tmpDir, featureDir, prdPath };
+}
+
+async function runWithStatus(feature: string, storyCount = 1, extraOpts: Partial<RunOptions> = {}) {
+  const setup = await setupDir(feature, storyCount);
+  const statusFilePath = path.join(setup.tmpDir, "nax-status.json");
+  await run({
+    prdPath: setup.prdPath,
+    workdir: setup.tmpDir,
+    config: createTestConfig(),
+    hooks: { hooks: {} },
+    feature,
+    featureDir: setup.featureDir,
+    dryRun: true,
+    statusFile: statusFilePath,
+    skipPrecheck: true,
+    ...extraOpts,
+  });
+  return { setup, statusFilePath };
+}
+
+// ============================================================================
+// RunOptions type-level checks
+// ============================================================================
+describe("RunOptions.statusFile", () => {
+  it("is optional (can be omitted)", () => {
+    const opts: RunOptions = {
+      prdPath: "/tmp/prd.json",
+      workdir: "/tmp",
+      config: createTestConfig(),
+      hooks: { hooks: {} },
+      feature: "test",
+      dryRun: true,
+    };
+    expect(opts.statusFile).toBeUndefined();
+  });
+
+  it("accepts a string value", () => {
+    const opts: RunOptions = {
+      prdPath: "/tmp/prd.json",
+      workdir: "/tmp",
+      config: createTestConfig(),
+      hooks: { hooks: {} },
+      feature: "test",
+      dryRun: true,
+      statusFile: "/tmp/nax-status.json",
+    };
+    expect(opts.statusFile).toBe("/tmp/nax-status.json");
+  });
+});
+
+// ============================================================================
+// No status file when option omitted (regression test)
+// ============================================================================
+describe("status file not written when omitted", () => {
+  let tmpDir: string;
+  afterEach(async () => {
+    if (tmpDir) await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("does not create any .json file in tmpDir", async () => {
+    const setup = await setupDir("no-sf", 1);
+    tmpDir = setup.tmpDir;
+    const before = await fs.readdir(setup.tmpDir);
+
+    await run({
+      prdPath: setup.prdPath,
+      workdir: setup.tmpDir,
+      config: createTestConfig(),
+      hooks: { hooks: {} },
+      feature: "no-sf",
+      featureDir: setup.featureDir,
+      dryRun: true, // no statusFile
+      skipPrecheck: true,
+    });
+
+    const after = await fs.readdir(setup.tmpDir);
+    const newJson = after.filter((f) => f.endsWith(".json") && !before.includes(f));
+    expect(newJson).toHaveLength(0);
+  });
+});
+
+// ============================================================================
+// Status file written during dry-run
+// ============================================================================
+describe("status file written during dry-run", () => {
+  let tmpDir: string;
+  afterEach(async () => {
+    if (tmpDir) await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates the file", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-creates");
+    tmpDir = setup.tmpDir;
+    expect(nodeFs.existsSync(statusFilePath)).toBe(true);
+  });
+
+  it("produces valid JSON", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-valid-json");
+    tmpDir = setup.tmpDir;
+    expect(() => JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8"))).not.toThrow();
+  });
+
+  it("has correct NaxStatusFile schema (version, run, progress, cost, current, iterations, updatedAt, durationMs)", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-schema", 2);
+    tmpDir = setup.tmpDir;
+    const p = JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8")) as NaxStatusFile;
+    expect(p.version).toBe(1);
+    expect(typeof p.run.id).toBe("string");
+    expect(p.run.feature).toBe("sf-schema");
+    expect(typeof p.run.startedAt).toBe("string");
+    expect(p.run.dryRun).toBe(true);
+    expect(typeof p.progress.total).toBe("number");
+    expect(typeof p.progress.passed).toBe("number");
+    expect(typeof p.progress.pending).toBe("number");
+    expect(typeof p.cost.spent).toBe("number");
+    expect(typeof p.iterations).toBe("number");
+    expect(typeof p.updatedAt).toBe("string");
+    expect(typeof p.durationMs).toBe("number");
+  });
+
+  it("run.status is 'completed' when all stories pass", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-completed", 2);
+    tmpDir = setup.tmpDir;
+    const p = JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8")) as NaxStatusFile;
+    expect(p.run.status).toBe("completed");
+  });
+
+  it("progress.passed equals story count after dry-run", async () => {
+    const storyCount = 3;
+    const { setup, statusFilePath } = await runWithStatus("sf-progress", storyCount);
+    tmpDir = setup.tmpDir;
+    const p = JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8")) as NaxStatusFile;
+    expect(p.progress.total).toBe(storyCount);
+    expect(p.progress.passed).toBe(storyCount);
+    expect(p.progress.pending).toBe(0);
+  });
+
+  it("current is null at run end (write point 4)", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-current-null");
+    tmpDir = setup.tmpDir;
+    const p = JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8")) as NaxStatusFile;
+    expect(p.current).toBeNull();
+  });
+
+  it("no .tmp file left behind after write", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-no-tmp");
+    tmpDir = setup.tmpDir;
+    expect(nodeFs.existsSync(`${statusFilePath}.tmp`)).toBe(false);
+  });
+
+  it("run.id starts with 'run-'", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-runid");
+    tmpDir = setup.tmpDir;
+    const p = JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8")) as NaxStatusFile;
+    expect(p.run.id).toMatch(/^run-/);
+  });
+
+  it("cost.limit is null when config.costLimit is Infinity", async () => {
+    const setup = await setupDir("sf-cost-null", 1);
+    tmpDir = setup.tmpDir;
+    const statusFilePath = path.join(setup.tmpDir, "nax-status.json");
+    const config = createTestConfig();
+    config.execution.costLimit = Number.POSITIVE_INFINITY;
+    await run({
+      prdPath: setup.prdPath,
+      workdir: setup.tmpDir,
+      config,
+      hooks: { hooks: {} },
+      feature: "sf-cost-null",
+      featureDir: setup.featureDir,
+      dryRun: true,
+      statusFile: statusFilePath,
+      skipPrecheck: true,
+    });
+    const p = JSON.parse(nodeFs.readFileSync(statusFilePath, "utf-8")) as NaxStatusFile;
+    expect(p.cost.limit).toBeNull();
+  });
+});
+
+// ============================================================================
+// CLI --status-file wiring (type check only)
+// ============================================================================
+describe("CLI --status-file wiring", () => {
+  it("RunOptions.statusFile is passed through correctly", () => {
+    const withFile: RunOptions = {
+      prdPath: "/tmp/prd.json",
+      workdir: "/tmp",
+      config: createTestConfig(),
+      hooks: { hooks: {} },
+      feature: "test",
+      dryRun: false,
+      statusFile: "/tmp/status.json",
+    };
+    const withoutFile: RunOptions = {
+      prdPath: "/tmp/prd.json",
+      workdir: "/tmp",
+      config: createTestConfig(),
+      hooks: { hooks: {} },
+      feature: "test",
+      dryRun: false,
+    };
+    expect(withFile.statusFile).toBe("/tmp/status.json");
+    expect(withoutFile.statusFile).toBeUndefined();
+  });
+});