@nathapp/nax 0.20.0 → 0.22.0

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

@@ -0,0 +1,302 @@
+// 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("formatContextAsMarkdown", () => {
+    test("should format context with all element types", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Dependency",
+          description: "Dep description",
+          acceptanceCriteria: ["AC1"],
+          status: "passed",
+          passes: true,
+        },
+        {
+          id: "US-002",
+          title: "Current",
+          description: "Current description",
+          acceptanceCriteria: ["AC2"],
+          dependencies: ["US-001"],
+          priorErrors: ["Test error"],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-002",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      expect(markdown).toContain("# Story Context");
+      expect(markdown).toContain("## Progress");
+      expect(markdown).toContain("## Prior Errors");
+      expect(markdown).toContain("## Current Story");
+      expect(markdown).toContain("## Dependency Stories");
+      expect(markdown).toContain("US-001");
+      expect(markdown).toContain("US-002");
+      expect(markdown).toContain("Test error");
+    });
+
+    test("should include summary with token count", async () => {
+      const prd = createTestPRD([{ id: "US-001", title: "Story" }]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      expect(markdown).toContain("Context:");
+      expect(markdown).toContain("tokens");
+      expect(markdown).toContain(built.totalTokens.toString());
+    });
+
+    test("should show truncation indicator", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          description: "x".repeat(2000),
+          dependencies: ["US-002", "US-003"],
+        },
+        { id: "US-002", description: "x".repeat(2000) },
+        { id: "US-003", description: "x".repeat(2000) },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 500,
+        reservedForInstructions: 250,
+        availableForContext: 250,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      expect(markdown).toContain("[TRUNCATED]");
+    });
+
+    test("should format context with file elements", async () => {
+      const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-test-"));
+
+      try {
+        await fs.writeFile(path.join(tempDir, "helper.ts"), "export function helper() {}");
+
+        const prd = createTestPRD([
+          {
+            id: "US-001",
+            title: "Story with File",
+            description: "Test",
+            acceptanceCriteria: ["AC1"],
+            contextFiles: ["helper.ts"],
+          },
+        ]);
+
+        const storyContext: StoryContext = {
+          prd,
+          currentStoryId: "US-001",
+          workdir: tempDir,
+        };
+
+        const budget: ContextBudget = {
+          maxTokens: 10000,
+          reservedForInstructions: 1000,
+          availableForContext: 9000,
+        };
+
+        const built = await buildContext(storyContext, budget);
+        const markdown = formatContextAsMarkdown(built);
+
+        expect(markdown).toContain("# Story Context");
+        expect(markdown).toContain("## Relevant Source Files");
+        expect(markdown).toContain("helper.ts");
+        expect(markdown).toContain("helper()");
+      } finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    test("should format ASSET_CHECK_FAILED errors as mandatory instructions", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Story with asset check failure",
+          description: "Test description",
+          acceptanceCriteria: ["AC1"],
+          priorErrors: [
+            "ASSET_CHECK_FAILED: Missing files: [src/finder.ts, test/finder.test.ts]\nAction: Create the missing files before tests can run.",
+          ],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      // Verify ASSET_CHECK errors are formatted prominently
+      expect(markdown).toContain("⚠️ MANDATORY: Missing Files from Previous Attempts");
+      expect(markdown).toContain("CRITICAL");
+      expect(markdown).toContain("You MUST create these exact files");
+      expect(markdown).toContain("Do NOT use alternative filenames");
+      expect(markdown).toContain("**Required files:**");
+      expect(markdown).toContain("`src/finder.ts`");
+      expect(markdown).toContain("`test/finder.test.ts`");
+
+      // Verify it's NOT in the generic "Prior Errors" section
+      expect(markdown).not.toContain("## Prior Errors");
+    });
+
+    test("should format mixed ASSET_CHECK and other errors separately", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Story with multiple error types",
+          description: "Test description",
+          acceptanceCriteria: ["AC1"],
+          priorErrors: [
+            "ASSET_CHECK_FAILED: Missing files: [src/utils.ts]\nAction: Create the missing files before tests can run.",
+            'TypeError: Cannot read property "foo" of undefined',
+            "Test execution failed",
+          ],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      // Verify ASSET_CHECK errors section exists
+      expect(markdown).toContain("⚠️ MANDATORY: Missing Files from Previous Attempts");
+      expect(markdown).toContain("`src/utils.ts`");
+
+      // Verify other errors are in separate section
+      expect(markdown).toContain("## Prior Errors");
+      expect(markdown).toContain('TypeError: Cannot read property "foo" of undefined');
+      expect(markdown).toContain("Test execution failed");
+    });
+
+    test("should handle non-ASSET_CHECK errors normally", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Story with regular errors",
+          description: "Test description",
+          acceptanceCriteria: ["AC1"],
+          priorErrors: ['TypeError: Cannot read property "foo" of undefined', "Test execution failed"],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 10000,
+        reservedForInstructions: 1000,
+        availableForContext: 9000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      // Verify only "Prior Errors" section exists (no MANDATORY section)
+      expect(markdown).toContain("## Prior Errors");
+      expect(markdown).toContain('TypeError: Cannot read property "foo" of undefined');
+      expect(markdown).toContain("Test execution failed");
+      expect(markdown).not.toContain("⚠️ MANDATORY");
+    });
+  });
+});

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

