@nathapp/nax 0.28.0 → 0.30.0

package/test/integration/pipeline/verify-stage.test.ts

@@ -1,286 +0,0 @@
-// RE-ARCH: rewrite
-
-/**
- * Verify Stage Tests
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { NaxConfig } from "../../../src/config/schema";
-import { initLogger, resetLogger } from "../../../src/logger";
-import { verifyStage } from "../../../src/pipeline/stages/verify";
-import type { PipelineContext } from "../../../src/pipeline/types";
-import type { PRD, UserStory } from "../../../src/prd/types";
-
-/** Helper: Create minimal test context */
-function createTestContext(overrides?: Partial<PipelineContext>): PipelineContext {
-  const story: UserStory = {
-    id: "US-001",
-    title: "Test Story",
-    description: "Test description",
-    acceptanceCriteria: ["Test passes"],
-    tags: [],
-    dependencies: [],
-    status: "pending",
-    passes: false,
-    escalations: [],
-    attempts: 0,
-  };
-
-  const prd: PRD = {
-    project: "test-project",
-    feature: "test-feature",
-    branchName: "test-branch",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    userStories: [story],
-  };
-
-  const config: NaxConfig = {
-    version: 1,
-    models: {
-      fast: "claude-sonnet-4-5",
-      balanced: "claude-sonnet-4-5",
-      powerful: "claude-opus-4-6",
-    },
-    autoMode: {
-      enabled: true,
-      defaultAgent: "nax-agent-claude",
-      fallbackOrder: ["nax-agent-claude"],
-      complexityRouting: {
-        simple: "fast",
-        medium: "balanced",
-        complex: "powerful",
-        expert: "powerful",
-      },
-      escalation: {
-        enabled: true,
-        maxAttempts: 3,
-      },
-    },
-    execution: {
-      maxIterations: 100,
-      iterationDelayMs: 1000,
-      costLimit: 50,
-      sessionTimeoutSeconds: 600,
-      verificationTimeoutSeconds: 30,
-      maxStoriesPerFeature: 50,
-    },
-    quality: {
-      requireTypecheck: false,
-      requireLint: false,
-      requireTests: true,
-      commands: {},
-    },
-    tdd: {
-      maxRetries: 3,
-      autoVerifyIsolation: true,
-      autoApproveVerifier: true,
-    },
-    constitution: {
-      enabled: false,
-      path: "constitution.md",
-      maxTokens: 2000,
-    },
-    analyze: {
-      llmEnhanced: false,
-      model: "balanced",
-      fallbackToKeywords: true,
-      maxCodebaseSummaryTokens: 4000,
-    },
-    review: {
-      enabled: true,
-      checks: ["test"],
-      commands: {},
-    },
-    plan: {
-      model: "balanced",
-      outputPath: "features",
-    },
-  };
-
-  return {
-    config,
-    prd,
-    story,
-    stories: [story],
-    routing: {
-      complexity: "simple",
-      modelTier: "fast",
-      testStrategy: "test-after",
-      reasoning: "Test routing",
-    },
-    workdir: "/test/workdir",
-    hooks: { hooks: {} },
-    ...overrides,
-  };
-}
-
-describe("Verify Stage", () => {
-  beforeEach(() => {
-    initLogger({ level: "error", useChalk: false });
-  });
-
-  afterEach(() => {
-    resetLogger();
-  });
-
-  test("verifyStage is always enabled", () => {
-    const ctx = createTestContext();
-    expect(verifyStage.enabled(ctx)).toBe(true);
-  });
-
-  test("passes when tests succeed", async () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
-
-    const ctx = createTestContext({
-      workdir: tempDir,
-      config: {
-        ...createTestContext().config,
-        review: {
-          enabled: true,
-          checks: ["test"],
-          commands: {
-            test: "echo 'Tests passed'",
-          },
-        },
-      },
-    });
-
-    const result = await verifyStage.execute(ctx);
-
-    expect(result.action).toBe("continue");
-  });
-
-  test("fails when tests fail", async () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
-
-    const ctx = createTestContext({
-      workdir: tempDir,
-      config: {
-        ...createTestContext().config,
-        execution: {
-          ...createTestContext().config.execution,
-          regressionGate: {
-            enabled: true,
-            timeoutSeconds: 30,
-            acceptOnTimeout: false,
-            mode: "per-story", // Override for this specific test
-          },
-        },
-        review: {
-          enabled: true,
-          checks: ["test"],
-          commands: {
-            test: "sh -c 'exit 1'",
-          },
-        },
-      },
-    });
-
-    const result = await verifyStage.execute(ctx);
-
-    expect(result.action).toBe("escalate");
-    if (result.action === "escalate") {
-      expect(result.reason).toContain("Tests failed");
-      // Exit code may vary by shell - just check it mentions exit code
-      expect(result.reason).toMatch(/exit code/);
-    }
-  });
-
-  test("uses default test command when not configured", async () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
-
-    // Create a simple package.json to make bun test work
-    await Bun.write(join(tempDir, "package.json"), JSON.stringify({ name: "test" }));
-
-    const ctx = createTestContext({
-      workdir: tempDir,
-      config: {
-        ...createTestContext().config,
-        review: {
-          enabled: true,
-          checks: ["test"],
-          commands: {}, // No custom command
-        },
-      },
-    });
-
-    const result = await verifyStage.execute(ctx);
-
-    // No test command configured → stage skips (returns continue)
-    // This is correct behaviour: don't run tests if none configured
-    expect(result.action).toBe("continue");
-  });
-
-  test("uses custom test command from config", async () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
-
-    const ctx = createTestContext({
-      workdir: tempDir,
-      config: {
-        ...createTestContext().config,
-        review: {
-          enabled: true,
-          checks: ["test"],
-          commands: {
-            test: "echo 'custom test command'",
-          },
-        },
-      },
-    });
-
-    const result = await verifyStage.execute(ctx);
-
-    expect(result.action).toBe("continue");
-  });
-
-  test("handles test command with arguments", async () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
-
-    const ctx = createTestContext({
-      workdir: tempDir,
-      config: {
-        ...createTestContext().config,
-        review: {
-          enabled: true,
-          checks: ["test"],
-          commands: {
-            test: "echo 'test' && echo 'with args'",
-          },
-        },
-      },
-    });
-
-    const result = await verifyStage.execute(ctx);
-
-    expect(result.action).toBe("continue");
-  });
-
-  test.skip("handles test command that throws error — hangs on nonexistent-command (TODO: fix timeout handling)", async () => {
-    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
-
-    const ctx = createTestContext({
-      workdir: tempDir,
-      config: {
-        ...createTestContext().config,
-        review: {
-          enabled: true,
-          checks: ["test"],
-          commands: {
-            test: "nonexistent-command",
-          },
-        },
-      },
-    });
-
-    const result = await verifyStage.execute(ctx);
-
-    expect(result.action).toBe("escalate");
-    if (result.action === "fail") {
-      expect(result.reason).toContain("Tests failed");
-    }
-  });
-});

