@nathapp/nax 0.28.0 → 0.30.0

package/test/unit/optimizer/rule-based.optimizer.test.ts

@@ -1,358 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { NaxConfig } from "../../../src/config/schema.js";
-import { RuleBasedOptimizer } from "../../../src/optimizer/rule-based.optimizer.js";
-import type { PromptOptimizerInput } from "../../../src/optimizer/types.js";
-
-describe("RuleBasedOptimizer", () => {
-  const mockConfig: NaxConfig = {
-    modelTier: "fast",
-    provider: "anthropic",
-    apiKeys: {},
-    optimizer: {
-      enabled: true,
-      strategy: "rule-based",
-      strategies: {
-        "rule-based": {
-          stripWhitespace: true,
-          compactCriteria: true,
-          deduplicateContext: true,
-          maxPromptTokens: 8000,
-        },
-      },
-    },
-  };
-
-  test("should have name 'rule-based'", () => {
-    const optimizer = new RuleBasedOptimizer();
-    expect(optimizer.name).toBe("rule-based");
-  });
-
-  describe("stripWhitespace rule", () => {
-    test("should collapse multiple blank lines to single blank line", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: "Line 1\n\n\n\nLine 2\n\n\n\n\nLine 3",
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.prompt).toBe("Line 1\n\nLine 2\n\nLine 3");
-      expect(result.appliedRules).toContain("stripWhitespace");
-    });
-
-    test("should trim trailing whitespace from lines", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: "Line 1   \nLine 2\t\t\nLine 3    ",
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.prompt).toBe("Line 1\nLine 2\nLine 3");
-      expect(result.appliedRules).toContain("stripWhitespace");
-    });
-
-    test("should not apply if disabled in config", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const configWithoutStrip = {
-        ...mockConfig,
-        optimizer: {
-          enabled: true,
-          strategy: "rule-based" as const,
-          strategies: {
-            "rule-based": {
-              stripWhitespace: false,
-              compactCriteria: false,
-              deduplicateContext: false,
-              maxPromptTokens: 8000,
-            },
-          },
-        },
-      };
-      const input: PromptOptimizerInput = {
-        prompt: "Line 1\n\n\n\nLine 2",
-        stories: [],
-        config: configWithoutStrip,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.prompt).toBe("Line 1\n\n\n\nLine 2");
-      expect(result.appliedRules).not.toContain("stripWhitespace");
-    });
-  });
-
-  describe("compactCriteria rule", () => {
-    test("should convert verbose acceptance criteria to terse bullets", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: `## Acceptance Criteria
-
-- The user should be able to click the button and see a modal
-- When the form is submitted, it should validate all fields
-- The system must display an error message if validation fails`,
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      // Should remove verbose wording like "should be able to", "When", "The system must"
-      expect(result.prompt).toContain("## Acceptance Criteria");
-      expect(result.appliedRules).toContain("compactCriteria");
-      // Verify some compaction occurred
-      expect(result.prompt.length).toBeLessThan(input.prompt.length);
-    });
-
-    test("should not apply if disabled in config", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const configWithoutCompact = {
-        ...mockConfig,
-        optimizer: {
-          enabled: true,
-          strategy: "rule-based" as const,
-          strategies: {
-            "rule-based": {
-              stripWhitespace: false,
-              compactCriteria: false,
-              deduplicateContext: false,
-              maxPromptTokens: 8000,
-            },
-          },
-        },
-      };
-      const input: PromptOptimizerInput = {
-        prompt: "The user should be able to click the button",
-        stories: [],
-        config: configWithoutCompact,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).not.toContain("compactCriteria");
-    });
-  });
-
-  describe("deduplicateContext rule", () => {
-    test("should remove context that duplicates constitution", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: `# Constitution
-Always use TypeScript
-
-# Context
-Use TypeScript for all code
-
-# Task
-Implement feature X`,
-        stories: [],
-        contextMarkdown: "Use TypeScript for all code",
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).toContain("deduplicateContext");
-      // Context section should be reduced or removed
-      expect(result.prompt.length).toBeLessThan(input.prompt.length);
-    });
-
-    test("should not apply if contextMarkdown is not provided", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: "Test prompt",
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).not.toContain("deduplicateContext");
-    });
-
-    test("should not apply if disabled in config", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const configWithoutDedup = {
-        ...mockConfig,
-        optimizer: {
-          enabled: true,
-          strategy: "rule-based" as const,
-          strategies: {
-            "rule-based": {
-              stripWhitespace: false,
-              compactCriteria: false,
-              deduplicateContext: false,
-              maxPromptTokens: 8000,
-            },
-          },
-        },
-      };
-      const input: PromptOptimizerInput = {
-        prompt: "Duplicate content here",
-        stories: [],
-        contextMarkdown: "Duplicate content",
-        config: configWithoutDedup,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).not.toContain("deduplicateContext");
-    });
-  });
-
-  describe("maxPromptTokens rule", () => {
-    test("should trim context if prompt exceeds threshold", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      // Create a very long prompt that exceeds 8000 tokens (~32000 chars)
-      const longPrompt = `# Task
-Implement feature X
-
-# Context
-${"Lorem ipsum dolor sit amet. ".repeat(5000)}
-
-# Acceptance Criteria
-- AC 1
-- AC 2`;
-      const input: PromptOptimizerInput = {
-        prompt: longPrompt,
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).toContain("maxPromptTokens");
-      expect(result.optimizedTokens).toBeLessThanOrEqual(8000);
-      // Should preserve task and AC sections
-      expect(result.prompt).toContain("# Task");
-      expect(result.prompt).toContain("# Acceptance Criteria");
-    });
-
-    test("should not apply if prompt is under threshold", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: "Short prompt that is well under 8000 tokens",
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).not.toContain("maxPromptTokens");
-    });
-
-    test("should use custom threshold from config", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const configWithLowThreshold = {
-        ...mockConfig,
-        optimizer: {
-          enabled: true,
-          strategy: "rule-based" as const,
-          strategies: {
-            "rule-based": {
-              stripWhitespace: false,
-              compactCriteria: false,
-              deduplicateContext: false,
-              maxPromptTokens: 10, // Very low threshold
-            },
-          },
-        },
-      };
-      const input: PromptOptimizerInput = {
-        prompt: "This prompt will definitely exceed 10 tokens",
-        stories: [],
-        config: configWithLowThreshold,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.appliedRules).toContain("maxPromptTokens");
-      expect(result.optimizedTokens).toBeLessThanOrEqual(10);
-    });
-  });
-
-  describe("savings calculation", () => {
-    test("should calculate savings correctly", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const input: PromptOptimizerInput = {
-        prompt: "Line 1\n\n\n\nLine 2   \n\n\n\nLine 3   ",
-        stories: [],
-        config: mockConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.originalTokens).toBeGreaterThan(result.optimizedTokens);
-      expect(result.savings).toBeGreaterThan(0);
-      expect(result.savings).toBeLessThanOrEqual(1);
-    });
-
-    test("should return 0 savings if no optimization applied", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const configWithNoRules = {
-        ...mockConfig,
-        optimizer: {
-          enabled: true,
-          strategy: "rule-based" as const,
-          strategies: {
-            "rule-based": {
-              stripWhitespace: false,
-              compactCriteria: false,
-              deduplicateContext: false,
-              maxPromptTokens: 999999,
-            },
-          },
-        },
-      };
-      const input: PromptOptimizerInput = {
-        prompt: "Simple prompt",
-        stories: [],
-        config: configWithNoRules,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      expect(result.savings).toBe(0);
-      expect(result.originalTokens).toBe(result.optimizedTokens);
-    });
-  });
-
-  describe("default config", () => {
-    test("should use default rules when config is missing", async () => {
-      const optimizer = new RuleBasedOptimizer();
-      const minimalConfig: NaxConfig = {
-        modelTier: "fast",
-        provider: "anthropic",
-        apiKeys: {},
-      };
-      const input: PromptOptimizerInput = {
-        prompt: "Line 1\n\n\n\nLine 2   ",
-        stories: [],
-        config: minimalConfig,
-      };
-
-      const result = await optimizer.optimize(input);
-
-      // Should apply default rules (all enabled)
-      expect(result.appliedRules).toContain("stripWhitespace");
-    });
-  });
-
-  test("should handle empty prompt", async () => {
-    const optimizer = new RuleBasedOptimizer();
-    const input: PromptOptimizerInput = {
-      prompt: "",
-      stories: [],
-      config: mockConfig,
-    };
-
-    const result = await optimizer.optimize(input);
-
-    expect(result.prompt).toBe("");
-    expect(result.savings).toBe(0);
-  });
-});