@@ -0,0 +1,267 @@
+// 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 isolation", () => {
+    test("should only include current story and declared dependencies — no other stories", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Define core interfaces",
+          description: "Create base interfaces for the module",
+          acceptanceCriteria: ["Interface exported", "Types documented"],
+          dependencies: [],
+          status: "passed" as any,
+          passes: true,
+        },
+        {
+          id: "US-002",
+          title: "Implement health service",
+          description: "Service that aggregates indicators",
+          acceptanceCriteria: ["Service injectable", "Aggregates results"],
+          dependencies: [],
+          status: "passed" as any,
+          passes: true,
+        },
+        {
+          id: "US-003",
+          title: "Add HTTP indicator",
+          description: "HTTP health check indicator",
+          acceptanceCriteria: ["Pings endpoint", "Returns status"],
+          dependencies: ["US-001"],
+        },
+        {
+          id: "US-004",
+          title: "Add database indicator",
+          description: "Database connectivity check",
+          acceptanceCriteria: ["Checks DB connection", "Timeout support"],
+          dependencies: ["US-001"],
+        },
+        {
+          id: "US-005",
+          title: "REST endpoint",
+          description: "Expose health check via REST API",
+          acceptanceCriteria: ["GET /health returns JSON", "Includes all indicators"],
+          dependencies: ["US-002", "US-003"],
+        },
+      ]);
+
+      // Build context for US-003 which depends only on US-001
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-003",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 50000,
+        reservedForInstructions: 5000,
+        availableForContext: 45000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      // Current story IS present
+      expect(markdown).toContain("US-003");
+      expect(markdown).toContain("Add HTTP indicator");
+
+      // Declared dependency IS present
+      expect(markdown).toContain("US-001");
+      expect(markdown).toContain("Define core interfaces");
+
+      // Non-dependency stories are NOT present
+      expect(markdown).not.toContain("US-002");
+      expect(markdown).not.toContain("Implement health service");
+      expect(markdown).not.toContain("US-004");
+      expect(markdown).not.toContain("Add database indicator");
+      expect(markdown).not.toContain("US-005");
+      expect(markdown).not.toContain("REST endpoint");
+
+      // Acceptance criteria from other stories are NOT leaked
+      expect(markdown).not.toContain("Aggregates results");
+      expect(markdown).not.toContain("Checks DB connection");
+      expect(markdown).not.toContain("Includes all indicators");
+    });
+
+    test("progress summary contains only aggregate counts, not story titles or IDs", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Secret Story Alpha",
+          description: "Should not appear in progress",
+          acceptanceCriteria: ["AC1"],
+          dependencies: [],
+          status: "passed" as any,
+          passes: true,
+        },
+        {
+          id: "US-002",
+          title: "Secret Story Beta",
+          description: "Also should not appear",
+          acceptanceCriteria: ["AC1"],
+          dependencies: [],
+          status: "failed" as any,
+          passes: false,
+        },
+        {
+          id: "US-003",
+          title: "Current Story",
+          description: "The one being built",
+          acceptanceCriteria: ["AC1"],
+          dependencies: [],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-003",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 50000,
+        reservedForInstructions: 5000,
+        availableForContext: 45000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const progressElement = built.elements.find((e) => e.type === "progress");
+
+      expect(progressElement).toBeDefined();
+      // Progress shows counts only
+      expect(progressElement!.content).toContain("2/3");
+      // Does NOT contain other story titles
+      expect(progressElement!.content).not.toContain("Secret Story Alpha");
+      expect(progressElement!.content).not.toContain("Secret Story Beta");
+      expect(progressElement!.content).not.toContain("US-001");
+      expect(progressElement!.content).not.toContain("US-002");
+    });
+
+    test("prior errors from other stories do not leak into current story context", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Story with errors",
+          description: "Has prior errors",
+          acceptanceCriteria: ["AC1"],
+          dependencies: [],
+          priorErrors: ["LEAKED_ERROR: something broke in US-001"],
+        },
+        {
+          id: "US-002",
+          title: "Clean story",
+          description: "No errors here",
+          acceptanceCriteria: ["AC1"],
+          dependencies: [],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-002",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 50000,
+        reservedForInstructions: 5000,
+        availableForContext: 45000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+      const markdown = formatContextAsMarkdown(built);
+
+      expect(markdown).not.toContain("LEAKED_ERROR");
+      expect(markdown).not.toContain("US-001");
+      // No error section at all
+      expect(markdown).not.toContain("## Prior Errors");
+    });
+
+    test("context elements only contain expected types for a story with no deps/errors", async () => {
+      const prd = createTestPRD([
+        {
+          id: "US-001",
+          title: "Solo story",
+          description: "No dependencies",
+          acceptanceCriteria: ["AC1"],
+          dependencies: [],
+        },
+      ]);
+
+      const storyContext: StoryContext = {
+        prd,
+        currentStoryId: "US-001",
+      };
+
+      const budget: ContextBudget = {
+        maxTokens: 50000,
+        reservedForInstructions: 5000,
+        availableForContext: 45000,
+      };
+
+      const built = await buildContext(storyContext, budget);
+
+      // Should only have progress + current story (no deps, no errors, no files, no test-coverage without workdir)
+      const types = built.elements.map((e) => e.type);
+      expect(types).toContain("progress");
+      expect(types).toContain("story");
+      expect(types).not.toContain("dependency");
+      expect(types).not.toContain("error");
+
+      // All story elements reference only US-001
+      const storyElements = built.elements.filter((e) => e.storyId);
+      for (const el of storyElements) {
+        expect(el.storyId).toBe("US-001");
+      }
+    });
+  });
+});

