@nathapp/nax 0.18.1

package/test/unit/analyze-classifier.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Tests for LLM Classifier
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { CodebaseScan } from "../../src/analyze";
+import { classifyStories } from "../../src/analyze/classifier";
+import { DEFAULT_CONFIG } from "../../src/config";
+import type { UserStory } from "../../src/prd";
+
+describe("classifyStories", () => {
+  const mockScan: CodebaseScan = {
+    fileTree: "src/\n├── index.ts\n└── utils/\n    └── helper.ts",
+    dependencies: { zod: "^4.0.0" },
+    devDependencies: { typescript: "^5.0.0" },
+    testPatterns: ["Test framework: bun:test", "Test directory: test/"],
+  };
+
+  const mockStories: UserStory[] = [
+    {
+      id: "US-001",
+      title: "Add input validation",
+      description: "Validate user inputs with Zod schemas",
+      acceptanceCriteria: ["Schema defined", "Validation works"],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    },
+  ];
+
+  test("falls back to keyword matching when LLM disabled", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        llmEnhanced: false,
+        classifierModel: "fast" as const,
+        fallbackToKeywords: true,
+        maxCodebaseSummaryTokens: 5000,
+      },
+    };
+
+    const result = await classifyStories(mockStories, mockScan, config);
+
+    expect(result.method).toBe("keyword-fallback");
+    expect(result.fallbackReason).toBe("LLM-enhanced analysis disabled in config");
+    expect(result.classifications).toHaveLength(1);
+    expect(result.classifications[0].storyId).toBe("US-001");
+  });
+
+  test("falls back to keyword matching when ANTHROPIC_API_KEY missing", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        llmEnhanced: true,
+        classifierModel: "fast" as const,
+        fallbackToKeywords: true,
+        maxCodebaseSummaryTokens: 5000,
+      },
+    };
+
+    // Temporarily unset API key
+    const originalKey = process.env.ANTHROPIC_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+
+    try {
+      const result = await classifyStories(mockStories, mockScan, config);
+
+      expect(result.method).toBe("keyword-fallback");
+      expect(result.fallbackReason).toContain("ANTHROPIC_API_KEY");
+      expect(result.classifications).toHaveLength(1);
+    } finally {
+      // Restore API key
+      if (originalKey) {
+        process.env.ANTHROPIC_API_KEY = originalKey;
+      }
+    }
+  });
+
+  test("keyword fallback classification includes all required fields", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        llmEnhanced: false,
+        classifierModel: "fast" as const,
+        fallbackToKeywords: true,
+        maxCodebaseSummaryTokens: 5000,
+      },
+    };
+
+    const result = await classifyStories(mockStories, mockScan, config);
+
+    const classification = result.classifications[0];
+    expect(classification.storyId).toBe("US-001");
+    expect(classification.complexity).toMatch(/simple|medium|complex|expert/);
+    expect(classification.contextFiles).toEqual([]);
+    expect(classification.reasoning).toContain("Keyword-based classification");
+    expect(typeof classification.estimatedLOC).toBe("number");
+    expect(classification.estimatedLOC).toBeGreaterThan(0);
+    expect(classification.risks).toEqual([]);
+  });
+
+  test("classifies simple stories correctly in keyword mode", async () => {
+    const simpleStory: UserStory = {
+      id: "US-002",
+      title: "Update button color",
+      description: "Change primary button to blue",
+      acceptanceCriteria: ["Button is blue"],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const config = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        llmEnhanced: false,
+        classifierModel: "fast" as const,
+        fallbackToKeywords: true,
+        maxCodebaseSummaryTokens: 5000,
+      },
+    };
+
+    const result = await classifyStories([simpleStory], mockScan, config);
+
+    expect(result.classifications[0].complexity).toBe("simple");
+    expect(result.classifications[0].estimatedLOC).toBe(50); // Simple = 50 LOC
+  });
+
+  test("classifies complex stories correctly in keyword mode", async () => {
+    const complexStory: UserStory = {
+      id: "US-003",
+      title: "Add JWT authentication",
+      description: "Implement secure JWT authentication with refresh tokens",
+      acceptanceCriteria: [
+        "Token generation",
+        "Token validation",
+        "Refresh logic",
+        "Expiry handling",
+        "Secure storage",
+      ],
+      tags: ["security", "auth"],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const config = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        llmEnhanced: false,
+        classifierModel: "fast" as const,
+        fallbackToKeywords: true,
+        maxCodebaseSummaryTokens: 5000,
+      },
+    };
+
+    const result = await classifyStories([complexStory], mockScan, config);
+
+    expect(result.classifications[0].complexity).toBe("complex");
+    expect(result.classifications[0].estimatedLOC).toBe(400); // Complex = 400 LOC
+  });
+
+  test("processes multiple stories", async () => {
+    const stories: UserStory[] = [
+      {
+        id: "US-001",
+        title: "Story 1",
+        description: "First story",
+        acceptanceCriteria: ["AC1"],
+        tags: [],
+        dependencies: [],
+        status: "pending",
+        passes: false,
+        escalations: [],
+        attempts: 0,
+      },
+      {
+        id: "US-002",
+        title: "Story 2",
+        description: "Second story",
+        acceptanceCriteria: ["AC2"],
+        tags: [],
+        dependencies: [],
+        status: "pending",
+        passes: false,
+        escalations: [],
+        attempts: 0,
+      },
+    ];
+
+    const config = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        llmEnhanced: false,
+        classifierModel: "fast" as const,
+        fallbackToKeywords: true,
+        maxCodebaseSummaryTokens: 5000,
+      },
+    };
+
+    const result = await classifyStories(stories, mockScan, config);
+
+    expect(result.classifications).toHaveLength(2);
+    expect(result.classifications[0].storyId).toBe("US-001");
+    expect(result.classifications[1].storyId).toBe("US-002");
+  });
+});

