@nathapp/nax 0.18.1 → 0.18.2

package/test/US-002-orchestrator.test.ts

@@ -101,7 +101,7 @@ describe("US-002: Precheck orchestrator acceptance criteria", () => {
     const config = createConfig(testDir);
     const prd = createPRD();
 
-    const { result } = await runPrecheck(config, prd, { workdir: testDir, format: "json" });
+    const { result } = await runPrecheck(config, prd, { workdir: testDir, format: "json", silent: true });
 
     // Should have exactly 1 blocker (fail-fast)
     expect(result.blockers.length).toBe(1);
@@ -116,7 +116,7 @@ describe("US-002: Precheck orchestrator acceptance criteria", () => {
     const config = createConfig(testDir);
     const prd = createPRD();
 
-    const { result } = await runPrecheck(config, prd, { workdir: testDir, format: "json" });
+    const { result } = await runPrecheck(config, prd, { workdir: testDir, format: "json", silent: true });
 
     // No blockers
     expect(result.blockers.length).toBe(0);
@@ -195,13 +195,13 @@ describe("US-002: Precheck orchestrator acceptance criteria", () => {
 
     let config = createConfig(testDir);
     const prd = createPRD();
-    let result = await runPrecheck(config, prd, { workdir: testDir, format: "json" });
+    let result = await runPrecheck(config, prd, { workdir: testDir, format: "json", silent: true });
     expect(result.exitCode).toBe(EXIT_CODES.SUCCESS);
 
     // Test exit code 1 (blocker)
     const testDir2 = mkdtempSync(join(tmpdir(), "nax-test-blocker-"));
     config = createConfig(testDir2);
-    result = await runPrecheck(config, prd, { workdir: testDir2, format: "json" });
+    result = await runPrecheck(config, prd, { workdir: testDir2, format: "json", silent: true });
     expect(result.exitCode).toBe(EXIT_CODES.BLOCKER);
     rmSync(testDir2, { recursive: true, force: true });
 
@@ -214,7 +214,7 @@ describe("US-002: Precheck orchestrator acceptance criteria", () => {
       ...prd,
       userStories: [{ ...prd.userStories[0], id: "", title: "", description: "" }],
     };
-    result = await runPrecheck(config, invalidPRD, { workdir: testDir3, format: "json" });
+    result = await runPrecheck(config, invalidPRD, { workdir: testDir3, format: "json", silent: true });
     expect(result.exitCode).toBe(EXIT_CODES.INVALID_PRD);
     rmSync(testDir3, { recursive: true, force: true });
   });

package/test/unit/config/smart-runner-flag.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Smart Test Runner Config Flag Tests (STR-004)
+ *
+ * Verifies that execution.smartTestRunner is present in the ExecutionConfig
+ * interface, defaults to true in the Zod schema, and loads correctly.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { globalConfigPath, loadConfig } from "../../../src/config/loader";
+import { DEFAULT_CONFIG } from "../../../src/config/defaults";
+import { NaxConfigSchema } from "../../../src/config/schemas";
+
+describe("execution.smartTestRunner config flag", () => {
+  let tempDir: string;
+  let globalBackup: string | null = null;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `nax-str-004-${Date.now()}`);
+    mkdirSync(join(tempDir, "nax"), { recursive: true });
+
+    const globalPath = globalConfigPath();
+    if (existsSync(globalPath)) {
+      globalBackup = `${globalPath}.test-backup-${Date.now()}`;
+      renameSync(globalPath, globalBackup);
+    }
+  });
+
+  afterEach(() => {
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+    if (globalBackup && existsSync(globalBackup)) {
+      const globalPath = globalConfigPath();
+      if (existsSync(globalPath)) rmSync(globalPath);
+      renameSync(globalBackup, globalPath);
+      globalBackup = null;
+    }
+  });
+
+  test("DEFAULT_CONFIG has smartTestRunner: true", () => {
+    expect(DEFAULT_CONFIG.execution.smartTestRunner).toBe(true);
+  });
+
+  test("Zod schema defaults smartTestRunner to true when field is absent", () => {
+    const minimal = {
+      version: 1,
+      models: {
+        fast: { provider: "anthropic", model: "haiku" },
+        balanced: { provider: "anthropic", model: "sonnet" },
+        powerful: { provider: "anthropic", model: "opus" },
+      },
+      autoMode: {
+        enabled: true,
+        defaultAgent: "claude",
+        fallbackOrder: [],
+        complexityRouting: { simple: "fast", medium: "balanced", complex: "powerful", expert: "powerful" },
+        escalation: { enabled: true, tierOrder: [{ tier: "fast", attempts: 1 }] },
+      },
+      routing: { strategy: "keyword" },
+      execution: {
+        maxIterations: 10,
+        iterationDelayMs: 0,
+        costLimit: 1,
+        sessionTimeoutSeconds: 60,
+        maxStoriesPerFeature: 10,
+        rectification: {
+          enabled: true,
+          maxRetries: 1,
+          fullSuiteTimeoutSeconds: 30,
+          maxFailureSummaryChars: 500,
+          abortOnIncreasingFailures: true,
+        },
+        regressionGate: { enabled: true, timeoutSeconds: 30 },
+        contextProviderTokenBudget: 100,
+        // smartTestRunner intentionally omitted
+      },
+      quality: {
+        requireTypecheck: true,
+        requireLint: true,
+        requireTests: true,
+        commands: {},
+        forceExit: false,
+        detectOpenHandles: true,
+        detectOpenHandlesRetries: 1,
+        gracePeriodMs: 500,
+        drainTimeoutMs: 0,
+        shell: "/bin/sh",
+        stripEnvVars: [],
+        environmentalEscalationDivisor: 2,
+      },
+      tdd: { maxRetries: 0, autoVerifyIsolation: false, autoApproveVerifier: false },
+      constitution: { enabled: false, path: "constitution.md", maxTokens: 100 },
+      analyze: { llmEnhanced: false, model: "balanced", fallbackToKeywords: true, maxCodebaseSummaryTokens: 100 },
+      review: { enabled: false, checks: [], commands: {} },
+      plan: { model: "balanced", outputPath: "spec.md" },
+      acceptance: { enabled: false, maxRetries: 0, generateTests: false, testPath: "acceptance.test.ts" },
+      context: {
+        testCoverage: { enabled: false, detail: "names-only", maxTokens: 50, testPattern: "**/*.test.ts", scopeToStory: false },
+        autoDetect: { enabled: false, maxFiles: 1, traceImports: false },
+      },
+    };
+
+    const result = NaxConfigSchema.safeParse(minimal);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.execution.smartTestRunner).toBe(true);
+    }
+  });
+
+  test("Zod schema accepts smartTestRunner: false", () => {
+    const result = NaxConfigSchema.safeParse({
+      ...buildMinimalConfig(),
+      execution: { ...buildMinimalConfig().execution, smartTestRunner: false },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.execution.smartTestRunner).toBe(false);
+    }
+  });
+
+  test("Zod schema accepts smartTestRunner: true explicitly", () => {
+    const result = NaxConfigSchema.safeParse({
+      ...buildMinimalConfig(),
+      execution: { ...buildMinimalConfig().execution, smartTestRunner: true },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.execution.smartTestRunner).toBe(true);
+    }
+  });
+
+  test("loadConfig defaults smartTestRunner to true when not in project config", async () => {
+    const configPath = join(tempDir, "nax", "config.json");
+    writeFileSync(configPath, JSON.stringify({ routing: { strategy: "keyword" } }, null, 2));
+
+    const config = await loadConfig(join(tempDir, "nax"));
+    expect(config.execution.smartTestRunner).toBe(true);
+  });
+
+  test("loadConfig respects smartTestRunner: false from project config", async () => {
+    const configPath = join(tempDir, "nax", "config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({ execution: { smartTestRunner: false } }, null, 2),
+    );
+
+    const config = await loadConfig(join(tempDir, "nax"));
+    expect(config.execution.smartTestRunner).toBe(false);
+  });
+
+  test("loadConfig loads correctly without the field (backward compat)", async () => {
+    const configPath = join(tempDir, "nax", "config.json");
+    // Config without smartTestRunner field at all
+    writeFileSync(configPath, JSON.stringify({}, null, 2));
+
+    const config = await loadConfig(join(tempDir, "nax"));
+    expect(config.execution.smartTestRunner).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Minimal valid config helper
+// ---------------------------------------------------------------------------
+
+function buildMinimalConfig() {
+  return {
+    version: 1,
+    models: {
+      fast: { provider: "anthropic", model: "haiku" },
+      balanced: { provider: "anthropic", model: "sonnet" },
+      powerful: { provider: "anthropic", model: "opus" },
+    },
+    autoMode: {
+      enabled: true,
+      defaultAgent: "claude",
+      fallbackOrder: [],
+      complexityRouting: { simple: "fast", medium: "balanced", complex: "powerful", expert: "powerful" },
+      escalation: { enabled: true, tierOrder: [{ tier: "fast", attempts: 1 }] },
+    },
+    routing: { strategy: "keyword" as const },
+    execution: {
+      maxIterations: 10,
+      iterationDelayMs: 0,
+      costLimit: 1,
+      sessionTimeoutSeconds: 60,
+      maxStoriesPerFeature: 10,
+      rectification: {
+        enabled: true,
+        maxRetries: 1,
+        fullSuiteTimeoutSeconds: 30,
+        maxFailureSummaryChars: 500,
+        abortOnIncreasingFailures: true,
+      },
+      regressionGate: { enabled: true, timeoutSeconds: 30 },
+      contextProviderTokenBudget: 100,
+    },
+    quality: {
+      requireTypecheck: true,
+      requireLint: true,
+      requireTests: true,
+      commands: {},
+      forceExit: false,
+      detectOpenHandles: true,
+      detectOpenHandlesRetries: 1,
+      gracePeriodMs: 500,
+      drainTimeoutMs: 0,
+      shell: "/bin/sh",
+      stripEnvVars: [],
+      environmentalEscalationDivisor: 2,
+    },
+    tdd: { maxRetries: 0, autoVerifyIsolation: false, autoApproveVerifier: false },
+    constitution: { enabled: false, path: "constitution.md", maxTokens: 100 },
+    analyze: { llmEnhanced: false, model: "balanced", fallbackToKeywords: true, maxCodebaseSummaryTokens: 100 },
+    review: { enabled: false, checks: [] as Array<"typecheck" | "lint" | "test">, commands: {} },
+    plan: { model: "balanced", outputPath: "spec.md" },
+    acceptance: { enabled: false, maxRetries: 0, generateTests: false, testPath: "acceptance.test.ts" },
+    context: {
+      testCoverage: { enabled: false, detail: "names-only" as const, maxTokens: 50, testPattern: "**/*.test.ts", scopeToStory: false },
+      autoDetect: { enabled: false, maxFiles: 1, traceImports: false },
+    },
+  };
+}

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

@@ -0,0 +1,141 @@
+/**
+ * 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 { beforeEach, afterEach, describe, expect, mock, test } from "bun:test";
+import { initLogger, resetLogger } from "../../../src/logger";
+import type { PipelineContext } from "../../../src/pipeline/types";
+import type { NaxConfig } from "../../../src/config";
+import type { UserStory } from "../../../src/prd/types";
+
+// ── Module mocks (must be declared before dynamic imports) ────────────────────
+
+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);
+
+mock.module("../../../src/routing", () => ({
+  routeStory: mockRouteStory,
+  complexityToModelTier: mockComplexityToModelTier,
+}));
+
+// Greenfield check: return false so it never interferes with test strategy
+mock.module("../../../src/context/greenfield", () => ({
+  isGreenfieldStory: mock(async () => false),
+}));
+
+// LLM batch cache is not relevant here
+mock.module("../../../src/routing/strategies/llm", () => ({
+  clearCache: mock(() => {}),
+  routeBatch: mock(async () => []),
+}));
+
+// ── Dynamic imports after mocks ───────────────────────────────────────────────
+
+const { routingStage } = await import("../../../src/pipeline/stages/routing");
+
+// ── 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;
+}
+
+// ── Logger setup ──────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  resetLogger();
+  initLogger({ level: "error", useChalk: false });
+  mockRouteStory.mockClear();
+  mockComplexityToModelTier.mockClear();
+});
+
+afterEach(() => {
+  resetLogger();
+});
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("routing stage — partial override (FIX-001)", () => {
+  test("(1) partial override with only testStrategy preserves LLM complexity", async () => {
+    // Story sets only testStrategy — complexity should come from LLM
+    const story = makeStory({ testStrategy: "test-after", complexity: undefined as any, reasoning: "manual" });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx);
+
+    // testStrategy is overridden by the story field
+    expect(ctx.routing.testStrategy).toBe("test-after");
+    // complexity should remain from the LLM result ("medium"), not undefined
+    expect(ctx.routing.complexity).toBe("medium");
+  });
+
+  test("(2) LLM-classified complexity is preserved when story.routing has no complexity", async () => {
+    // story.routing is present but complexity is undefined (falsy)
+    const story = makeStory({ testStrategy: "test-after", complexity: undefined as any, reasoning: "" });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx);
+
+    // LLM returned "medium" — it must not be overwritten with undefined
+    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 () => {
+    // Story has explicit values for both fields
+    const story = makeStory({
+      complexity: "simple",
+      testStrategy: "test-after",
+      reasoning: "manual override",
+    });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx);
+
+    // Both fields should be overridden from the story
+    expect(ctx.routing.complexity).toBe("simple");
+    expect(ctx.routing.testStrategy).toBe("test-after");
+  });
+});