package/test/integration/plan/analyze-integration.test.ts

@@ -1,262 +0,0 @@
-// RE-ARCH: keep
-/**
- * Integration Tests for Analyze Command
- */
-
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { analyzeFeature } from "../../../src/cli/analyze";
-import { DEFAULT_CONFIG } from "../../../src/config";
-
-describe("analyzeFeature integration", () => {
-  const testDir = "/tmp/nax-analyze-test";
-  const featureDir = join(testDir, "nax/features/test-feature");
-
-  beforeAll(() => {
-    // Create test directory structure
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true });
-    }
-    mkdirSync(featureDir, { recursive: true });
-
-    // Create test spec.md
-    const specContent = `# Test Feature
-
-## US-001: Add user authentication
-
-### Description
-Implement JWT-based authentication with refresh tokens.
-
-### Acceptance Criteria
-- [ ] User can log in with email/password
-- [ ] JWT token is generated and stored
-- [ ] Refresh token logic works
-- [ ] Token expiry is handled
-
-Tags: security, auth
-Dependencies: none
-
-## US-002: Update homepage UI
-
-### Description
-Refresh the homepage design with new color scheme.
-
-### Acceptance Criteria
-- [ ] New colors applied
-- [ ] Layout is responsive
-
-Tags: ui
-Dependencies: none
-`;
-
-    Bun.write(join(featureDir, "spec.md"), specContent);
-
-    // Create mock src/ directory
-    mkdirSync(join(testDir, "src"), { recursive: true });
-    Bun.write(join(testDir, "src/index.ts"), "export {}");
-
-    // Create mock package.json
-    Bun.write(
-      join(testDir, "package.json"),
-      JSON.stringify({
-        name: "test-project",
-        dependencies: { zod: "^4.0.0" },
-        devDependencies: { typescript: "^5.0.0" },
-      }),
-    );
-  });
-
-  afterAll(() => {
-    // Cleanup
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true });
-    }
-  });
-
-  test("parses spec.md into PRD structure", async () => {
-    const config = {
-      ...DEFAULT_CONFIG,
-      analyze: {
-        llmEnhanced: false, // Disable LLM for predictable tests
-        model: "fast" as const,
-        fallbackToKeywords: true,
-        maxCodebaseSummaryTokens: 5000,
-      },
-    };
-
-    const prd = await analyzeFeature({
-      featureDir,
-      featureName: "test-feature",
-      branchName: "feat/test-feature",
-      config,
-    });
-
-    expect(prd.project).toBe("nax");
-    expect(prd.feature).toBe("test-feature");
-    expect(prd.branchName).toBe("feat/test-feature");
-    expect(prd.userStories).toHaveLength(2);
-  });
-
-  test("extracts story metadata correctly", async () => {
-    const config = {
-      ...DEFAULT_CONFIG,
-      analyze: {
-        llmEnhanced: false,
-        model: "fast" as const,
-        fallbackToKeywords: true,
-        maxCodebaseSummaryTokens: 5000,
-      },
-    };
-
-    const prd = await analyzeFeature({
-      featureDir,
-      featureName: "test-feature",
-      branchName: "feat/test-feature",
-      config,
-    });
-
-    const story1 = prd.userStories[0];
-    expect(story1.id).toBe("US-001");
-    expect(story1.title).toBe("Add user authentication");
-    expect(story1.description).toContain("JWT-based authentication");
-    expect(story1.acceptanceCriteria).toHaveLength(4);
-    expect(story1.tags).toContain("security");
-    expect(story1.tags).toContain("auth");
-    expect(story1.status).toBe("pending");
-    expect(story1.passes).toBe(false);
-  });
-
-  test("applies routing when LLM disabled (keyword fallback)", async () => {
-    const config = {
-      ...DEFAULT_CONFIG,
-      analyze: {
-        llmEnhanced: false,
-        model: "fast" as const,
-        fallbackToKeywords: true,
-        maxCodebaseSummaryTokens: 5000,
-      },
-    };
-
-    const prd = await analyzeFeature({
-      featureDir,
-      featureName: "test-feature",
-      branchName: "feat/test-feature",
-      config,
-    });
-
-    // Routing should be applied with keyword classification
-    expect(prd.userStories[0].routing).toBeDefined();
-    expect(prd.userStories[1].routing).toBeDefined();
-  });
-
-  test.skip("scans codebase when LLM enabled", async () => {
-    // Skipped: This test would require a real agent installation and API key
-    // The LLM decompose flow is tested in unit tests with mocked agents
-    const config = {
-      ...DEFAULT_CONFIG,
-      analyze: {
-        llmEnhanced: true,
-        model: "fast" as const,
-        fallbackToKeywords: true,
-        maxCodebaseSummaryTokens: 5000,
-      },
-    };
-
-    // This will trigger LLM decompose (will fall back due to no agent in test)
-    const prd = await analyzeFeature({
-      featureDir,
-      featureName: "test-feature",
-      branchName: "feat/test-feature",
-      config,
-    });
-
-    // Should have routing metadata from keyword fallback
-    expect(prd.userStories[0].routing).toBeDefined();
-    expect(prd.userStories[1].routing).toBeDefined();
-
-    // First story should be complex (security keywords)
-    expect(prd.userStories[0].routing?.complexity).toBe("complex");
-
-    // Second story should be simple
-    expect(prd.userStories[1].routing?.complexity).toBe("simple");
-  });
-
-  test("throws error when spec.md missing", async () => {
-    const emptyDir = "/tmp/nax-empty-test";
-    mkdirSync(emptyDir, { recursive: true });
-
-    try {
-      await expect(
-        analyzeFeature({
-          featureDir: emptyDir,
-          featureName: "empty",
-          branchName: "feat/empty",
-        }),
-      ).rejects.toThrow("spec.md not found");
-    } finally {
-      rmSync(emptyDir, { recursive: true });
-    }
-  });
-
-  test("throws error when no stories found", async () => {
-    const noStoriesDir = "/tmp/nax-no-stories-test";
-    const featurePath = join(noStoriesDir, "nax/features/test");
-    mkdirSync(featurePath, { recursive: true });
-
-    // Create empty spec.md
-    await Bun.write(join(featurePath, "spec.md"), "# Empty\n\nNo stories here.");
-
-    try {
-      await expect(
-        analyzeFeature({
-          featureDir: featurePath,
-          featureName: "test",
-          branchName: "feat/test",
-        }),
-      ).rejects.toThrow("No user stories found");
-    } finally {
-      rmSync(noStoriesDir, { recursive: true });
-    }
-  });
-
-  test("warns but succeeds when story count exceeds maxStoriesPerFeature limit", async () => {
-    const manyStoriesDir = "/tmp/nax-many-stories-test";
-    const featurePath = join(manyStoriesDir, "nax/features/test");
-    mkdirSync(featurePath, { recursive: true });
-
-    // Create spec.md with 6 stories (exceeds limit of 5)
-    let specContent = "# Many Stories\n\n";
-    for (let i = 1; i <= 6; i++) {
-      specContent += `## US-${String(i).padStart(3, "0")}: Story ${i}\n\n`;
-      specContent += `### Description\nStory ${i}\n\n`;
-      specContent += `### Acceptance Criteria\n- [ ] Done\n\n`;
-    }
-    await Bun.write(join(featurePath, "spec.md"), specContent);
-
-    const config = {
-      ...DEFAULT_CONFIG,
-      execution: {
-        ...DEFAULT_CONFIG.execution,
-        maxStoriesPerFeature: 5,
-      },
-      analyze: {
-        ...DEFAULT_CONFIG.analyze,
-        llmEnhanced: false,
-      },
-    };
-
-    try {
-      // Should warn but not throw (changed from hard error to warning)
-      const prd = await analyzeFeature({
-        featureDir: featurePath,
-        featureName: "test",
-        branchName: "feat/test",
-        config,
-      });
-      expect(prd.userStories.length).toBe(6);
-    } finally {
-      rmSync(manyStoriesDir, { recursive: true });
-    }
-  });
-});

