@nathapp/nax 0.21.0 → 0.22.1

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

@@ -0,0 +1,236 @@
+// 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("test coverage scoping", () => {
+    test("should scope test coverage to story contextFiles", async () => {
+      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
+
+      try {
+        // Create test directory and files
+        const testDir = path.join(tempDir, "test");
+        await fs.mkdir(testDir);
+
+        // Create multiple test files
+        await fs.writeFile(
+          path.join(testDir, "health.service.test.ts"),
+          'describe("Health Service", () => { test("checks health", () => {}); });',
+        );
+        await fs.writeFile(
+          path.join(testDir, "auth.service.test.ts"),
+          'describe("Auth Service", () => { test("authenticates", () => {}); });',
+        );
+        await fs.writeFile(
+          path.join(testDir, "db.connection.test.ts"),
+          'describe("DB Connection", () => { test("connects", () => {}); });',
+        );
+
+        const prd = createTestPRD([
+          {
+            id: "US-001",
+            title: "Implement health service",
+            description: "Create health check service",
+            acceptanceCriteria: ["Service works"],
+            contextFiles: ["src/health.service.ts"], // Only health service
+          },
+        ]);
+
+        const storyContext: StoryContext = {
+          prd,
+          currentStoryId: "US-001",
+          workdir: tempDir,
+          config: {
+            context: {
+              testCoverage: {
+                enabled: true,
+                scopeToStory: true, // Enable scoping
+              },
+            },
+          } as any,
+        };
+
+        const budget: ContextBudget = {
+          maxTokens: 10000,
+          reservedForInstructions: 1000,
+          availableForContext: 9000,
+        };
+
+        const built = await buildContext(storyContext, budget);
+        const markdown = formatContextAsMarkdown(built);
+
+        // Should include test coverage element
+        expect(built.elements.some((e) => e.type === "test-coverage")).toBe(true);
+
+        // Should only mention health.service.test.ts, not auth or db tests
+        expect(markdown).toContain("health.service.test.ts");
+        expect(markdown).not.toContain("auth.service.test.ts");
+        expect(markdown).not.toContain("db.connection.test.ts");
+      } finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    test("should scan all tests when scopeToStory=false", async () => {
+      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
+
+      try {
+        const testDir = path.join(tempDir, "test");
+        await fs.mkdir(testDir);
+
+        await fs.writeFile(
+          path.join(testDir, "health.test.ts"),
+          'describe("Health", () => { test("works", () => {}); });',
+        );
+        await fs.writeFile(path.join(testDir, "auth.test.ts"), 'describe("Auth", () => { test("works", () => {}); });');
+
+        const prd = createTestPRD([
+          {
+            id: "US-001",
+            title: "Story",
+            description: "Test",
+            acceptanceCriteria: ["AC1"],
+            contextFiles: ["src/health.ts"],
+          },
+        ]);
+
+        const storyContext: StoryContext = {
+          prd,
+          currentStoryId: "US-001",
+          workdir: tempDir,
+          config: {
+            context: {
+              testCoverage: {
+                enabled: true,
+                scopeToStory: false, // Disabled - should scan all
+              },
+            },
+          } as any,
+        };
+
+        const budget: ContextBudget = {
+          maxTokens: 10000,
+          reservedForInstructions: 1000,
+          availableForContext: 9000,
+        };
+
+        const built = await buildContext(storyContext, budget);
+        const markdown = formatContextAsMarkdown(built);
+
+        // Should include both test files
+        expect(markdown).toContain("health.test.ts");
+        expect(markdown).toContain("auth.test.ts");
+      } finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    test("should fall back to full scan when no contextFiles provided", async () => {
+      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
+
+      try {
+        const testDir = path.join(tempDir, "test");
+        await fs.mkdir(testDir);
+
+        await fs.writeFile(
+          path.join(testDir, "test1.test.ts"),
+          'describe("Test1", () => { test("works", () => {}); });',
+        );
+        await fs.writeFile(
+          path.join(testDir, "test2.test.ts"),
+          'describe("Test2", () => { test("works", () => {}); });',
+        );
+
+        const prd = createTestPRD([
+          {
+            id: "US-001",
+            title: "Story without contextFiles",
+            description: "Test",
+            acceptanceCriteria: ["AC1"],
+            // No contextFiles
+          },
+        ]);
+
+        const storyContext: StoryContext = {
+          prd,
+          currentStoryId: "US-001",
+          workdir: tempDir,
+          config: {
+            context: {
+              testCoverage: {
+                enabled: true,
+                scopeToStory: true, // true but no contextFiles
+              },
+            },
+          } as any,
+        };
+
+        const budget: ContextBudget = {
+          maxTokens: 10000,
+          reservedForInstructions: 1000,
+          availableForContext: 9000,
+        };
+
+        const built = await buildContext(storyContext, budget);
+        const markdown = formatContextAsMarkdown(built);
+
+        // Should fall back to scanning all files
+        expect(markdown).toContain("test1.test.ts");
+        expect(markdown).toContain("test2.test.ts");
+      } finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+});

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

@@ -0,0 +1,93 @@
+// 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("createErrorContext", () => {
+    test("should create error context element", () => {
+      const error = "TypeError: Cannot read property";
+      const element = createErrorContext(error, 90);
+
+      expect(element.type).toBe("error");
+      expect(element.content).toBe(error);
+      expect(element.priority).toBe(90);
+      expect(element.tokens).toBeGreaterThan(0);
+    });
+  });
+
+  describe("createProgressContext", () => {
+    test("should create progress context element", () => {
+      const progress = "Progress: 5/12 stories complete (4 passed, 1 failed)";
+      const element = createProgressContext(progress, 100);
+
+      expect(element.type).toBe("progress");
+      expect(element.content).toBe(progress);
+      expect(element.priority).toBe(100);
+      expect(element.tokens).toBeGreaterThan(0);
+    });
+  });
+
+  describe("createFileContext", () => {
+    test("should create file context element", () => {
+      const filePath = "src/utils/helper.ts";
+      const content = 'export function helper() { return "test"; }';
+      const element = createFileContext(filePath, content, 60);
+
+      expect(element.type).toBe("file");
+      expect(element.filePath).toBe(filePath);
+      expect(element.content).toBe(content);
+      expect(element.priority).toBe(60);
+      expect(element.tokens).toBeGreaterThan(0);
+    });
+  });
+});

