@nathapp/nax 0.18.1

package/test/integration/verify-stage.test.ts

@@ -0,0 +1,275 @@
+/**
+ * Verify Stage Tests
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { NaxConfig } from "../../src/config/schema";
+import { initLogger, resetLogger } from "../../src/logger";
+import { verifyStage } from "../../src/pipeline/stages/verify";
+import type { PipelineContext } from "../../src/pipeline/types";
+import type { PRD, UserStory } from "../../src/prd/types";
+
+/** Helper: Create minimal test context */
+function createTestContext(overrides?: Partial<PipelineContext>): PipelineContext {
+  const story: UserStory = {
+    id: "US-001",
+    title: "Test Story",
+    description: "Test description",
+    acceptanceCriteria: ["Test passes"],
+    tags: [],
+    dependencies: [],
+    status: "pending",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+  };
+
+  const prd: PRD = {
+    project: "test-project",
+    feature: "test-feature",
+    branchName: "test-branch",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: [story],
+  };
+
+  const config: NaxConfig = {
+    version: 1,
+    models: {
+      fast: "claude-sonnet-4-5",
+      balanced: "claude-sonnet-4-5",
+      powerful: "claude-opus-4-6",
+    },
+    autoMode: {
+      enabled: true,
+      defaultAgent: "nax-agent-claude",
+      fallbackOrder: ["nax-agent-claude"],
+      complexityRouting: {
+        simple: "fast",
+        medium: "balanced",
+        complex: "powerful",
+        expert: "powerful",
+      },
+      escalation: {
+        enabled: true,
+        maxAttempts: 3,
+      },
+    },
+    execution: {
+      maxIterations: 100,
+      iterationDelayMs: 1000,
+      costLimit: 50,
+      sessionTimeoutSeconds: 600,
+      verificationTimeoutSeconds: 30,
+      maxStoriesPerFeature: 50,
+    },
+    quality: {
+      requireTypecheck: false,
+      requireLint: false,
+      requireTests: true,
+      commands: {},
+    },
+    tdd: {
+      maxRetries: 3,
+      autoVerifyIsolation: true,
+      autoApproveVerifier: true,
+    },
+    constitution: {
+      enabled: false,
+      path: "constitution.md",
+      maxTokens: 2000,
+    },
+    analyze: {
+      llmEnhanced: false,
+      model: "balanced",
+      fallbackToKeywords: true,
+      maxCodebaseSummaryTokens: 4000,
+    },
+    review: {
+      enabled: true,
+      checks: ["test"],
+      commands: {},
+    },
+    plan: {
+      model: "balanced",
+      outputPath: "features",
+    },
+  };
+
+  return {
+    config,
+    prd,
+    story,
+    stories: [story],
+    routing: {
+      complexity: "simple",
+      modelTier: "fast",
+      testStrategy: "test-after",
+      reasoning: "Test routing",
+    },
+    workdir: "/test/workdir",
+    hooks: { hooks: {} },
+    ...overrides,
+  };
+}
+
+describe("Verify Stage", () => {
+  beforeEach(() => {
+    initLogger({ level: "error", useChalk: false });
+  });
+
+  afterEach(() => {
+    resetLogger();
+  });
+
+  test("verifyStage is always enabled", () => {
+    const ctx = createTestContext();
+    expect(verifyStage.enabled(ctx)).toBe(true);
+  });
+
+  test("passes when tests succeed", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
+
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "echo 'Tests passed'",
+          },
+        },
+      },
+    });
+
+    const result = await verifyStage.execute(ctx);
+
+    expect(result.action).toBe("continue");
+  });
+
+  test("fails when tests fail", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
+
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "sh -c 'exit 1'",
+          },
+        },
+      },
+    });
+
+    const result = await verifyStage.execute(ctx);
+
+    expect(result.action).toBe("escalate");
+    if (result.action === "escalate") {
+      expect(result.reason).toContain("Tests failed");
+      // Exit code may vary by shell - just check it mentions exit code
+      expect(result.reason).toMatch(/exit code/);
+    }
+  });
+
+  test("uses default test command when not configured", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
+
+    // Create a simple package.json to make bun test work
+    await Bun.write(join(tempDir, "package.json"), JSON.stringify({ name: "test" }));
+
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {}, // No custom command
+        },
+      },
+    });
+
+    const result = await verifyStage.execute(ctx);
+
+    // No test command configured → stage skips (returns continue)
+    // This is correct behaviour: don't run tests if none configured
+    expect(result.action).toBe("continue");
+  });
+
+  test("uses custom test command from config", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
+
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "echo 'custom test command'",
+          },
+        },
+      },
+    });
+
+    const result = await verifyStage.execute(ctx);
+
+    expect(result.action).toBe("continue");
+  });
+
+  test("handles test command with arguments", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
+
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "echo 'test' && echo 'with args'",
+          },
+        },
+      },
+    });
+
+    const result = await verifyStage.execute(ctx);
+
+    expect(result.action).toBe("continue");
+  });
+
+  test.skip("handles test command that throws error — hangs on nonexistent-command (TODO: fix timeout handling)", async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "nax-verify-test-"));
+
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "nonexistent-command",
+          },
+        },
+      },
+    });
+
+    const result = await verifyStage.execute(ctx);
+
+    expect(result.action).toBe("escalate");
+    if (result.action === "fail") {
+      expect(result.reason).toContain("Tests failed");
+    }
+  });
+});