package/test/integration/plan/analyze-scanner.test.ts

@@ -1,132 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for Codebase Scanner
- */
-
-import { describe, expect, test } from "bun:test";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { scanCodebase } from "../../../src/analyze/scanner";
-
-describe("scanCodebase", () => {
-  test("scans project codebase successfully", async () => {
-    // Use the nax project itself as test data
-    const workdir = join(import.meta.dir, "../..");
-
-    const scan = await scanCodebase(workdir);
-
-    // Should have file tree
-    expect(scan.fileTree).toBeTruthy();
-    expect(typeof scan.fileTree).toBe("string");
-    expect(scan.fileTree.length).toBeGreaterThan(0);
-
-    // Should have dependencies
-    expect(scan.dependencies).toBeDefined();
-    expect(typeof scan.dependencies).toBe("object");
-
-    // Should have dev dependencies
-    expect(scan.devDependencies).toBeDefined();
-    expect(typeof scan.devDependencies).toBe("object");
-
-    // Should detect test patterns
-    expect(scan.testPatterns).toBeDefined();
-    expect(Array.isArray(scan.testPatterns)).toBe(true);
-    expect(scan.testPatterns.length).toBeGreaterThan(0);
-  });
-
-  test("handles missing src directory", async () => {
-    const workdir = "/tmp/nax-test-no-src";
-
-    // Create temp dir without src/
-    await Bun.write(join(workdir, "package.json"), JSON.stringify({}));
-
-    const scan = await scanCodebase(workdir);
-
-    // Should return placeholder for missing src
-    expect(scan.fileTree).toBe("No src/ directory");
-    expect(scan.dependencies).toEqual({});
-    expect(scan.devDependencies).toEqual({});
-  });
-
-  test(
-    "extracts dependencies from package.json",
-    async () => {
-      const workdir = join(import.meta.dir, "../../..");
-
-      const scan = await scanCodebase(workdir);
-
-      // Should have zod dependency (from real package.json)
-      expect(scan.dependencies.zod).toBeTruthy();
-      expect(scan.dependencies.commander).toBeTruthy();
-    },
-    30000,
-  );
-
-  test(
-    "detects test framework",
-    async () => {
-      const workdir = join(import.meta.dir, "../../..");
-
-      const scan = await scanCodebase(workdir);
-
-      // Should detect bun:test (no framework in package.json)
-      const hasBunTest = scan.testPatterns.some((p) => p.includes("bun:test"));
-      expect(hasBunTest).toBe(true);
-    },
-    30000,
-  );
-
-  test(
-    "detects test directory",
-    async () => {
-      const workdir = join(import.meta.dir, "../../..");
-
-      const scan = await scanCodebase(workdir);
-
-      // Should detect test/ directory
-      const hasTestDir = scan.testPatterns.some((p) => p.includes("test/"));
-      expect(hasTestDir).toBe(true);
-    },
-    30000,
-  );
-
-  test(
-    "file tree respects max depth",
-    async () => {
-      const workdir = join(import.meta.dir, "../../..");
-
-      const scan = await scanCodebase(workdir);
-
-      // File tree should not be excessively deep (max depth 3)
-      const lines = scan.fileTree.split("\n");
-      const maxIndent = Math.max(
-        ...lines.map((line) => {
-          const match = line.match(/^(│ {3}| {4})*/);
-          return match ? match[0].length / 4 : 0;
-        }),
-      );
-
-      // Max depth 3 means max indent of 2 (0-indexed)
-      expect(maxIndent).toBeLessThanOrEqual(3);
-    },
-    30000,
-  );
-
-  test(
-    "file tree includes directories and files",
-    async () => {
-      const workdir = join(import.meta.dir, "../../..");
-
-      const scan = await scanCodebase(workdir);
-
-      // Should contain directories (marked with trailing /)
-      const hasDirectories = scan.fileTree.includes("/");
-      expect(hasDirectories).toBe(true);
-
-      // Should contain some TypeScript files
-      const hasTsFiles = scan.fileTree.includes(".ts");
-      expect(hasTsFiles).toBe(true);
-    },
-    30000,
-  );
-});