@nathapp/nax 0.18.1

package/test/unit/merge.test.ts

@@ -0,0 +1,268 @@
+/**
+ * Tests for src/worktree/merge.ts
+ *
+ * Covers: MergeEngine topological sort and merge logic
+ */
+
+import { describe, expect, it } from "bun:test";
+import { MergeEngine } from "../../src/worktree/merge";
+import type { StoryDependencies } from "../../src/worktree/merge";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Test fixtures
+// ─────────────────────────────────────────────────────────────────────────────
+
+const mockWorktreeManager = {
+  create: async () => {},
+  remove: async () => {},
+  list: async () => [],
+} as any;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// MergeEngine.topologicalSort
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("MergeEngine.topologicalSort", () => {
+  it("sorts stories with no dependencies", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001", "US-002", "US-003"];
+    const dependencies: StoryDependencies = {};
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted.length).toBe(3);
+    expect(sorted).toContain("US-001");
+    expect(sorted).toContain("US-002");
+    expect(sorted).toContain("US-003");
+  });
+
+  it("sorts stories with simple linear dependencies", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001", "US-002", "US-003"];
+    const dependencies: StoryDependencies = {
+      "US-002": ["US-001"],
+      "US-003": ["US-002"],
+    };
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted).toEqual(["US-001", "US-002", "US-003"]);
+  });
+
+  it("sorts stories with multiple dependencies", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001", "US-002", "US-003", "US-004"];
+    const dependencies: StoryDependencies = {
+      "US-003": ["US-001", "US-002"],
+      "US-004": ["US-002"],
+    };
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted.length).toBe(4);
+
+    // US-001 and US-002 must come before US-003
+    const idx001 = sorted.indexOf("US-001");
+    const idx002 = sorted.indexOf("US-002");
+    const idx003 = sorted.indexOf("US-003");
+    expect(idx001).toBeLessThan(idx003);
+    expect(idx002).toBeLessThan(idx003);
+
+    // US-002 must come before US-004
+    const idx004 = sorted.indexOf("US-004");
+    expect(idx002).toBeLessThan(idx004);
+  });
+
+  it("handles diamond dependency pattern", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001", "US-002", "US-003", "US-004"];
+    const dependencies: StoryDependencies = {
+      "US-002": ["US-001"],
+      "US-003": ["US-001"],
+      "US-004": ["US-002", "US-003"],
+    };
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted.length).toBe(4);
+
+    // US-001 must come first
+    expect(sorted[0]).toBe("US-001");
+
+    // US-002 and US-003 must come before US-004
+    const idx002 = sorted.indexOf("US-002");
+    const idx003 = sorted.indexOf("US-003");
+    const idx004 = sorted.indexOf("US-004");
+    expect(idx002).toBeLessThan(idx004);
+    expect(idx003).toBeLessThan(idx004);
+  });
+
+  it("throws on circular dependency", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001", "US-002", "US-003"];
+    const dependencies: StoryDependencies = {
+      "US-001": ["US-003"],
+      "US-002": ["US-001"],
+      "US-003": ["US-002"],
+    };
+
+    expect(() => {
+      // @ts-expect-error - accessing private method for testing
+      engine.topologicalSort(storyIds, dependencies);
+    }).toThrow("Circular dependency detected");
+  });
+
+  it("handles self-circular dependency", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001"];
+    const dependencies: StoryDependencies = {
+      "US-001": ["US-001"],
+    };
+
+    expect(() => {
+      // @ts-expect-error - accessing private method for testing
+      engine.topologicalSort(storyIds, dependencies);
+    }).toThrow("Circular dependency detected");
+  });
+
+  it("ignores dependencies not in storyIds list", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-002", "US-003"];
+    const dependencies: StoryDependencies = {
+      "US-002": ["US-001"], // US-001 not in storyIds
+      "US-003": ["US-002"],
+    };
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    // Should sort US-002 before US-003, ignoring missing US-001
+    expect(sorted).toEqual(["US-002", "US-003"]);
+  });
+
+  it("handles complex dependency graph", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001", "US-002", "US-003", "US-004", "US-005"];
+    const dependencies: StoryDependencies = {
+      "US-002": ["US-001"],
+      "US-003": ["US-001"],
+      "US-004": ["US-002", "US-003"],
+      "US-005": ["US-003"],
+    };
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted.length).toBe(5);
+    expect(sorted[0]).toBe("US-001");
+
+    const idx002 = sorted.indexOf("US-002");
+    const idx003 = sorted.indexOf("US-003");
+    const idx004 = sorted.indexOf("US-004");
+    const idx005 = sorted.indexOf("US-005");
+
+    expect(idx002).toBeGreaterThan(0);
+    expect(idx003).toBeGreaterThan(0);
+    expect(idx002).toBeLessThan(idx004);
+    expect(idx003).toBeLessThan(idx004);
+    expect(idx003).toBeLessThan(idx005);
+  });
+
+  it("handles empty story list", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds: string[] = [];
+    const dependencies: StoryDependencies = {};
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted.length).toBe(0);
+  });
+
+  it("handles single story", () => {
+    const engine = new MergeEngine(mockWorktreeManager);
+    const storyIds = ["US-001"];
+    const dependencies: StoryDependencies = {};
+
+    // @ts-expect-error - accessing private method for testing
+    const sorted = engine.topologicalSort(storyIds, dependencies);
+
+    expect(sorted).toEqual(["US-001"]);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// MergeEngine.mergeAll
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("MergeEngine.mergeAll", () => {
+  it("skips stories with failed dependencies", async () => {
+    const mockManager = {
+      ...mockWorktreeManager,
+      remove: async () => {},
+    };
+
+    const engine = new MergeEngine(mockManager);
+
+    // Mock merge to fail for US-001
+    const originalMerge = engine.merge;
+    let callCount = 0;
+    engine.merge = async (_projectRoot: string, storyId: string) => {
+      callCount++;
+      if (storyId === "US-001") {
+        return { success: false, conflictFiles: ["file.ts"], retryCount: 0 };
+      }
+      return { success: true, retryCount: 0 };
+    };
+
+    const storyIds = ["US-001", "US-002"];
+    const dependencies: StoryDependencies = {
+      "US-002": ["US-001"],
+    };
+
+    const results = await engine.mergeAll("/tmp/project", storyIds, dependencies);
+
+    expect(results.length).toBe(2);
+    expect(results[0].success).toBe(false);
+    expect(results[1].success).toBe(false); // Skipped due to failed dependency
+    expect(callCount).toBe(1); // Only US-001 was attempted
+
+    // Restore original method
+    engine.merge = originalMerge;
+  });
+
+  it("continues with remaining stories after one fails", async () => {
+    const mockManager = {
+      ...mockWorktreeManager,
+      remove: async () => {},
+    };
+
+    const engine = new MergeEngine(mockManager);
+
+    // Mock merge to fail for US-002 only
+    const originalMerge = engine.merge;
+    engine.merge = async (_projectRoot: string, storyId: string) => {
+      if (storyId === "US-002") {
+        return { success: false, conflictFiles: ["file.ts"], retryCount: 0 };
+      }
+      return { success: true, retryCount: 0 };
+    };
+
+    const storyIds = ["US-001", "US-002", "US-003"];
+    const dependencies: StoryDependencies = {};
+
+    const results = await engine.mergeAll("/tmp/project", storyIds, dependencies);
+
+    expect(results.length).toBe(3);
+    expect(results[0].success).toBe(true); // US-001 succeeds
+    expect(results[1].success).toBe(false); // US-002 fails
+    expect(results[2].success).toBe(true); // US-003 succeeds
+
+    // Restore original method
+    engine.merge = originalMerge;
+  });
+});

package/test/unit/metrics.test.ts

@@ -0,0 +1,276 @@
+import { describe, expect, test } from "bun:test";
+import { type RunMetrics, type StoryMetrics, calculateAggregateMetrics, getLastRun } from "../../src/metrics";
+
+describe("metrics/aggregator", () => {
+  describe("calculateAggregateMetrics", () => {
+    test("returns empty metrics for no runs", () => {
+      const aggregate = calculateAggregateMetrics([]);
+
+      expect(aggregate.totalRuns).toBe(0);
+      expect(aggregate.totalCost).toBe(0);
+      expect(aggregate.totalStories).toBe(0);
+      expect(aggregate.firstPassRate).toBe(0);
+      expect(aggregate.escalationRate).toBe(0);
+      expect(aggregate.avgCostPerStory).toBe(0);
+      expect(aggregate.avgCostPerFeature).toBe(0);
+      expect(Object.keys(aggregate.modelEfficiency)).toHaveLength(0);
+      expect(Object.keys(aggregate.complexityAccuracy)).toHaveLength(0);
+    });
+
+    test("calculates metrics for single run", () => {
+      const storyMetrics: StoryMetrics[] = [
+        {
+          storyId: "US-001",
+          complexity: "simple",
+          modelTier: "fast",
+          modelUsed: "claude-haiku-4.5",
+          attempts: 1,
+          finalTier: "fast",
+          success: true,
+          cost: 0.01,
+          durationMs: 30000,
+          firstPassSuccess: true,
+          startedAt: "2026-02-17T10:00:00.000Z",
+          completedAt: "2026-02-17T10:00:30.000Z",
+        },
+        {
+          storyId: "US-002",
+          complexity: "medium",
+          modelTier: "balanced",
+          modelUsed: "claude-sonnet-4.5",
+          attempts: 2,
+          finalTier: "powerful",
+          success: true,
+          cost: 0.05,
+          durationMs: 60000,
+          firstPassSuccess: false,
+          startedAt: "2026-02-17T10:01:00.000Z",
+          completedAt: "2026-02-17T10:02:00.000Z",
+        },
+      ];
+
+      const runMetrics: RunMetrics = {
+        runId: "run-test-1",
+        feature: "test-feature",
+        startedAt: "2026-02-17T10:00:00.000Z",
+        completedAt: "2026-02-17T10:02:00.000Z",
+        totalCost: 0.06,
+        totalStories: 2,
+        storiesCompleted: 2,
+        storiesFailed: 0,
+        totalDurationMs: 120000,
+        stories: storyMetrics,
+      };
+
+      const aggregate = calculateAggregateMetrics([runMetrics]);
+
+      expect(aggregate.totalRuns).toBe(1);
+      expect(aggregate.totalCost).toBe(0.06);
+      expect(aggregate.totalStories).toBe(2);
+      expect(aggregate.firstPassRate).toBe(0.5); // 1/2
+      expect(aggregate.escalationRate).toBe(0.5); // 1/2
+      expect(aggregate.avgCostPerStory).toBe(0.03);
+      expect(aggregate.avgCostPerFeature).toBe(0.06);
+    });
+
+    test("calculates model efficiency across multiple runs", () => {
+      const run1: RunMetrics = {
+        runId: "run-1",
+        feature: "feature-1",
+        startedAt: "2026-02-17T10:00:00.000Z",
+        completedAt: "2026-02-17T10:01:00.000Z",
+        totalCost: 0.02,
+        totalStories: 2,
+        storiesCompleted: 2,
+        storiesFailed: 0,
+        totalDurationMs: 60000,
+        stories: [
+          {
+            storyId: "US-001",
+            complexity: "simple",
+            modelTier: "fast",
+            modelUsed: "claude-haiku-4.5",
+            attempts: 1,
+            finalTier: "fast",
+            success: true,
+            cost: 0.01,
+            durationMs: 30000,
+            firstPassSuccess: true,
+            startedAt: "2026-02-17T10:00:00.000Z",
+            completedAt: "2026-02-17T10:00:30.000Z",
+          },
+          {
+            storyId: "US-002",
+            complexity: "simple",
+            modelTier: "fast",
+            modelUsed: "claude-haiku-4.5",
+            attempts: 1,
+            finalTier: "fast",
+            success: true,
+            cost: 0.01,
+            durationMs: 30000,
+            firstPassSuccess: true,
+            startedAt: "2026-02-17T10:00:30.000Z",
+            completedAt: "2026-02-17T10:01:00.000Z",
+          },
+        ],
+      };
+
+      const run2: RunMetrics = {
+        runId: "run-2",
+        feature: "feature-2",
+        startedAt: "2026-02-17T11:00:00.000Z",
+        completedAt: "2026-02-17T11:01:00.000Z",
+        totalCost: 0.05,
+        totalStories: 1,
+        storiesCompleted: 1,
+        storiesFailed: 0,
+        totalDurationMs: 60000,
+        stories: [
+          {
+            storyId: "US-003",
+            complexity: "complex",
+            modelTier: "powerful",
+            modelUsed: "claude-opus-4.6",
+            attempts: 1,
+            finalTier: "powerful",
+            success: true,
+            cost: 0.05,
+            durationMs: 60000,
+            firstPassSuccess: true,
+            startedAt: "2026-02-17T11:00:00.000Z",
+            completedAt: "2026-02-17T11:01:00.000Z",
+          },
+        ],
+      };
+
+      const aggregate = calculateAggregateMetrics([run1, run2]);
+
+      expect(aggregate.totalRuns).toBe(2);
+      expect(aggregate.totalStories).toBe(3);
+
+      // Check haiku model efficiency
+      expect(aggregate.modelEfficiency["claude-haiku-4.5"]).toBeDefined();
+      expect(aggregate.modelEfficiency["claude-haiku-4.5"].attempts).toBe(2);
+      expect(aggregate.modelEfficiency["claude-haiku-4.5"].successes).toBe(2);
+      expect(aggregate.modelEfficiency["claude-haiku-4.5"].passRate).toBe(1.0);
+      expect(aggregate.modelEfficiency["claude-haiku-4.5"].totalCost).toBe(0.02);
+
+      // Check opus model efficiency
+      expect(aggregate.modelEfficiency["claude-opus-4.6"]).toBeDefined();
+      expect(aggregate.modelEfficiency["claude-opus-4.6"].attempts).toBe(1);
+      expect(aggregate.modelEfficiency["claude-opus-4.6"].successes).toBe(1);
+      expect(aggregate.modelEfficiency["claude-opus-4.6"].passRate).toBe(1.0);
+      expect(aggregate.modelEfficiency["claude-opus-4.6"].totalCost).toBe(0.05);
+    });
+
+    test("calculates complexity accuracy with mismatches", () => {
+      const runMetrics: RunMetrics = {
+        runId: "run-test-1",
+        feature: "test-feature",
+        startedAt: "2026-02-17T10:00:00.000Z",
+        completedAt: "2026-02-17T10:05:00.000Z",
+        totalCost: 0.15,
+        totalStories: 3,
+        storiesCompleted: 3,
+        storiesFailed: 0,
+        totalDurationMs: 300000,
+        stories: [
+          {
+            storyId: "US-001",
+            complexity: "simple",
+            modelTier: "fast",
+            modelUsed: "claude-haiku-4.5",
+            attempts: 1,
+            finalTier: "fast",
+            success: true,
+            cost: 0.01,
+            durationMs: 30000,
+            firstPassSuccess: true,
+            startedAt: "2026-02-17T10:00:00.000Z",
+            completedAt: "2026-02-17T10:00:30.000Z",
+          },
+          {
+            storyId: "US-002",
+            complexity: "simple",
+            modelTier: "fast",
+            modelUsed: "claude-sonnet-4.5",
+            attempts: 2,
+            finalTier: "balanced",
+            success: true,
+            cost: 0.04,
+            durationMs: 120000,
+            firstPassSuccess: false,
+            startedAt: "2026-02-17T10:01:00.000Z",
+            completedAt: "2026-02-17T10:03:00.000Z",
+          },
+          {
+            storyId: "US-003",
+            complexity: "medium",
+            modelTier: "balanced",
+            modelUsed: "claude-sonnet-4.5",
+            attempts: 1,
+            finalTier: "balanced",
+            success: true,
+            cost: 0.03,
+            durationMs: 90000,
+            firstPassSuccess: true,
+            startedAt: "2026-02-17T10:03:00.000Z",
+            completedAt: "2026-02-17T10:04:30.000Z",
+          },
+        ],
+      };
+
+      const aggregate = calculateAggregateMetrics([runMetrics]);
+
+      // Check simple complexity accuracy
+      expect(aggregate.complexityAccuracy.simple).toBeDefined();
+      expect(aggregate.complexityAccuracy.simple.predicted).toBe(2);
+      expect(aggregate.complexityAccuracy.simple.mismatchRate).toBe(0.5); // 1 mismatch out of 2
+
+      // Check medium complexity accuracy
+      expect(aggregate.complexityAccuracy.medium).toBeDefined();
+      expect(aggregate.complexityAccuracy.medium.predicted).toBe(1);
+      expect(aggregate.complexityAccuracy.medium.mismatchRate).toBe(0); // no mismatch
+    });
+  });
+
+  describe("getLastRun", () => {
+    test("returns null for empty runs", () => {
+      expect(getLastRun([])).toBeNull();
+    });
+
+    test("returns last run from array", () => {
+      const runs: RunMetrics[] = [
+        {
+          runId: "run-1",
+          feature: "feature-1",
+          startedAt: "2026-02-17T10:00:00.000Z",
+          completedAt: "2026-02-17T10:01:00.000Z",
+          totalCost: 0.01,
+          totalStories: 1,
+          storiesCompleted: 1,
+          storiesFailed: 0,
+          totalDurationMs: 60000,
+          stories: [],
+        },
+        {
+          runId: "run-2",
+          feature: "feature-2",
+          startedAt: "2026-02-17T11:00:00.000Z",
+          completedAt: "2026-02-17T11:01:00.000Z",
+          totalCost: 0.02,
+          totalStories: 2,
+          storiesCompleted: 2,
+          storiesFailed: 0,
+          totalDurationMs: 120000,
+          stories: [],
+        },
+      ];
+
+      const lastRun = getLastRun(runs);
+      expect(lastRun).not.toBeNull();
+      expect(lastRun?.runId).toBe("run-2");
+    });
+  });
+});

package/test/unit/optimizer/noop.optimizer.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import type { NaxConfig } from "../../../src/config/schema.js";
+import type { PromptOptimizerInput, PromptOptimizerResult } from "../../../src/optimizer/types.js";
+
+// NoopOptimizer implementation is imported here
+// We're writing tests FIRST, so this will fail until we implement it
+import { NoopOptimizer } from "../../../src/optimizer/noop.optimizer.js";
+
+describe("NoopOptimizer", () => {
+  const mockConfig: NaxConfig = {
+    modelTier: "fast",
+    provider: "anthropic",
+    apiKeys: {},
+    optimizer: {
+      enabled: false,
+      strategy: "noop",
+    },
+  };
+
+  test("should have name 'noop'", () => {
+    const optimizer = new NoopOptimizer();
+    expect(optimizer.name).toBe("noop");
+  });
+
+  test("should return prompt unchanged", async () => {
+    const optimizer = new NoopOptimizer();
+    const input: PromptOptimizerInput = {
+      prompt: "This is a test prompt with some content.",
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.prompt).toBe(input.prompt);
+  });
+
+  test("should return zero savings", async () => {
+    const optimizer = new NoopOptimizer();
+    const input: PromptOptimizerInput = {
+      prompt: "Any prompt content here.",
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.savings).toBe(0);
+  });
+
+  test("should return equal original and optimized token counts", async () => {
+    const optimizer = new NoopOptimizer();
+    const input: PromptOptimizerInput = {
+      prompt: "A prompt with several words to estimate tokens.",
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.originalTokens).toBe(result.optimizedTokens);
+    expect(result.originalTokens).toBeGreaterThan(0);
+  });
+
+  test("should return empty applied rules", async () => {
+    const optimizer = new NoopOptimizer();
+    const input: PromptOptimizerInput = {
+      prompt: "Test prompt",
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.appliedRules).toEqual([]);
+  });
+
+  test("should handle empty prompt", async () => {
+    const optimizer = new NoopOptimizer();
+    const input: PromptOptimizerInput = {
+      prompt: "",
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.prompt).toBe("");
+    expect(result.originalTokens).toBe(0);
+    expect(result.optimizedTokens).toBe(0);
+    expect(result.savings).toBe(0);
+  });
+
+  test("should handle very long prompt", async () => {
+    const optimizer = new NoopOptimizer();
+    const longPrompt = "a".repeat(10000);
+    const input: PromptOptimizerInput = {
+      prompt: longPrompt,
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.prompt).toBe(longPrompt);
+    expect(result.originalTokens).toBe(result.optimizedTokens);
+  });
+
+  test("should preserve multiline prompts", async () => {
+    const optimizer = new NoopOptimizer();
+    const multilinePrompt = `Line 1
+Line 2
+
+Line 4 with blank line above`;
+    const input: PromptOptimizerInput = {
+      prompt: multilinePrompt,
+      stories: [],
+      config: mockConfig,
+    };
+
+    const result = await optimizer.optimize(input);
+
+    expect(result.prompt).toBe(multilinePrompt);
+  });
+});