@nathapp/nax 0.20.0 → 0.22.0

package/test/unit/agents/claude.test.ts

@@ -0,0 +1,107 @@
+// RE-ARCH: keep
+/**
+ * Tests for ClaudeCodeAdapter.runOnce() timeout behavior
+ *
+ * Covers: US-001 - runOnce() SIGKILL follow-up after grace period
+ * - SIGTERM is sent first on timeout
+ * - PID is always unregistered in finally block, even if kill() throws
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ClaudeCodeAdapter, _runOnceDeps } from "../../../src/agents/claude";
+import type { AgentRunOptions } from "../../../src/agents/types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Test adapter — overrides buildCommand to avoid requiring the claude binary
+// ─────────────────────────────────────────────────────────────────────────────
+
+class TestAdapter extends ClaudeCodeAdapter {
+  private readonly testCmd: string[];
+
+  constructor(cmd: string[]) {
+    super();
+    this.testCmd = cmd;
+  }
+
+  override buildCommand(_options: AgentRunOptions): string[] {
+    return this.testCmd;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+function makeRunOptions(workdir: string, timeoutSeconds: number): AgentRunOptions {
+  return {
+    workdir,
+    prompt: "test",
+    modelTier: "balanced",
+    modelDef: { provider: "anthropic", model: "claude-sonnet-4-5", env: {} },
+    timeoutSeconds,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("runOnce() timeout behavior", () => {
+  let tempDir: string;
+  const origKillProc = _runOnceDeps.killProc;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "nax-claude-test-"));
+  });
+
+  afterEach(() => {
+    // Restore original killProc after each test
+    _runOnceDeps.killProc = origKillProc;
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  test("timeout path sends SIGTERM to process first", async () => {
+    const sentSignals: string[] = [];
+
+    // Record signals sent but still kill the process so proc.exited resolves
+    _runOnceDeps.killProc = (proc, signal) => {
+      sentSignals.push(String(signal));
+      origKillProc(proc, signal);
+    };
+
+    // Long-running process: will be killed by the 100ms timeout
+    const adapter = new TestAdapter(["/bin/sh", "-c", "sleep 100"]);
+    const result = await adapter.run(makeRunOptions(tempDir, 0.1));
+
+    expect(result.exitCode).toBe(124); // timeout exit code
+    expect(sentSignals[0]).toBe("SIGTERM"); // SIGTERM sent first
+  });
+
+  test("timeout path: unregisters PID even if killProc throws", async () => {
+    // Override killProc to throw — simulates kill() failing (e.g., process already gone)
+    _runOnceDeps.killProc = (_proc, _signal) => {
+      throw new Error("kill failed");
+    };
+
+    // Use a short-lived process (0.5s) with a timeout that fires first (50ms).
+    // killProc throws (process not killed), so proc exits naturally at ~0.5s.
+    // The finally block must still call unregister regardless.
+    const adapter = new TestAdapter(["/bin/sh", "-c", "sleep 0.5"]);
+    const options = makeRunOptions(tempDir, 0.05); // 50ms timeout
+
+    // Should not throw — kill errors are caught internally
+    await adapter.run(options);
+
+    // PID must have been unregistered (file empty or absent)
+    const pidsFile = join(tempDir, ".nax-pids");
+    if (existsSync(pidsFile)) {
+      const content = await Bun.file(pidsFile).text();
+      expect(content.trim()).toBe("");
+    }
+  });
+});

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

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for LLM Classifier
  */

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

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for context auto-detection (BUG-006)
  */

package/test/unit/cli-status.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/cli/status.ts - Feature status display with active run detection
  */

package/test/unit/commands/common.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/commands/common.ts
  */

package/test/unit/commands/logs.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Unit tests for nax logs command
  *

package/test/unit/commands/unlock.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Unit tests for the nax unlock command
  *

package/test/unit/config/defaults.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * DEFAULT_CONFIG.review.checks default value tests
  *

package/test/unit/config/regression-gate-schema.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * RegressionGateConfigSchema — mode and maxRectificationAttempts fields
  *

package/test/unit/config/smart-runner-flag.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Smart Test Runner Config Flag Tests (STR-004)
  *

package/test/unit/constitution-generators.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Constitution Generators Tests
  *

package/test/unit/constitution.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Constitution system tests
  */

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

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