@nathapp/nax 0.28.0 → 0.29.0

package/test/unit/routing-strategies.test.ts

@@ -1,440 +0,0 @@
-// RE-ARCH: keep
-/**
- * Routing Tests
- *
- * Consolidated test suite for routing system including:
- * - Core routing logic (classifyComplexity, determineTestStrategy, routeTask)
- * - Routing strategies (keyword, llm, manual, adaptive)
- * - Strategy chain execution
- * - Async support and chain delegation
- */
-
-import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
-import { DEFAULT_CONFIG } from "../../src/config";
-import type { NaxConfig } from "../../src/config";
-import { escalateTier } from "../../src/execution/runner";
-import type { AggregateMetrics } from "../../src/metrics/types";
-import type { UserStory } from "../../src/prd/types";
-import { classifyComplexity, determineTestStrategy, routeTask } from "../../src/routing";
-import { buildStrategyChain } from "../../src/routing/builder";
-import { StrategyChain } from "../../src/routing/chain";
-import { keywordStrategy, llmStrategy, manualStrategy } from "../../src/routing/strategies";
-import { adaptiveStrategy } from "../../src/routing/strategies/adaptive";
-import {
-  buildBatchPrompt,
-  buildRoutingPrompt,
-  clearCache,
-  clearCacheForStory,
-  getCacheSize,
-  llmStrategy as llmStrategyFull,
-  parseRoutingResponse,
-  routeBatch,
-  stripCodeFences,
-  validateRoutingDecision,
-} from "../../src/routing/strategies/llm";
-import type { RoutingContext, RoutingDecision, RoutingStrategy } from "../../src/routing/strategy";
-
-
-const simpleStory: UserStory = {
-  id: "US-001",
-  title: "Fix typo in README",
-  description: "Correct spelling mistake",
-  acceptanceCriteria: ["Update README.md with correct spelling"],
-  tags: ["docs"],
-  dependencies: [],
-  status: "pending",
-  passes: false,
-};
-
-const complexStory: UserStory = {
-  id: "US-002",
-  title: "Add JWT authentication",
-  description: "Implement JWT authentication with refresh tokens",
-  acceptanceCriteria: ["Secure token storage", "Token refresh endpoint", "Expiry handling", "Logout functionality"],
-  tags: ["security", "auth"],
-  dependencies: [],
-  status: "pending",
-  passes: false,
-};
-
-const testContext: RoutingContext = {
-  config: DEFAULT_CONFIG,
-};
-
-describe("StrategyChain", () => {
-  test("uses first strategy that returns non-null", async () => {
-    const alwaysNullStrategy: RoutingStrategy = {
-      name: "always-null",
-      route: () => null,
-    };
-
-    const alwaysReturnStrategy: RoutingStrategy = {
-      name: "always-return",
-      route: () => ({
-        complexity: "simple",
-        modelTier: "fast",
-        testStrategy: "test-after",
-        reasoning: "Always return strategy",
-      }),
-    };
-
-    const chain = new StrategyChain([alwaysNullStrategy, alwaysReturnStrategy]);
-
-    const story: UserStory = {
-      id: "US-001",
-      title: "Test story",
-      description: "Test",
-      acceptanceCriteria: [],
-      tags: [],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-    const decision = await chain.route(story, context);
-
-    expect(decision.reasoning).toBe("Always return strategy");
-  });
-
-  test("throws error if all strategies return null", async () => {
-    const alwaysNullStrategy: RoutingStrategy = {
-      name: "always-null",
-      route: () => null,
-    };
-
-    const chain = new StrategyChain([alwaysNullStrategy]);
-
-    const story: UserStory = {
-      id: "US-001",
-      title: "Test story",
-      description: "Test",
-      acceptanceCriteria: [],
-      tags: [],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-
-    await expect(chain.route(story, context)).rejects.toThrow("No routing strategy returned a decision");
-  });
-
-  test("getStrategyNames returns strategy names", () => {
-    const chain = new StrategyChain([keywordStrategy, llmStrategy]);
-    expect(chain.getStrategyNames()).toEqual(["keyword", "llm"]);
-  });
-
-  describe("async support", () => {
-    test("handles async strategy that returns decision", async () => {
-      const asyncStrategy: RoutingStrategy = {
-        name: "async-test",
-        route: async () => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          return {
-            complexity: "medium",
-            modelTier: "balanced",
-            testStrategy: "test-after",
-            reasoning: "Async strategy result",
-          };
-        },
-      };
-
-      const chain = new StrategyChain([asyncStrategy]);
-
-      const story: UserStory = {
-        id: "US-001",
-        title: "Test async story",
-        description: "Test async routing",
-        acceptanceCriteria: [],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 0,
-      };
-
-      const context: RoutingContext = { config: DEFAULT_CONFIG };
-      const decision = await chain.route(story, context);
-
-      expect(decision.reasoning).toBe("Async strategy result");
-      expect(decision.complexity).toBe("medium");
-      expect(decision.modelTier).toBe("balanced");
-    });
-
-    test("handles mixed sync and async strategies", async () => {
-      const syncStrategy: RoutingStrategy = {
-        name: "sync-first",
-        route: () => null,
-      };
-
-      const asyncStrategy: RoutingStrategy = {
-        name: "async-second",
-        route: async () => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          return {
-            complexity: "complex",
-            modelTier: "powerful",
-            testStrategy: "three-session-tdd",
-            reasoning: "Mixed chain result",
-          };
-        },
-      };
-
-      const chain = new StrategyChain([syncStrategy, asyncStrategy]);
-
-      const story: UserStory = {
-        id: "US-003",
-        title: "Test mixed",
-        description: "Test mixed sync/async",
-        acceptanceCriteria: [],
-        tags: [],
-        dependencies: [],
-        status: "pending",
-        passes: false,
-        escalations: [],
-        attempts: 0,
-      };
-
-      const context: RoutingContext = { config: DEFAULT_CONFIG };
-      const decision = await chain.route(story, context);
-
-      expect(decision.reasoning).toBe("Mixed chain result");
-      expect(decision.testStrategy).toBe("three-session-tdd");
-    });
-  });
-});
-
-describe("keywordStrategy", () => {
-  test("classifies simple story correctly", () => {
-    const story: UserStory = {
-      id: "US-001",
-      title: "Update button color",
-      description: "Change button to blue",
-      acceptanceCriteria: ["Button is blue"],
-      tags: [],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-    const decision = keywordStrategy.route(story, context);
-
-    expect(decision).not.toBeNull();
-    expect(decision!.complexity).toBe("simple");
-    expect(decision!.modelTier).toBe("fast");
-    expect(decision!.testStrategy).toBe("test-after");
-  });
-
-  test("classifies complex story with security keywords", () => {
-    const story: UserStory = {
-      id: "US-002",
-      title: "Add JWT authentication",
-      description: "Implement JWT auth with refresh tokens",
-      acceptanceCriteria: ["Token storage", "Refresh logic", "Expiry"],
-      tags: ["security", "auth"],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-    const decision = keywordStrategy.route(story, context);
-
-    expect(decision).not.toBeNull();
-    expect(decision!.complexity).toBe("complex");
-    expect(decision!.modelTier).toBe("powerful");
-    expect(decision!.testStrategy).toBe("three-session-tdd");
-    expect(decision!.reasoning).toContain("security-critical");
-  });
-
-  test("uses three-session-tdd for public API", () => {
-    const story: UserStory = {
-      id: "US-005",
-      title: "Add public API endpoint",
-      description: "Create external API for consumers",
-      acceptanceCriteria: ["Endpoint returns JSON"],
-      tags: ["public api"],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-    const decision = keywordStrategy.route(story, context);
-
-    expect(decision).not.toBeNull();
-    expect(decision!.testStrategy).toBe("three-session-tdd");
-    expect(decision!.reasoning).toContain("public-api");
-  });
-});
-
-describe("manualStrategy", () => {
-  test("returns decision from story.routing metadata", () => {
-    const story: UserStory = {
-      id: "US-006",
-      title: "Manual override test",
-      description: "Story with manual routing",
-      acceptanceCriteria: [],
-      tags: [],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-      routing: {
-        complexity: "expert",
-        modelTier: "powerful",
-        testStrategy: "three-session-tdd",
-        reasoning: "Manual override for critical task",
-      },
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-    const decision = manualStrategy.route(story, context);
-
-    expect(decision).not.toBeNull();
-    expect(decision!.complexity).toBe("expert");
-    expect(decision!.modelTier).toBe("powerful");
-    expect(decision!.testStrategy).toBe("three-session-tdd");
-    expect(decision!.reasoning).toBe("Manual override for critical task");
-  });
-
-  test("returns null when no routing metadata", () => {
-    const story: UserStory = {
-      id: "US-007",
-      title: "No manual routing",
-      description: "Story without routing metadata",
-      acceptanceCriteria: [],
-      tags: [],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
-    const context: RoutingContext = { config: configWithoutLlm };
-    const decision = manualStrategy.route(story, context);
-
-    expect(decision).toBeNull();
-  });
-});
-
-describe("LLM Routing Strategy - Prompt Building", () => {
-  test("buildRoutingPrompt formats story correctly", () => {
-    const prompt = buildRoutingPrompt(simpleStory, DEFAULT_CONFIG);
-
-    expect(prompt).toContain("Title: Fix typo in README");
-    expect(prompt).toContain("Description: Correct spelling mistake");
-    expect(prompt).toContain("1. Update README.md with correct spelling");
-    expect(prompt).toContain("Tags: docs");
-    expect(prompt).toContain("fast: Simple changes");
-    expect(prompt).toContain("balanced: Standard features");
-    expect(prompt).toContain("powerful: Complex architecture");
-  });
-
-  test("buildBatchPrompt formats multiple stories", () => {
-    const stories = [simpleStory, complexStory];
-    const prompt = buildBatchPrompt(stories, DEFAULT_CONFIG);
-
-    expect(prompt).toContain("1. US-001: Fix typo in README");
-    expect(prompt).toContain("2. US-002: Add JWT authentication");
-    expect(prompt).toContain("Tags: docs");
-    expect(prompt).toContain("Tags: security, auth");
-    expect(prompt).toContain('{"id":"US-001"');
-  });
-});
-
-describe("LLM Routing Strategy - Response Parsing", () => {
-  test("parseRoutingResponse handles valid JSON", () => {
-    const output =
-      '{"complexity":"simple","modelTier":"fast","testStrategy":"test-after","reasoning":"Simple documentation fix"}';
-    const decision = parseRoutingResponse(output, simpleStory, DEFAULT_CONFIG);
-
-    expect(decision.complexity).toBe("simple");
-    expect(decision.modelTier).toBe("fast");
-    expect(decision.testStrategy).toBe("test-after");
-    expect(decision.reasoning).toBe("Simple documentation fix");
-  });
-
-  test("parseRoutingResponse strips markdown code blocks", () => {
-    const output =
-      '```json\n{"complexity":"complex","modelTier":"powerful","testStrategy":"three-session-tdd","reasoning":"Security-critical"}\n```';
-    const decision = parseRoutingResponse(output, complexStory, DEFAULT_CONFIG);
-
-    expect(decision.complexity).toBe("complex");
-    expect(decision.modelTier).toBe("powerful");
-    expect(decision.testStrategy).toBe("three-session-tdd");
-  });
-
-  test("parseRoutingResponse throws on invalid JSON", () => {
-    const output = "This is not JSON";
-    expect(() => parseRoutingResponse(output, simpleStory, DEFAULT_CONFIG)).toThrow();
-  });
-
-  test("parseRoutingResponse throws on missing fields", () => {
-    const output = '{"complexity":"simple","modelTier":"fast"}';
-    expect(() => parseRoutingResponse(output, simpleStory, DEFAULT_CONFIG)).toThrow("Missing required fields");
-  });
-});
-
-describe("stripCodeFences", () => {
-  test("returns plain JSON unchanged", () => {
-    const input = '{"complexity":"simple"}';
-    expect(stripCodeFences(input)).toBe('{"complexity":"simple"}');
-  });
-
-  test("strips ```json ... ``` fences", () => {
-    const input = '```json\n{"complexity":"simple"}\n```';
-    expect(stripCodeFences(input)).toBe('{"complexity":"simple"}');
-  });
-
-  test("strips leading 'json' keyword (no backticks)", () => {
-    const input = 'json\n{"complexity":"simple"}';
-    expect(stripCodeFences(input)).toBe('{"complexity":"simple"}');
-  });
-});
-
-describe("validateRoutingDecision", () => {
-  test("returns valid decision for correct input", () => {
-    const input = { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "trivial" };
-    const result = validateRoutingDecision(input, DEFAULT_CONFIG);
-    expect(result).toEqual({
-      complexity: "simple",
-      modelTier: "fast",
-      testStrategy: "test-after",
-      reasoning: "trivial",
-    });
-  });
-
-  test("throws on missing complexity", () => {
-    const input = { modelTier: "fast", testStrategy: "test-after", reasoning: "test" };
-    expect(() => validateRoutingDecision(input, DEFAULT_CONFIG)).toThrow("Missing required fields");
-  });
-
-  test("throws on invalid complexity value", () => {
-    const input = { complexity: "mega", modelTier: "fast", testStrategy: "test-after", reasoning: "test" };
-    expect(() => validateRoutingDecision(input, DEFAULT_CONFIG)).toThrow("Invalid complexity: mega");
-  });
-});

package/test/unit/storyid-events.test.ts

@@ -1,213 +0,0 @@
-// RE-ARCH: keep
-/**
- * BUG-020: Verify storyId is present in JSONL event logger calls.
- *
- * Tests three key stages: verify, execution, tdd orchestrator.
- * Uses mocks — does NOT spawn nax processes.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
-import type { NaxConfig } from "../../src/config";
-import { getLogger, initLogger, resetLogger } from "../../src/logger";
-import type { PipelineContext } from "../../src/pipeline/types";
-import type { UserStory } from "../../src/prd/types";
-
-// ── Static imports (uses _deps pattern — no mock.module() needed) ────────────
-
-import { verifyStage } from "../../src/pipeline/stages/verify";
-import { _executionDeps, executionStage } from "../../src/pipeline/stages/execution";
-import { runThreeSessionTdd } from "../../src/tdd/orchestrator";
-
-// ── Mock agent ────────────────────────────────────────────────────────────────
-
-const mockAgentRun = mock(async () => ({
-  success: true,
-  rateLimited: false,
-  estimatedCost: 0.01,
-  output: "done",
-  exitCode: 0,
-  durationMs: 100,
-}));
-
-const mockAgent = {
-  name: "claude",
-  // Only supports "balanced"/"powerful" — triggers tier mismatch when ctx.routing.modelTier="fast"
-  capabilities: { supportedTiers: ["balanced", "powerful"] },
-  run: mockAgentRun,
-  isInstalled: async () => true,
-  buildCommand: () => ["claude"],
-};
-
-// ── Capture originals for afterEach restoration ───────────────────────────────
-
-const _origExecutionDeps = { ..._executionDeps };
-
-// ── Shared fixtures ───────────────────────────────────────────────────────────
-
-const STORY_ID = "story-bug020-test";
-
-const mockStory: UserStory = {
-  id: STORY_ID,
-  title: "Test story for BUG-020",
-  description: "Verifies storyId appears in event payloads",
-  acceptanceCriteria: [],
-  status: "pending",
-};
-
-/**
- * Build a minimal PipelineContext with configurable quality overrides.
- */
-function makeCtx(
-  qualityOverrides: Partial<{ requireTests: boolean; testCommand: string | undefined }> = {},
-): PipelineContext {
-  const { requireTests = false, testCommand = undefined } = qualityOverrides;
-  return {
-    config: {
-      quality: {
-        requireTests,
-        commands: { test: testCommand },
-      },
-      review: undefined,
-      execution: {
-        sessionTimeoutSeconds: 60,
-        verificationTimeoutSeconds: 60,
-        dangerouslySkipPermissions: false,
-        costLimit: 10,
-        maxIterations: 50,
-        iterationDelayMs: 0,
-      },
-      models: {
-        fast: "claude-3-haiku-20240307",
-        balanced: "claude-3-5-sonnet-20241022",
-        powerful: "claude-opus-4-20250514",
-      },
-      autoMode: { defaultAgent: "claude" },
-      tdd: { rollbackOnFailure: false },
-      routing: { strategy: "complexity", llm: { mode: "per-story" } },
-    } as unknown as NaxConfig,
-    story: mockStory,
-    stories: [mockStory],
-    routing: {
-      complexity: "simple",
-      modelTier: "fast",
-      testStrategy: "test-after",
-      reasoning: "test fixture",
-    },
-    workdir: "/tmp/nax-test-storyid",
-    prd: { feature: "test", userStories: [mockStory] },
-    hooks: {} as any,
-  } as PipelineContext;
-}
-
-// ── Logger lifecycle ──────────────────────────────────────────────────────────
-
-beforeEach(() => {
-  _executionDeps.getAgent = () => mockAgent as any;
-  resetLogger();
-  initLogger({ level: "debug", useChalk: false });
-  mockAgentRun.mockClear();
-});
-
-afterEach(() => {
-  Object.assign(_executionDeps, _origExecutionDeps);
-  mock.restore();
-  resetLogger();
-});
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe("BUG-020: storyId in JSONL event payloads", () => {
-  // ── Verify stage ────────────────────────────────────────────────────────────
-
-  describe("verify stage", () => {
-    test("skip log (requireTests=false) includes storyId", async () => {
-      const logger = getLogger();
-      const debugSpy = spyOn(logger, "debug").mockImplementation(() => {});
-
-      const ctx = makeCtx({ requireTests: false });
-      await verifyStage.execute(ctx);
-
-      const call = debugSpy.mock.calls.find(
-        ([, msg]) => msg === "Skipping verification (quality.requireTests = false)",
-      );
-      expect(call).toBeDefined();
-      expect(call![2]).toEqual(expect.objectContaining({ storyId: STORY_ID }));
-    });
-
-    test("skip log (no test command) includes storyId", async () => {
-      const logger = getLogger();
-      const debugSpy = spyOn(logger, "debug").mockImplementation(() => {});
-
-      const ctx = makeCtx({ requireTests: true, testCommand: undefined });
-      await verifyStage.execute(ctx);
-
-      const call = debugSpy.mock.calls.find(
-        ([, msg]) => msg === "Skipping verification (no test command configured)",
-      );
-      expect(call).toBeDefined();
-      expect(call![2]).toEqual(expect.objectContaining({ storyId: STORY_ID }));
-    });
-  });
-
-  // ── Execution stage ─────────────────────────────────────────────────────────
-
-  describe("execution stage", () => {
-    test("agent tier mismatch warn includes storyId", async () => {
-      const logger = getLogger();
-      const warnSpy = spyOn(logger, "warn").mockImplementation(() => {});
-      spyOn(logger, "info").mockImplementation(() => {});
-      spyOn(logger, "error").mockImplementation(() => {});
-
-      const ctx = makeCtx();
-      ctx.prompt = "implement the feature";
-      await executionStage.execute(ctx);
-
-      const call = warnSpy.mock.calls.find(([, msg]) => msg === "Agent tier mismatch");
-      expect(call).toBeDefined();
-      expect(call![2]).toEqual(
-        expect.objectContaining({
-          storyId: STORY_ID,
-          agentName: "claude",
-          requestedTier: "fast",
-        }),
-      );
-    });
-  });
-
-  // ── TDD orchestrator ────────────────────────────────────────────────────────
-
-  describe("tdd orchestrator", () => {
-    test("dry-run info log includes storyId", async () => {
-      const logger = getLogger();
-      const infoSpy = spyOn(logger, "info").mockImplementation(() => {});
-
-      const mockAgent = {
-        name: "dry-run-agent",
-        capabilities: { supportedTiers: ["fast"] },
-        run: mock(async () => ({
-          success: true,
-          rateLimited: false,
-          estimatedCost: 0,
-          output: "",
-          exitCode: 0,
-          durationMs: 0,
-        })),
-      };
-
-      await runThreeSessionTdd({
-        agent: mockAgent as any,
-        story: mockStory,
-        config: makeCtx().config,
-        workdir: "/tmp/nax-test-storyid",
-        modelTier: "fast",
-        dryRun: true,
-      });
-
-      const dryRunCall = infoSpy.mock.calls.find(
-        ([, msg]) => msg === "[DRY RUN] Would run 3-session TDD",
-      );
-      expect(dryRunCall).toBeDefined();
-      expect(dryRunCall![2]).toEqual(expect.objectContaining({ storyId: STORY_ID }));
-    });
-  });
-});