package/test/unit/context/context-estimate-tokens.test.ts

@@ -0,0 +1,201 @@
+// 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("estimateTokens", () => {
+    test("should estimate tokens correctly", () => {
+      expect(estimateTokens("test")).toBe(2); // 4 chars = 2 tokens (1 token ≈ 3 chars)
+      expect(estimateTokens("hello world")).toBe(4); // 11 chars = 4 tokens
+      expect(estimateTokens("")).toBe(0);
+    });
+  });
+
+  describe("defensive checks", () => {
+    test("should handle story with null acceptanceCriteria", async () => {
+      // Create PRD directly to bypass helper defaults
+      const prd: PRD = {
+        project: "test-project",
+        feature: "test-feature",
+        branchName: "test-branch",
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        userStories: [
+          {
+            id: "US-001",
+            title: "Malformed Story",
+            description: "Test",
+            acceptanceCriteria: null as any, // Simulate malformed data
+            dependencies: [],
+            tags: [],
+            status: "pending",
+            passes: false,
+            escalations: [],
+            attempts: 0,
+          },
+        ],
+      };
+
+      const context: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(context, budget);
+      expect(built.elements.length).toBeGreaterThan(0);
+      const storyElement = built.elements.find((e) => e.type === "story");
+      expect(storyElement?.content).toContain("(No acceptance criteria defined)");
+    });
+
+    test("should handle story with undefined acceptanceCriteria", async () => {
+      // Create PRD directly to bypass helper defaults
+      const prd: PRD = {
+        project: "test-project",
+        feature: "test-feature",
+        branchName: "test-branch",
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        userStories: [
+          {
+            id: "US-001",
+            title: "Malformed Story",
+            description: "Test",
+            acceptanceCriteria: undefined as any, // Simulate malformed data
+            dependencies: [],
+            tags: [],
+            status: "pending",
+            passes: false,
+            escalations: [],
+            attempts: 0,
+          },
+        ],
+      };
+
+      const context: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(context, budget);
+      expect(built.elements.length).toBeGreaterThan(0);
+      const storyElement = built.elements.find((e) => e.type === "story");
+      expect(storyElement?.content).toContain("(No acceptance criteria defined)");
+    });
+
+    test("should log warning for missing dependency story", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Story with Missing Dependency",
+          description: "Test",
+          acceptanceCriteria: ["AC1"],
+          dependencies: ["US-999"], // Non-existent dependency
+        },
+      ]);
+
+      const context: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(context, budget);
+
+      // Should not include the missing dependency in the context
+      expect(built.elements.find((e) => e.type === "dependency")).toBeUndefined();
+    });
+
+    test("should handle story with non-array priorErrors", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Story with Malformed Errors",
+          description: "Test",
+          acceptanceCriteria: ["AC1"],
+          priorErrors: "not an array" as any, // Malformed data
+        },
+      ]);
+
+      const context: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(context, budget);
+      expect(built.elements.find((e) => e.type === "error")).toBeUndefined();
+    });
+  });
+});