package/test/integration/worktree/manager.test.ts

@@ -0,0 +1,218 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { WorktreeManager } from "../../../src/worktree/manager";
+
+describe("WorktreeManager", () => {
+  let testDir: string;
+  let projectRoot: string;
+
+  beforeEach(() => {
+    // Create a temporary directory for each test
+    testDir = mkdtempSync(join(tmpdir(), "worktree-test-"));
+    projectRoot = join(testDir, "test-project");
+    mkdirSync(projectRoot, { recursive: true });
+
+    // Initialize a git repository
+    execSync("git init", { cwd: projectRoot, stdio: "pipe" });
+    execSync('git config user.email "test@example.com"', {
+      cwd: projectRoot,
+      stdio: "pipe",
+    });
+    execSync('git config user.name "Test User"', {
+      cwd: projectRoot,
+      stdio: "pipe",
+    });
+
+    // Create an initial commit (required for worktree creation)
+    writeFileSync(join(projectRoot, "README.md"), "# Test Project");
+    execSync("git add README.md", { cwd: projectRoot, stdio: "pipe" });
+    execSync('git commit -m "Initial commit"', {
+      cwd: projectRoot,
+      stdio: "pipe",
+    });
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("create", () => {
+    test("creates a git worktree at .nax-wt/<storyId>/ with branch nax/<storyId>", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-123";
+
+      await manager.create(projectRoot, storyId);
+
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      expect(existsSync(worktreePath)).toBe(true);
+
+      // Verify branch exists
+      const branches = execSync("git branch --list", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+      });
+      expect(branches).toContain(`nax/${storyId}`);
+    });
+
+    test("symlinks node_modules from project root into worktree", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-456";
+
+      // Create node_modules in project root
+      const nodeModulesPath = join(projectRoot, "node_modules");
+      mkdirSync(nodeModulesPath, { recursive: true });
+      writeFileSync(join(nodeModulesPath, "test.txt"), "test content");
+
+      await manager.create(projectRoot, storyId);
+
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      const symlinkPath = join(worktreePath, "node_modules");
+
+      expect(existsSync(symlinkPath)).toBe(true);
+      // Check if it's a symlink by reading the link
+      const { lstatSync, readlinkSync } = await import("node:fs");
+      expect(lstatSync(symlinkPath).isSymbolicLink()).toBe(true);
+      expect(readlinkSync(symlinkPath)).toBe(nodeModulesPath);
+    });
+
+    test("symlinks .env if present", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-789";
+
+      // Create .env in project root
+      const envPath = join(projectRoot, ".env");
+      writeFileSync(envPath, "TEST_VAR=value");
+
+      await manager.create(projectRoot, storyId);
+
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      const symlinkPath = join(worktreePath, ".env");
+
+      expect(existsSync(symlinkPath)).toBe(true);
+      // Check if it's a symlink
+      const { lstatSync, readlinkSync } = await import("node:fs");
+      expect(lstatSync(symlinkPath).isSymbolicLink()).toBe(true);
+      expect(readlinkSync(symlinkPath)).toBe(envPath);
+    });
+
+    test("does not fail if .env is not present", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-no-env";
+
+      await manager.create(projectRoot, storyId);
+
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      expect(existsSync(worktreePath)).toBe(true);
+
+      const symlinkPath = join(worktreePath, ".env");
+      expect(existsSync(symlinkPath)).toBe(false);
+    });
+
+    test("throws descriptive error when not in git repo", async () => {
+      const manager = new WorktreeManager();
+      const nonGitDir = join(testDir, "non-git");
+      mkdirSync(nonGitDir, { recursive: true });
+
+      await expect(manager.create(nonGitDir, "story-fail")).rejects.toThrow(
+        /not a git repository|fatal: not a git repository/i,
+      );
+    });
+
+    test("throws descriptive error when worktree already exists", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-duplicate";
+
+      await manager.create(projectRoot, storyId);
+
+      // Try to create the same worktree again
+      await expect(manager.create(projectRoot, storyId)).rejects.toThrow(/already exists|worktree.*exists/i);
+    });
+  });
+
+  describe("remove", () => {
+    test("cleans up worktree and branch", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-remove";
+
+      // Create worktree first
+      await manager.create(projectRoot, storyId);
+
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      expect(existsSync(worktreePath)).toBe(true);
+
+      // Remove it
+      await manager.remove(projectRoot, storyId);
+
+      // Verify worktree is removed
+      expect(existsSync(worktreePath)).toBe(false);
+
+      // Verify branch is deleted
+      const branches = execSync("git branch --list", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+      });
+      expect(branches).not.toContain(`nax/${storyId}`);
+    });
+
+    test("throws descriptive error when worktree does not exist", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "nonexistent-story";
+
+      await expect(manager.remove(projectRoot, storyId)).rejects.toThrow(
+        /not found|does not exist|no such worktree|worktree not found/i,
+      );
+    });
+  });
+
+  describe("list", () => {
+    test("returns active worktree entries", async () => {
+      const manager = new WorktreeManager();
+      const storyId1 = "story-list-1";
+      const storyId2 = "story-list-2";
+
+      // Create two worktrees
+      await manager.create(projectRoot, storyId1);
+      await manager.create(projectRoot, storyId2);
+
+      const worktrees = await manager.list(projectRoot);
+
+      // Should have at least our two worktrees (main worktree + 2 created)
+      expect(worktrees.length).toBeGreaterThanOrEqual(2);
+
+      // Check if our worktrees are in the list
+      const paths = worktrees.map((wt) => wt.path);
+      expect(paths.some((p) => p.includes(join(".nax-wt", storyId1)))).toBe(true);
+      expect(paths.some((p) => p.includes(join(".nax-wt", storyId2)))).toBe(true);
+    });
+
+    test("returns empty array when no worktrees exist (except main)", async () => {
+      const manager = new WorktreeManager();
+
+      const worktrees = await manager.list(projectRoot);
+
+      // Should only have the main worktree
+      expect(worktrees.length).toBeGreaterThanOrEqual(0);
+      expect(worktrees.every((wt) => !wt.path.includes(".nax-wt"))).toBe(true);
+    });
+
+    test("each entry contains path and branch info", async () => {
+      const manager = new WorktreeManager();
+      const storyId = "story-info";
+
+      await manager.create(projectRoot, storyId);
+
+      const worktrees = await manager.list(projectRoot);
+      const ourWorktree = worktrees.find((wt) => wt.path.includes(join(".nax-wt", storyId)));
+
+      expect(ourWorktree).toBeDefined();
+      expect(ourWorktree?.path).toBeTruthy();
+      expect(ourWorktree?.branch).toBe(`nax/${storyId}`);
+    });
+  });
+});