package/test/unit/pipeline/event-bus.test.ts

@@ -1,105 +0,0 @@
-// RE-ARCH: keep
-import { describe, expect, test } from "bun:test";
-import { PipelineEventBus } from "../../../src/pipeline/event-bus";
-import type { PipelineEvent } from "../../../src/pipeline/event-bus";
-
-function makeStoryCompletedEvent(): PipelineEvent {
-  return {
-    type: "story:completed",
-    storyId: "US-001",
-    story: { id: "US-001", title: "Test story", status: "passed", acceptanceCriteria: [] } as any,
-    passed: true,
-    durationMs: 1000,
-  };
-}
-
-describe("PipelineEventBus", () => {
-  test("subscribes and receives event", () => {
-    const bus = new PipelineEventBus();
-    const received: PipelineEvent[] = [];
-    bus.on("story:completed", (e) => received.push(e));
-
-    const evt = makeStoryCompletedEvent();
-    bus.emit(evt);
-
-    expect(received).toHaveLength(1);
-    expect(received[0]).toBe(evt);
-  });
-
-  test("onAll receives all event types", () => {
-    const bus = new PipelineEventBus();
-    const received: string[] = [];
-    bus.onAll((e) => received.push(e.type));
-
-    bus.emit(makeStoryCompletedEvent());
-    bus.emit({ type: "run:completed", totalStories: 1, passedStories: 1, failedStories: 0, durationMs: 5000 });
-
-    expect(received).toEqual(["story:completed", "run:completed"]);
-  });
-
-  test("unsubscribe stops receiving events", () => {
-    const bus = new PipelineEventBus();
-    const received: PipelineEvent[] = [];
-    const unsub = bus.on("story:completed", (e) => received.push(e));
-
-    bus.emit(makeStoryCompletedEvent());
-    unsub();
-    bus.emit(makeStoryCompletedEvent());
-
-    expect(received).toHaveLength(1);
-  });
-
-  test("subscriber error does not prevent other subscribers from running", () => {
-    const bus = new PipelineEventBus();
-    const results: string[] = [];
-
-    bus.on("story:completed", () => { throw new Error("boom"); });
-    bus.on("story:completed", () => results.push("second"));
-
-    bus.emit(makeStoryCompletedEvent());
-
-    expect(results).toEqual(["second"]);
-  });
-
-  test("subscriberCount returns correct count", () => {
-    const bus = new PipelineEventBus();
-    expect(bus.subscriberCount("story:completed")).toBe(0);
-
-    bus.on("story:completed", () => {});
-    bus.on("story:completed", () => {});
-    expect(bus.subscriberCount("story:completed")).toBe(2);
-  });
-
-  test("clear removes all subscribers", () => {
-    const bus = new PipelineEventBus();
-    const received: PipelineEvent[] = [];
-    bus.on("story:completed", (e) => received.push(e));
-    bus.clear();
-    bus.emit(makeStoryCompletedEvent());
-
-    expect(received).toHaveLength(0);
-  });
-
-  test("emitAsync awaits all async subscribers", async () => {
-    const bus = new PipelineEventBus();
-    let resolved = false;
-
-    bus.on("story:completed", async () => {
-      await new Promise((r) => setTimeout(r, 10));
-      resolved = true;
-    });
-
-    await bus.emitAsync(makeStoryCompletedEvent());
-    expect(resolved).toBe(true);
-  });
-
-  test("does not deliver typed events to wrong subscriber", () => {
-    const bus = new PipelineEventBus();
-    const received: PipelineEvent[] = [];
-
-    bus.on("run:completed", (e) => received.push(e));
-    bus.emit(makeStoryCompletedEvent());
-
-    expect(received).toHaveLength(0);
-  });
-});