package/test/unit/context/context-sort.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("sortContextElements", () => {
+    test("should sort by priority descending", () => {
+      const elements: ContextElement[] = [
+        createErrorContext("error", 10),
+        createProgressContext("progress", 100),
+        createErrorContext("error2", 50),
+      ];
+
+      const sorted = sortContextElements(elements);
+
+      expect(sorted[0].priority).toBe(100);
+      expect(sorted[1].priority).toBe(50);
+      expect(sorted[2].priority).toBe(10);
+    });
+
+    test("should sort by tokens ascending for same priority", () => {
+      const elements: ContextElement[] = [
+        createErrorContext("this is a much longer error message with lots of text", 50),
+        createErrorContext("short", 50),
+        createErrorContext("medium length message", 50),
+      ];
+
+      const sorted = sortContextElements(elements);
+
+      expect(sorted[0].tokens).toBeLessThan(sorted[1].tokens);
+      expect(sorted[1].tokens).toBeLessThan(sorted[2].tokens);
+    });
+
+    test("should not mutate original array", () => {
+      const elements: ContextElement[] = [createErrorContext("a", 10), createErrorContext("b", 20)];
+
+      const original = [...elements];
+      sortContextElements(elements);
+
+      expect(elements).toEqual(original);
+    });
+  });
+});