@nathapp/nax 0.18.1

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

@@ -0,0 +1,261 @@
+/**
+ * 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/analyze-scanner.test.ts

@@ -0,0 +1,131 @@
+/**
+ * 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,
+  );
+});

package/test/integration/cli-config-default-edge-cases.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Edge Case Tests for `nax config` Default View
+ *
+ * Tests edge cases and regression scenarios for the default view.
+ * These tests ensure the feature handles unusual scenarios correctly.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+describe("nax config (default view) - edge cases", () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "nax-config-edge-test-"));
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  // NOTE: Error handling tests removed - those belong in a separate error handling story
+  // The current story (CM-003) focuses on the happy path: displaying config when files are valid
+
+  test("handles project config with only comments (valid but empty JSON)", async () => {
+    // Create project config with only {}
+    const naxDir = join(tempDir, "nax");
+    mkdirSync(naxDir, { recursive: true });
+    writeFileSync(join(naxDir, "config.json"), "{}");
+
+    process.chdir(tempDir);
+
+    const proc = Bun.spawn(["bun", join(import.meta.dir, "../../bin/nax.ts"), "config"], {
+      cwd: tempDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    expect(exitCode).toBe(0);
+
+    // Should show project config as found (even though it's empty)
+    expect(output).toContain("// Project config:");
+    expect(output).toContain("config.json");
+
+    // Should still output valid JSON (merged with defaults)
+    const lines = output.split("\n");
+    const jsonStartIndex = lines.findIndex((line) => line.startsWith("{"));
+    const jsonOutput = lines.slice(jsonStartIndex).join("\n");
+    const parsed = JSON.parse(jsonOutput);
+    expect(parsed.version).toBe(1);
+  });
+
+  test("handles deep nesting when walking up directory tree", async () => {
+    // Create project config at root
+    const naxDir = join(tempDir, "nax");
+    mkdirSync(naxDir, { recursive: true });
+    writeFileSync(
+      join(naxDir, "config.json"),
+      JSON.stringify({
+        execution: {
+          maxIterations: 50,
+        },
+      }),
+    );
+
+    // Create deeply nested subdirectory
+    const deepDir = join(tempDir, "a", "b", "c", "d", "e", "f");
+    mkdirSync(deepDir, { recursive: true });
+    process.chdir(deepDir);
+
+    const proc = Bun.spawn(["bun", join(import.meta.dir, "../../bin/nax.ts"), "config"], {
+      cwd: deepDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    expect(exitCode).toBe(0);
+
+    // Should find project config by walking up
+    expect(output).toContain("// Project config:");
+    expect(output).toContain("config.json");
+
+    // Should reflect merged config
+    const lines = output.split("\n");
+    const jsonStartIndex = lines.findIndex((line) => line.startsWith("{"));
+    const jsonOutput = lines.slice(jsonStartIndex).join("\n");
+    const parsed = JSON.parse(jsonOutput);
+    expect(parsed.execution.maxIterations).toBe(50);
+  });
+
+  test("outputs complete config structure with all top-level keys", async () => {
+    process.chdir(tempDir);
+
+    const proc = Bun.spawn(["bun", join(import.meta.dir, "../../bin/nax.ts"), "config"], {
+      cwd: tempDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    expect(exitCode).toBe(0);
+
+    const lines = output.split("\n");
+    const jsonStartIndex = lines.findIndex((line) => line.startsWith("{"));
+    const jsonOutput = lines.slice(jsonStartIndex).join("\n");
+    const parsed = JSON.parse(jsonOutput);
+
+    // Verify all required top-level keys are present
+    expect(parsed).toHaveProperty("version");
+    expect(parsed).toHaveProperty("models");
+    expect(parsed).toHaveProperty("autoMode");
+    expect(parsed).toHaveProperty("routing");
+    expect(parsed).toHaveProperty("execution");
+    expect(parsed).toHaveProperty("quality");
+    expect(parsed).toHaveProperty("tdd");
+    expect(parsed).toHaveProperty("constitution");
+    expect(parsed).toHaveProperty("analyze");
+    expect(parsed).toHaveProperty("review");
+    expect(parsed).toHaveProperty("plan");
+    expect(parsed).toHaveProperty("acceptance");
+    expect(parsed).toHaveProperty("context");
+    expect(parsed).toHaveProperty("interaction");
+    expect(parsed).toHaveProperty("precheck");
+  });
+
+  test("merges nested config overrides correctly", async () => {
+    // Create project config with nested overrides
+    const naxDir = join(tempDir, "nax");
+    mkdirSync(naxDir, { recursive: true });
+    writeFileSync(
+      join(naxDir, "config.json"),
+      JSON.stringify({
+        execution: {
+          maxIterations: 15,
+          rectification: {
+            enabled: false,
+            maxRetries: 5,
+          },
+        },
+      }),
+    );
+
+    process.chdir(tempDir);
+
+    const proc = Bun.spawn(["bun", join(import.meta.dir, "../../bin/nax.ts"), "config"], {
+      cwd: tempDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    expect(exitCode).toBe(0);
+
+    const lines = output.split("\n");
+    const jsonStartIndex = lines.findIndex((line) => line.startsWith("{"));
+    const jsonOutput = lines.slice(jsonStartIndex).join("\n");
+    const parsed = JSON.parse(jsonOutput);
+
+    // Verify nested overrides
+    expect(parsed.execution.maxIterations).toBe(15);
+    expect(parsed.execution.rectification.enabled).toBe(false);
+    expect(parsed.execution.rectification.maxRetries).toBe(5);
+
+    // Verify non-overridden fields are preserved
+    expect(parsed.execution.iterationDelayMs).toBeDefined();
+    expect(parsed.execution.rectification.fullSuiteTimeoutSeconds).toBeDefined();
+  });
+
+  test("handles project config with schema version mismatch", async () => {
+    // Create project config with future schema version
+    const naxDir = join(tempDir, "nax");
+    mkdirSync(naxDir, { recursive: true });
+    writeFileSync(
+      join(naxDir, "config.json"),
+      JSON.stringify({
+        version: 999, // Future version
+        execution: {
+          maxIterations: 25,
+        },
+      }),
+    );
+
+    process.chdir(tempDir);
+
+    const proc = Bun.spawn(["bun", join(import.meta.dir, "../../bin/nax.ts"), "config"], {
+      cwd: tempDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    // Should either succeed with warning or fail gracefully
+    if (exitCode !== 0) {
+      expect(stderr.toLowerCase()).toMatch(/error|invalid|version/);
+    } else {
+      // If it succeeds, verify output is valid
+      const lines = output.split("\n");
+      const jsonStartIndex = lines.findIndex((line) => line.startsWith("{"));
+      expect(jsonStartIndex).toBeGreaterThan(0);
+      const jsonOutput = lines.slice(jsonStartIndex).join("\n");
+      expect(() => JSON.parse(jsonOutput)).not.toThrow();
+    }
+  });
+});