package/test/unit/analyze.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "bun:test";
+import { analyzeFeature } from "../../src/cli/analyze";
+import type { NaxConfig } from "../../src/config";
+import { DEFAULT_CONFIG } from "../../src/config/schema";
+
+describe("analyzeFeature", () => {
+  test("parses spec.md into user stories (LLM disabled, keyword fallback)", async () => {
+    const tmpDir = `/tmp/nax-analyze-${Date.now()}`;
+    await Bun.spawn(["mkdir", "-p", tmpDir], { stdout: "pipe" }).exited;
+
+    await Bun.write(
+      `${tmpDir}/spec.md`,
+      `# Feature: Auth System
+
+## US-001: Add login endpoint
+
+### Description
+Create a POST /auth/login endpoint that accepts email and password.
+
+### Acceptance Criteria
+- [ ] Endpoint returns JWT token on success
+- [ ] Returns 401 on invalid credentials
+- [ ] Rate limited to 5 attempts per minute
+
+Tags: security, auth
+Dependencies: US-000
+
+## US-002: Add logout endpoint
+
+### Description
+Create a POST /auth/logout endpoint.
+
+### Acceptance Criteria
+- [ ] Invalidates the current token
+- [ ] Returns 200 on success
+
+Dependencies: US-001
+`,
+    );
+
+    // Disable LLM for keyword-based classification
+    const config: NaxConfig = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        ...DEFAULT_CONFIG.analyze,
+        llmEnhanced: false,
+      },
+    };
+
+    const prd = await analyzeFeature({
+      featureDir: tmpDir,
+      featureName: "auth",
+      branchName: "feat/auth",
+      config,
+    });
+
+    expect(prd.feature).toBe("auth");
+    expect(prd.branchName).toBe("feat/auth");
+    expect(prd.userStories).toHaveLength(2);
+
+    const s1 = prd.userStories[0];
+    expect(s1.id).toBe("US-001");
+    expect(s1.title).toBe("Add login endpoint");
+    expect(s1.acceptanceCriteria).toHaveLength(3);
+    expect(s1.tags).toContain("security");
+    expect(s1.dependencies).toContain("US-000");
+
+    const s2 = prd.userStories[1];
+    expect(s2.id).toBe("US-002");
+    expect(s2.title).toBe("Add logout endpoint");
+    expect(s2.acceptanceCriteria).toHaveLength(2);
+    expect(s2.dependencies).toContain("US-001");
+
+    await Bun.spawn(["rm", "-rf", tmpDir], { stdout: "pipe" }).exited;
+  });
+
+  test("throws when spec.md is missing", async () => {
+    const tmpDir = `/tmp/nax-analyze-empty-${Date.now()}`;
+    await Bun.spawn(["mkdir", "-p", tmpDir], { stdout: "pipe" }).exited;
+
+    await expect(
+      analyzeFeature({
+        featureDir: tmpDir,
+        featureName: "test",
+        branchName: "feat/test",
+      }),
+    ).rejects.toThrow("spec.md not found");
+
+    await Bun.spawn(["rm", "-rf", tmpDir], { stdout: "pipe" }).exited;
+  });
+
+  test("warns but does not throw when story count exceeds maxStoriesPerFeature limit", async () => {
+    const tmpDir = `/tmp/nax-analyze-limit-${Date.now()}`;
+    await Bun.spawn(["mkdir", "-p", tmpDir], { stdout: "pipe" }).exited;
+
+    // Generate spec.md with 6 stories
+    const stories = Array.from(
+      { length: 6 },
+      (_, i) => `
+## US-${String(i + 1).padStart(3, "0")}: Story ${i + 1}
+
+### Description
+Description for story ${i + 1}
+
+### Acceptance Criteria
+- [ ] Criterion 1
+`,
+    ).join("\n");
+
+    await Bun.write(`${tmpDir}/spec.md`, `# Feature\n${stories}`);
+
+    // Create config with limit of 5 stories (LLM disabled)
+    const config: NaxConfig = {
+      ...DEFAULT_CONFIG,
+      execution: {
+        ...DEFAULT_CONFIG.execution,
+        maxStoriesPerFeature: 5,
+      },
+      analyze: {
+        ...DEFAULT_CONFIG.analyze,
+        llmEnhanced: false,
+      },
+    };
+
+    // Should warn but still succeed (no longer throws)
+    const prd = await analyzeFeature({
+      featureDir: tmpDir,
+      featureName: "test",
+      branchName: "feat/test",
+      config,
+    });
+
+    expect(prd.userStories.length).toBe(6);
+
+    await Bun.spawn(["rm", "-rf", tmpDir], { stdout: "pipe" }).exited;
+  });
+
+  test("allows story count at maxStoriesPerFeature limit", async () => {
+    const tmpDir = `/tmp/nax-analyze-ok-${Date.now()}`;
+    await Bun.spawn(["mkdir", "-p", tmpDir], { stdout: "pipe" }).exited;
+
+    // Generate spec.md with exactly 5 stories
+    const stories = Array.from(
+      { length: 5 },
+      (_, i) => `
+## US-${String(i + 1).padStart(3, "0")}: Story ${i + 1}
+
+### Description
+Description for story ${i + 1}
+
+### Acceptance Criteria
+- [ ] Criterion 1
+`,
+    ).join("\n");
+
+    await Bun.write(`${tmpDir}/spec.md`, `# Feature\n${stories}`);
+
+    // Create config with limit of 5 stories (LLM disabled)
+    const config: NaxConfig = {
+      ...DEFAULT_CONFIG,
+      execution: {
+        ...DEFAULT_CONFIG.execution,
+        maxStoriesPerFeature: 5,
+      },
+      analyze: {
+        ...DEFAULT_CONFIG.analyze,
+        llmEnhanced: false,
+      },
+    };
+
+    // Should NOT throw because 5 === 5
+    const prd = await analyzeFeature({
+      featureDir: tmpDir,
+      featureName: "test",
+      branchName: "feat/test",
+      config,
+    });
+    expect(prd.userStories).toHaveLength(5);
+
+    await Bun.spawn(["rm", "-rf", tmpDir], { stdout: "pipe" }).exited;
+  });
+
+  test("reads spec from explicit --from path", async () => {
+    const tmpDir = `/tmp/nax-analyze-from-${Date.now()}`;
+    await Bun.spawn(["mkdir", "-p", tmpDir], { stdout: "pipe" }).exited;
+
+    const customSpecPath = `${tmpDir}/custom-spec.md`;
+    await Bun.write(
+      customSpecPath,
+      `# Custom Spec
+
+## US-001: Custom story
+
+### Description
+A custom story from explicit path
+
+### Acceptance Criteria
+- [ ] Works with --from flag
+`,
+    );
+
+    const config: NaxConfig = {
+      ...DEFAULT_CONFIG,
+      analyze: {
+        ...DEFAULT_CONFIG.analyze,
+        llmEnhanced: false,
+      },
+    };
+
+    const prd = await analyzeFeature({
+      featureDir: tmpDir,
+      featureName: "custom",
+      branchName: "feat/custom",
+      config,
+      specPath: customSpecPath,
+    });
+
+    expect(prd.userStories).toHaveLength(1);
+    expect(prd.userStories[0].id).toBe("US-001");
+    expect(prd.userStories[0].title).toBe("Custom story");
+
+    await Bun.spawn(["rm", "-rf", tmpDir], { stdout: "pipe" }).exited;
+  });
+});