package/test/unit/pipeline/routing-partial-override.test.ts

@@ -1,121 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for partial routing override in routing stage (FIX-001)
- *
- * Verifies that story.routing fields only override LLM-classified results
- * when they are actually set. Prevents undefined values from clobbering
- * a fresh classification.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { initLogger, resetLogger } from "../../../src/logger";
-import { _routingDeps, routingStage } from "../../../src/pipeline/stages/routing";
-import type { NaxConfig } from "../../../src/config";
-import type { PipelineContext } from "../../../src/pipeline/types";
-import type { UserStory } from "../../../src/prd/types";
-
-// ── Mock functions ────────────────────────────────────────────────────────────
-
-const mockRouteStory = mock(async () => ({
-  complexity: "medium",
-  modelTier: "balanced",
-  testStrategy: "three-session-tdd",
-  reasoning: "LLM classified as medium",
-}));
-
-const mockComplexityToModelTier = mock((_complexity: string, _config: unknown) => "balanced" as const);
-const mockIsGreenfieldStory = mock(async () => false);
-
-// ── Capture originals for afterEach restoration ───────────────────────────────
-
-const _origDeps = { ..._routingDeps };
-
-// ── Fixtures ──────────────────────────────────────────────────────────────────
-
-function makeStory(routingOverride?: Partial<UserStory["routing"]>): UserStory {
-  const story: UserStory = {
-    id: "FIX-001-test",
-    title: "Partial routing override test",
-    description: "Tests that story.routing only overrides when set",
-    acceptanceCriteria: [],
-    status: "pending",
-    passes: false,
-    escalations: [],
-    attempts: 0,
-    tags: [],
-    dependencies: [],
-  };
-  if (routingOverride !== undefined) {
-    story.routing = routingOverride as UserStory["routing"];
-  }
-  return story;
-}
-
-function makeCtx(story: UserStory): PipelineContext {
-  return {
-    config: {
-      tdd: { greenfieldDetection: false },
-      autoMode: { complexityRouting: {} },
-      routing: { strategy: "complexity", llm: { mode: "per-story" } },
-    } as unknown as NaxConfig,
-    story,
-    stories: [story],
-    routing: {} as PipelineContext["routing"],
-    workdir: "/tmp/nax-test-partial-routing",
-    prd: { feature: "test", userStories: [story] } as PipelineContext["prd"],
-    hooks: {} as PipelineContext["hooks"],
-  } as PipelineContext;
-}
-
-// ── Lifecycle ─────────────────────────────────────────────────────────────────
-
-beforeEach(() => {
-  resetLogger();
-  initLogger({ level: "error", useChalk: false });
-  _routingDeps.routeStory = mockRouteStory as typeof _routingDeps.routeStory;
-  _routingDeps.complexityToModelTier = mockComplexityToModelTier as typeof _routingDeps.complexityToModelTier;
-  _routingDeps.isGreenfieldStory = mockIsGreenfieldStory as typeof _routingDeps.isGreenfieldStory;
-  mockRouteStory.mockClear();
-  mockComplexityToModelTier.mockClear();
-  mockIsGreenfieldStory.mockClear();
-});
-
-afterEach(() => {
-  Object.assign(_routingDeps, _origDeps);
-  mock.restore();
-  resetLogger();
-});
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe("routing stage — partial override (FIX-001)", () => {
-  test("(1) partial override with only testStrategy preserves LLM complexity", async () => {
-    const story = makeStory({ testStrategy: "test-after", complexity: undefined as any, reasoning: "manual" });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx);
-
-    expect(ctx.routing.testStrategy).toBe("test-after");
-    expect(ctx.routing.complexity).toBe("medium");
-  });
-
-  test("(2) LLM-classified complexity is preserved when story.routing has no complexity", async () => {
-    const story = makeStory({ testStrategy: "test-after", complexity: undefined as any, reasoning: "" });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx);
-
-    expect(ctx.routing.complexity).toBe("medium");
-    expect(ctx.routing.complexity).not.toBeUndefined();
-  });
-
-  test("(3) full override works when both complexity and testStrategy are set", async () => {
-    const story = makeStory({ complexity: "simple", testStrategy: "test-after", reasoning: "manual override" });
-    const ctx = makeCtx(story);
-
-    await routingStage.execute(ctx);
-
-    expect(ctx.routing.complexity).toBe("simple");
-    expect(ctx.routing.testStrategy).toBe("test-after");
-  });
-});

