@nathapp/nax 0.27.1 → 0.29.0

package/test/unit/constitution.test.ts

@@ -1,210 +0,0 @@
-// RE-ARCH: keep
-/**
- * Constitution system tests
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { estimateTokens, loadConstitution, truncateToTokens } from "../../src/constitution";
-import type { ConstitutionConfig } from "../../src/constitution";
-
-const TEST_DIR = join(import.meta.dir, ".tmp-constitution-test");
-
-beforeEach(() => {
-  if (existsSync(TEST_DIR)) {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  }
-  mkdirSync(TEST_DIR, { recursive: true });
-});
-
-afterEach(() => {
-  if (existsSync(TEST_DIR)) {
-    rmSync(TEST_DIR, { recursive: true, force: true });
-  }
-});
-
-describe("estimateTokens", () => {
-  test("estimates tokens using 1 token ≈ 3 chars", () => {
-    expect(estimateTokens("abc")).toBe(1); // 3 chars = 1 token
-    expect(estimateTokens("abcdef")).toBe(2); // 6 chars = 2 tokens
-    expect(estimateTokens("a".repeat(100))).toBe(34); // 100 chars = 34 tokens (rounded up)
-  });
-
-  test("handles empty string", () => {
-    expect(estimateTokens("")).toBe(0);
-  });
-
-  test("rounds up fractional tokens", () => {
-    expect(estimateTokens("ab")).toBe(1); // 2 chars = 0.67 tokens → rounds up to 1
-  });
-});
-
-describe("truncateToTokens", () => {
-  test("returns full text if within token limit", () => {
-    const text = "Hello world";
-    const result = truncateToTokens(text, 100);
-    expect(result).toBe(text);
-  });
-
-  test("truncates at word boundary", () => {
-    const text = "The quick brown fox jumps over the lazy dog";
-    const result = truncateToTokens(text, 5); // 5 tokens ≈ 15 chars
-    expect(result.length).toBeLessThanOrEqual(15);
-    expect(result).not.toContain("fox"); // Should stop before "fox"
-    // Result should be "The quick" which ends with a word character
-    expect(result.trim()).toBe("The quick");
-  });
-
-  test("truncates at newline boundary", () => {
-    const text = "Line 1\nLine 2\nLine 3\nLine 4";
-    const result = truncateToTokens(text, 3); // 3 tokens ≈ 9 chars
-    expect(result).toContain("Line 1");
-    expect(result).not.toContain("Line 3");
-  });
-
-  test("hard cuts if no word boundary found", () => {
-    const text = "a".repeat(100);
-    const result = truncateToTokens(text, 5); // 5 tokens ≈ 15 chars
-    expect(result.length).toBe(15);
-  });
-});
-
-describe("loadConstitution", () => {
-  test("returns null if disabled", async () => {
-    const config: ConstitutionConfig = {
-      enabled: false,
-      path: "constitution.md",
-      maxTokens: 2000,
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).toBeNull();
-  });
-
-  test("returns null if file doesn't exist", async () => {
-    const config: ConstitutionConfig = {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 2000,
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).toBeNull();
-  });
-
-  test("returns null if file is empty", async () => {
-    const constitutionPath = join(TEST_DIR, "constitution.md");
-    await Bun.write(constitutionPath, "   \n\n  "); // Only whitespace
-
-    const config: ConstitutionConfig = {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 2000,
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).toBeNull();
-  });
-
-  test("loads constitution without truncation", async () => {
-    const content = "# Project Constitution\n\nFollow these rules.";
-    const constitutionPath = join(TEST_DIR, "constitution.md");
-    await Bun.write(constitutionPath, content);
-
-    const config: ConstitutionConfig = {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 2000,
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).not.toBeNull();
-    expect(result?.content).toBe(content);
-    expect(result?.tokens).toBe(estimateTokens(content));
-    expect(result?.truncated).toBe(false);
-    expect(result?.originalTokens).toBeUndefined();
-  });
-
-  test("truncates constitution if exceeds maxTokens", async () => {
-    const content = "A".repeat(300); // 300 chars = 100 tokens
-    const constitutionPath = join(TEST_DIR, "constitution.md");
-    await Bun.write(constitutionPath, content);
-
-    const config: ConstitutionConfig = {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 50, // Only allow 50 tokens
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).not.toBeNull();
-    expect(result?.truncated).toBe(true);
-    expect(result?.tokens).toBeLessThanOrEqual(50);
-    expect(result?.originalTokens).toBe(100);
-    expect(result?.content.length).toBeLessThan(content.length);
-  });
-
-  test("loads from custom path", async () => {
-    const content = "# Custom Constitution";
-    const customPath = join(TEST_DIR, "custom-rules.md");
-    await Bun.write(customPath, content);
-
-    const config: ConstitutionConfig = {
-      enabled: true,
-      path: "custom-rules.md",
-      maxTokens: 2000,
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).not.toBeNull();
-    expect(result?.content).toBe(content);
-  });
-
-  test("handles large constitution with meaningful content", async () => {
-    const content = `# Project Constitution
-
-## Coding Standards
-- Use TypeScript strict mode
-- Follow ESLint rules
-- Write clear variable names
-
-## Testing
-- Write unit tests for all functions
-- Aim for 80%+ coverage
-- Use describe/test/expect pattern
-
-## Architecture
-- Keep functions small (<50 lines)
-- Use dependency injection
-- Follow SOLID principles
-
-## Forbidden Patterns
-- No any types
-- No console.log
-- No hardcoded secrets
-`;
-
-    const constitutionPath = join(TEST_DIR, "constitution.md");
-    await Bun.write(constitutionPath, content);
-
-    const config: ConstitutionConfig = {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 2000,
-      skipGlobal: true,
-    };
-
-    const result = await loadConstitution(TEST_DIR, config);
-    expect(result).not.toBeNull();
-    expect(result?.content).toBe(content);
-    expect(result?.truncated).toBe(false);
-    expect(result?.tokens).toBeGreaterThan(0);
-  });
-});

package/test/unit/context/context-autodetect.test.ts

@@ -1,297 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for context builder module
- */
-
-// RE-ARCH: keep
-/**
- * Tests for context builder module
- */
-
-import { describe, expect, test } from "bun:test";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import {
-  buildContext,
-  createDependencyContext,
-  createErrorContext,
-  createFileContext,
-  createProgressContext,
-  createStoryContext,
-  estimateTokens,
-  formatContextAsMarkdown,
-  sortContextElements,
-} from "../../../src/context/builder";
-import type { ContextBudget, ContextElement, StoryContext } from "../../../src/context/types";
-import type { PRD, UserStory } from "../../../src/prd";
-
-// Helper to create test PRD
-const createTestPRD = (stories: Partial<UserStory>[]): PRD => ({
-  project: "test-project",
-  feature: "test-feature",
-  branchName: "test-branch",
-  createdAt: new Date().toISOString(),
-  updatedAt: new Date().toISOString(),
-  userStories: stories.map((s, i) => ({
-    id: s.id || `US-${String(i + 1).padStart(3, "0")}`,
-    title: s.title || "Test Story",
-    description: s.description || "Test description",
-    acceptanceCriteria: s.acceptanceCriteria || ["AC1"],
-    dependencies: s.dependencies || [],
-    tags: s.tags || [],
-    status: s.status || "pending",
-    passes: s.passes ?? false,
-    escalations: s.escalations || [],
-    attempts: s.attempts || 0,
-    routing: s.routing,
-    priorErrors: s.priorErrors,
-    relevantFiles: s.relevantFiles,
-    contextFiles: s.contextFiles,
-    expectedFiles: s.expectedFiles,
-  })),
-});
-
-describe("Context Builder", () => {
-  describe("context auto-detection (BUG-006)", () => {
-    test("should auto-detect files when contextFiles is empty", async () => {
-      // Create temp git repo
-      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-      try {
-        // Initialize git
-        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;
-
-        // Create files matching story keywords
-        await fs.mkdir(path.join(tempDir, "src/routing"), { recursive: true });
-        await fs.writeFile(path.join(tempDir, "src/routing/router.ts"), "export class Router { /* routing logic */ }");
-        await fs.writeFile(
-          path.join(tempDir, "src/routing/chain.ts"),
-          "export class RouterChain { /* chain logic */ }",
-        );
-
-        // Commit 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 prd = createTestPRD([
-          {
-            id: "US-001",
-            title: "Fix routing chain bug",
-            description: "Fix issue in router chain",
-            acceptanceCriteria: ["Router chain works correctly"],
-            // No contextFiles - should auto-detect
-          },
-        ]);
-
-        const storyContext: StoryContext = {
-          prd,
-          currentStoryId: "US-001",
-          workdir: tempDir,
-          config: {
-            context: {
-              autoDetect: {
-                enabled: true,
-                maxFiles: 5,
-                traceImports: false,
-              },
-              testCoverage: {
-                enabled: false, // Disable to isolate auto-detect test
-              },
-            },
-          } as any,
-        };
-
-        const budget: ContextBudget = {
-          maxTokens: 10000,
-          reservedForInstructions: 1000,
-          availableForContext: 9000,
-        };
-
-        const built = await buildContext(storyContext, budget);
-        const fileElements = built.elements.filter((e) => e.type === "file");
-
-        // Should auto-detect routing files
-        expect(fileElements.length).toBeGreaterThan(0);
-        const filePaths = fileElements.map((e) => e.filePath);
-        expect(filePaths).toContain("src/routing/router.ts");
-        expect(filePaths).toContain("src/routing/chain.ts");
-      } finally {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("should skip auto-detection when contextFiles is provided", async () => {
-      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-      try {
-        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;
-
-        await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
-        await fs.writeFile(path.join(tempDir, "src/explicit.ts"), "export const explicit = true;");
-        await fs.writeFile(path.join(tempDir, "src/routing.ts"), "export const routing = true;");
-
-        await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
-        await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
-
-        const prd = createTestPRD([
-          {
-            id: "US-001",
-            title: "Fix routing bug",
-            description: "Fix routing",
-            acceptanceCriteria: ["Works"],
-            contextFiles: ["src/explicit.ts"], // Explicit file provided
-          },
-        ]);
-
-        const storyContext: StoryContext = {
-          prd,
-          currentStoryId: "US-001",
-          workdir: tempDir,
-          config: {
-            context: {
-              autoDetect: {
-                enabled: true,
-                maxFiles: 5,
-                traceImports: false,
-              },
-              testCoverage: {
-                enabled: false,
-              },
-            },
-          } as any,
-        };
-
-        const budget: ContextBudget = {
-          maxTokens: 10000,
-          reservedForInstructions: 1000,
-          availableForContext: 9000,
-        };
-
-        const built = await buildContext(storyContext, budget);
-        const fileElements = built.elements.filter((e) => e.type === "file");
-
-        // Should only load explicit file, NOT auto-detect
-        expect(fileElements.length).toBe(1);
-        expect(fileElements[0].filePath).toBe("src/explicit.ts");
-      } finally {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("should skip auto-detection when disabled in config", async () => {
-      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-      try {
-        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;
-
-        await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
-        await fs.writeFile(path.join(tempDir, "src/routing.ts"), "export const routing = true;");
-
-        await Bun.spawn(["git", "add", "."], { cwd: tempDir }).exited;
-        await Bun.spawn(["git", "commit", "-m", "initial"], { cwd: tempDir }).exited;
-
-        const prd = createTestPRD([
-          {
-            id: "US-001",
-            title: "Fix routing bug",
-            description: "Fix routing",
-            acceptanceCriteria: ["Works"],
-            // No contextFiles
-          },
-        ]);
-
-        const storyContext: StoryContext = {
-          prd,
-          currentStoryId: "US-001",
-          workdir: tempDir,
-          config: {
-            context: {
-              autoDetect: {
-                enabled: false, // Disabled
-                maxFiles: 5,
-                traceImports: false,
-              },
-              testCoverage: {
-                enabled: false,
-              },
-            },
-          } as any,
-        };
-
-        const budget: ContextBudget = {
-          maxTokens: 10000,
-          reservedForInstructions: 1000,
-          availableForContext: 9000,
-        };
-
-        const built = await buildContext(storyContext, budget);
-        const fileElements = built.elements.filter((e) => e.type === "file");
-
-        // Should NOT auto-detect when disabled
-        expect(fileElements.length).toBe(0);
-      } finally {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("should handle auto-detection failure gracefully", async () => {
-      // Non-git directory - git grep will fail
-      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
-
-      try {
-        await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
-        await fs.writeFile(path.join(tempDir, "src/file.ts"), "export const test = true;");
-
-        const prd = createTestPRD([
-          {
-            id: "US-001",
-            title: "Fix test bug",
-            description: "Fix test",
-            acceptanceCriteria: ["Works"],
-            // No contextFiles
-          },
-        ]);
-
-        const storyContext: StoryContext = {
-          prd,
-          currentStoryId: "US-001",
-          workdir: tempDir,
-          config: {
-            context: {
-              autoDetect: {
-                enabled: true,
-                maxFiles: 5,
-                traceImports: false,
-              },
-              testCoverage: {
-                enabled: false,
-              },
-            },
-          } as any,
-        };
-
-        const budget: ContextBudget = {
-          maxTokens: 10000,
-          reservedForInstructions: 1000,
-          availableForContext: 9000,
-        };
-
-        // Should not throw, just log warning and continue
-        const built = await buildContext(storyContext, budget);
-        const fileElements = built.elements.filter((e) => e.type === "file");
-
-        // No files loaded (graceful failure)
-        expect(fileElements.length).toBe(0);
-      } finally {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      }
-    });
-  });
-});