package/test/unit/auto-detect.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Tests for context auto-detection (BUG-006)
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { autoDetectContextFiles, extractKeywords } from "../../src/context/auto-detect";
+
+describe("Context Auto-Detection", () => {
+  describe("extractKeywords", () => {
+    test("should extract keywords from simple title", () => {
+      const keywords = extractKeywords("BUG-006: Context auto-detection");
+      expect(keywords).toContain("006");
+      expect(keywords).toContain("context");
+      expect(keywords).toContain("auto");
+      expect(keywords).toContain("detection");
+    });
+
+    test("should remove common stop words", () => {
+      const keywords = extractKeywords("Add the new feature for user authentication");
+      expect(keywords).not.toContain("the");
+      expect(keywords).not.toContain("for");
+      expect(keywords).not.toContain("add");
+      expect(keywords).toContain("new");
+      expect(keywords).toContain("feature");
+      expect(keywords).toContain("user");
+      expect(keywords).toContain("authentication");
+    });
+
+    test("should handle punctuation and special chars", () => {
+      const keywords = extractKeywords("Fix: API endpoint (v2) - rate-limiting");
+      expect(keywords).toContain("api");
+      expect(keywords).toContain("endpoint");
+      expect(keywords).toContain("rate");
+      expect(keywords).toContain("limiting");
+    });
+
+    test("should deduplicate keywords", () => {
+      const keywords = extractKeywords("Context context CONTEXT");
+      expect(keywords.filter((k) => k === "context")).toHaveLength(1);
+    });
+
+    test("should filter short words (< 3 chars)", () => {
+      const keywords = extractKeywords("Fix a bug in UI");
+      expect(keywords).not.toContain("in");
+      expect(keywords).not.toContain("ui"); // length 2
+    });
+
+    test("should return empty array for title with only stop words", () => {
+      const keywords = extractKeywords("The and or to");
+      expect(keywords).toHaveLength(0);
+    });
+
+    test("should lowercase all keywords", () => {
+      const keywords = extractKeywords("UPPERCASE lowercase MixedCase");
+      expect(keywords).toContain("uppercase");
+      expect(keywords).toContain("lowercase");
+      expect(keywords).toContain("mixedcase");
+      expect(keywords).not.toContain("UPPERCASE");
+      expect(keywords).not.toContain("MixedCase");
+    });
+  });
+
+  describe("autoDetectContextFiles", () => {
+    let tempDir: string;
+
+    beforeEach(async () => {
+      // Create temp git repo
+      tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-autodetect-test-"));
+      await Bun.spawn(["git", "init"], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "config", "user.email", "test@test.com"], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "config", "user.name", "Test User"], { cwd: tempDir }).exited;
+    });
+
+    afterEach(async () => {
+      // Clean up
+      await fs.rm(tempDir, { recursive: true, force: true });
+    });
+
+    test("should detect files matching keywords", async () => {
+      // Create test files
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src/context-builder.ts"), "export function buildContext() {}");
+      await fs.writeFile(path.join(tempDir, "src/auto-detect.ts"), "export function autoDetectContextFiles() {}");
+      await fs.writeFile(path.join(tempDir, "src/unrelated.ts"), "export function foo() {}");
+
+      // Commit files so git grep can find them
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "BUG-006: Context auto-detection",
+        maxFiles: 5,
+      });
+
+      expect(files).toContain("src/context-builder.ts");
+      expect(files).toContain("src/auto-detect.ts");
+      expect(files).not.toContain("src/unrelated.ts");
+    });
+
+    test("should exclude test files", async () => {
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      await fs.mkdir(path.join(tempDir, "test"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src/context.ts"), "export function buildContext() {}");
+      await fs.writeFile(path.join(tempDir, "test/context.test.ts"), "test('context', () => {})");
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "Context builder",
+        maxFiles: 5,
+      });
+
+      expect(files).toContain("src/context.ts");
+      expect(files).not.toContain("test/context.test.ts");
+    });
+
+    test("should exclude index files", async () => {
+      await fs.mkdir(path.join(tempDir, "src/context"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src/context/index.ts"), "export * from './builder'");
+      await fs.writeFile(path.join(tempDir, "src/context/builder.ts"), "export function buildContext() {}");
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "Context builder",
+        maxFiles: 5,
+      });
+
+      expect(files).toContain("src/context/builder.ts");
+      expect(files).not.toContain("src/context/index.ts");
+    });
+
+    test("should respect maxFiles limit", async () => {
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      for (let i = 1; i <= 10; i++) {
+        await fs.writeFile(path.join(tempDir, `src/file${i}.ts`), `// Contains keyword: routing`);
+      }
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "Routing system",
+        maxFiles: 3,
+      });
+
+      expect(files.length).toBeLessThanOrEqual(3);
+    });
+
+    test("should return empty array when no matches", async () => {
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src/unrelated.ts"), "export function foo() {}");
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "NonExistentKeyword XYZ123",
+        maxFiles: 5,
+      });
+
+      expect(files).toHaveLength(0);
+    });
+
+    test("should return empty array when no keywords extracted", async () => {
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src/file.ts"), "export function test() {}");
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "the and or", // All stop words
+        maxFiles: 5,
+      });
+
+      expect(files).toHaveLength(0);
+    });
+
+    test("should handle non-git directory gracefully", async () => {
+      // Create non-git temp dir
+      const nonGitDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-nongit-"));
+      await fs.mkdir(path.join(nonGitDir, "src"), { recursive: true });
+      await fs.writeFile(path.join(nonGitDir, "src/file.ts"), "export function test() {}");
+
+      const files = await autoDetectContextFiles({
+        workdir: nonGitDir,
+        storyTitle: "Test story",
+        maxFiles: 5,
+      });
+
+      expect(files).toHaveLength(0);
+
+      // Clean up
+      await fs.rm(nonGitDir, { recursive: true, force: true });
+    });
+
+    test("should sort files by relevance score", async () => {
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      // File with 2 keyword matches
+      await fs.writeFile(path.join(tempDir, "src/context-builder.ts"), "context builder code");
+      // File with 1 keyword match
+      await fs.writeFile(path.join(tempDir, "src/context-helper.ts"), "context helper code");
+      // File with 1 keyword match
+      await fs.writeFile(path.join(tempDir, "src/builder-utils.ts"), "builder utils code");
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "Context builder system",
+        maxFiles: 5,
+      });
+
+      // File with most keyword matches should be first
+      expect(files[0]).toBe("src/context-builder.ts");
+    });
+
+    test("should exclude generated files", async () => {
+      await fs.mkdir(path.join(tempDir, "src/__generated__"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src/__generated__/schema.ts"), "// generated schema");
+      await fs.writeFile(path.join(tempDir, "src/schema.ts"), "export const schema = {}");
+
+      await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
+      await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
+
+      const files = await autoDetectContextFiles({
+        workdir: tempDir,
+        storyTitle: "Schema validation",
+        maxFiles: 5,
+      });
+
+      expect(files).toContain("src/schema.ts");
+      expect(files).not.toContain("src/__generated__/schema.ts");
+    });
+  });
+});