package/test/unit/pipeline/runner-retry.test.ts

@@ -1,89 +0,0 @@
-// RE-ARCH: keep
-import { describe, expect, test } from "bun:test";
-import { MAX_STAGE_RETRIES, runPipeline } from "../../../src/pipeline/runner";
-import type { PipelineContext, PipelineStage } from "../../../src/pipeline/types";
-import { DEFAULT_CONFIG } from "../../../src/config";
-
-function makeCtx(): PipelineContext {
-  return {
-    config: DEFAULT_CONFIG,
-    prd: { stories: [], acceptanceOverrides: {} } as any,
-    story: { id: "US-001", title: "t", status: "pending", acceptanceCriteria: [] } as any,
-    stories: [],
-    routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
-    workdir: "/tmp",
-    hooks: {},
-  };
-}
-
-function stage(name: string, action: () => import("../../../src/pipeline/types").StageResult | Promise<import("../../../src/pipeline/types").StageResult>): PipelineStage {
-  return { name, enabled: () => true, execute: async () => action() };
-}
-
-describe("runPipeline retry action", () => {
-  test("retry jumps back to named stage", async () => {
-    const order: string[] = [];
-    let attempt = 0;
-
-    const stages = [
-      stage("a", () => { order.push("a"); return { action: "continue" }; }),
-      stage("b", () => { order.push("b"); return { action: "continue" }; }),
-      stage("c", () => {
-        order.push("c");
-        attempt++;
-        if (attempt < 2) return { action: "retry", fromStage: "b" };
-        return { action: "continue" };
-      }),
-      stage("d", () => { order.push("d"); return { action: "continue" }; }),
-    ];
-
-    const result = await runPipeline(stages, makeCtx());
-
-    expect(result.finalAction).toBe("complete");
-    expect(order).toEqual(["a", "b", "c", "b", "c", "d"]);
-  });
-
-  test("retry fails after MAX_STAGE_RETRIES exceeded", async () => {
-    let calls = 0;
-    const stages = [
-      stage("verify", () => { return { action: "continue" }; }),
-      stage("rectify", () => { calls++; return { action: "retry", fromStage: "verify" }; }),
-    ];
-
-    const result = await runPipeline(stages, makeCtx());
-
-    expect(result.finalAction).toBe("fail");
-    expect(calls).toBe(MAX_STAGE_RETRIES + 1);
-    expect(result.reason).toContain("exceeded max retries");
-  });
-
-  test("retry to unknown stage escalates", async () => {
-    const stages = [
-      stage("a", () => ({ action: "retry", fromStage: "nonexistent" })),
-    ];
-
-    const result = await runPipeline(stages, makeCtx());
-    expect(result.finalAction).toBe("escalate");
-    expect(result.reason).toContain("not found");
-  });
-
-  test("disabled stages are skipped during retry", async () => {
-    const order: string[] = [];
-    let attempt = 0;
-
-    const stages = [
-      stage("verify", () => { order.push("verify"); return { action: "continue" }; }),
-      { name: "disabled", enabled: () => false, execute: async () => { order.push("disabled"); return { action: "continue" as const }; } },
-      stage("rectify", () => {
-        order.push("rectify");
-        attempt++;
-        if (attempt < 2) return { action: "retry", fromStage: "verify" };
-        return { action: "continue" };
-      }),
-    ];
-
-    await runPipeline(stages, makeCtx());
-    expect(order).not.toContain("disabled");
-    expect(order).toEqual(["verify", "rectify", "verify", "rectify"]);
-  });
-});