@nathapp/nax 0.18.1

package/test/integration/worktree/merge.test.ts

@@ -0,0 +1,341 @@
+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";
+import { MergeEngine } from "../../../src/worktree/merge";
+
+describe("MergeEngine", () => {
+  let testDir: string;
+  let projectRoot: string;
+  let manager: WorktreeManager;
+  let engine: MergeEngine;
+
+  beforeEach(() => {
+    // Create a temporary directory for each test
+    testDir = mkdtempSync(join(tmpdir(), "merge-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",
+    });
+
+    manager = new WorktreeManager();
+    engine = new MergeEngine(manager);
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("merge", () => {
+    test("performs git merge --no-ff of story branch", async () => {
+      const storyId = "story-merge-1";
+
+      // Create worktree and make a change
+      await manager.create(projectRoot, storyId);
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      writeFileSync(join(worktreePath, "feature.txt"), "feature content");
+      execSync("git add feature.txt", {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+      execSync('git commit -m "Add feature"', {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+
+      // Merge the branch
+      const result = await engine.merge(projectRoot, storyId);
+
+      expect(result.success).toBe(true);
+      expect(result.conflictFiles).toBeUndefined();
+
+      // Verify merge commit exists
+      const log = execSync("git log --oneline --graph", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+      });
+      expect(log).toContain(`Merge branch 'nax/${storyId}'`);
+
+      // Verify feature file exists in main branch
+      expect(existsSync(join(projectRoot, "feature.txt"))).toBe(true);
+    });
+
+    test("returns { success: true } on clean merge", async () => {
+      const storyId = "story-clean";
+
+      // Create worktree and make a non-conflicting change
+      await manager.create(projectRoot, storyId);
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      writeFileSync(join(worktreePath, "new-file.txt"), "new content");
+      execSync("git add new-file.txt", {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+      execSync('git commit -m "Add new file"', {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+
+      const result = await engine.merge(projectRoot, storyId);
+
+      expect(result.success).toBe(true);
+      expect(result.conflictFiles).toBeUndefined();
+    });
+
+    test("returns { success: false, conflictFiles: [...] } on conflict", async () => {
+      const storyId = "story-conflict";
+
+      // Create worktree
+      await manager.create(projectRoot, storyId);
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+
+      // Make conflicting changes in both branches
+      // Change in main branch
+      writeFileSync(join(projectRoot, "conflict.txt"), "main content");
+      execSync("git add conflict.txt", {
+        cwd: projectRoot,
+        stdio: "pipe",
+      });
+      execSync('git commit -m "Add conflict file in main"', {
+        cwd: projectRoot,
+        stdio: "pipe",
+      });
+
+      // Change in story branch (same file, different content)
+      writeFileSync(join(worktreePath, "conflict.txt"), "story content");
+      execSync("git add conflict.txt", {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+      execSync('git commit -m "Add conflict file in story"', {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+
+      const result = await engine.merge(projectRoot, storyId);
+
+      expect(result.success).toBe(false);
+      expect(result.conflictFiles).toBeDefined();
+      expect(result.conflictFiles?.length).toBeGreaterThan(0);
+      expect(result.conflictFiles).toContain("conflict.txt");
+
+      // Verify merge was aborted (working tree should be clean except for .nax-wt)
+      const status = execSync("git status --short", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+      });
+      const nonWorktreeStatus = status
+        .split("\n")
+        .filter((line) => !line.includes(".nax-wt"))
+        .join("\n")
+        .trim();
+      expect(nonWorktreeStatus).toBe(""); // Clean working tree after abort
+    });
+
+    test("cleans up worktree after successful merge", async () => {
+      const storyId = "story-cleanup";
+
+      // Create worktree and make a change
+      await manager.create(projectRoot, storyId);
+      const worktreePath = join(projectRoot, ".nax-wt", storyId);
+      writeFileSync(join(worktreePath, "cleanup.txt"), "cleanup test");
+      execSync("git add cleanup.txt", {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+      execSync('git commit -m "Add cleanup test"', {
+        cwd: worktreePath,
+        stdio: "pipe",
+      });
+
+      // Merge and verify cleanup
+      await engine.merge(projectRoot, storyId);
+
+      // Worktree should be removed
+      expect(existsSync(worktreePath)).toBe(false);
+
+      // Branch should be deleted
+      const branches = execSync("git branch --list", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+      });
+      expect(branches).not.toContain(`nax/${storyId}`);
+    });
+  });
+
+  describe("mergeAll", () => {
+    test("processes stories in topological order", async () => {
+      // Create three stories with dependencies: story-1 <- story-2 <- story-3
+      const storyIds = ["story-1", "story-2", "story-3"];
+      const dependencies = {
+        "story-1": [],
+        "story-2": ["story-1"],
+        "story-3": ["story-2"],
+      };
+
+      // Create worktrees and commits for each story
+      for (const storyId of storyIds) {
+        await manager.create(projectRoot, storyId);
+        const worktreePath = join(projectRoot, ".nax-wt", storyId);
+        writeFileSync(join(worktreePath, `${storyId}.txt`), `${storyId} content`);
+        execSync(`git add ${storyId}.txt`, {
+          cwd: worktreePath,
+          stdio: "pipe",
+        });
+        execSync(`git commit -m "Add ${storyId}"`, {
+          cwd: worktreePath,
+          stdio: "pipe",
+        });
+      }
+
+      const results = await engine.mergeAll(projectRoot, storyIds, dependencies);
+
+      // All should succeed
+      expect(results.every((r) => r.success)).toBe(true);
+      expect(results.length).toBe(3);
+
+      // Verify all files exist
+      for (const storyId of storyIds) {
+        expect(existsSync(join(projectRoot, `${storyId}.txt`))).toBe(true);
+      }
+    });
+
+    test("retries once on conflict after rebasing worktree", async () => {
+      const storyIds = ["story-base", "story-conflict"];
+      const dependencies = {
+        "story-base": [],
+        "story-conflict": [],
+      };
+
+      // Create base story
+      await manager.create(projectRoot, "story-base");
+      const basePath = join(projectRoot, ".nax-wt", "story-base");
+      writeFileSync(join(basePath, "shared.txt"), "base content");
+      execSync("git add shared.txt", { cwd: basePath, stdio: "pipe" });
+      execSync('git commit -m "Add shared file"', {
+        cwd: basePath,
+        stdio: "pipe",
+      });
+
+      // Create conflicting story
+      await manager.create(projectRoot, "story-conflict");
+      const conflictPath = join(projectRoot, ".nax-wt", "story-conflict");
+      writeFileSync(join(conflictPath, "shared.txt"), "conflict content");
+      execSync("git add shared.txt", { cwd: conflictPath, stdio: "pipe" });
+      execSync('git commit -m "Add conflicting shared file"', {
+        cwd: conflictPath,
+        stdio: "pipe",
+      });
+
+      // This should handle the conflict scenario
+      const results = await engine.mergeAll(projectRoot, storyIds, dependencies);
+
+      expect(results.length).toBe(2);
+      // First story should succeed
+      expect(results[0].success).toBe(true);
+      expect(results[0].storyId).toBe("story-base");
+    });
+
+    test("marks story as failed on second conflict", async () => {
+      const storyIds = ["story-1", "story-2"];
+      const dependencies = {
+        "story-1": [],
+        "story-2": [],
+      };
+
+      // Create first story
+      await manager.create(projectRoot, "story-1");
+      const path1 = join(projectRoot, ".nax-wt", "story-1");
+      writeFileSync(join(path1, "conflict.txt"), "content 1");
+      execSync("git add conflict.txt", { cwd: path1, stdio: "pipe" });
+      execSync('git commit -m "Story 1"', { cwd: path1, stdio: "pipe" });
+
+      // Create second story with conflict
+      await manager.create(projectRoot, "story-2");
+      const path2 = join(projectRoot, ".nax-wt", "story-2");
+      writeFileSync(join(path2, "conflict.txt"), "content 2");
+      execSync("git add conflict.txt", { cwd: path2, stdio: "pipe" });
+      execSync('git commit -m "Story 2"', { cwd: path2, stdio: "pipe" });
+
+      const results = await engine.mergeAll(projectRoot, storyIds, dependencies);
+
+      // First should succeed, second should fail
+      expect(results.length).toBe(2);
+      expect(results[0].success).toBe(true);
+      expect(results[1].success).toBe(false);
+      expect(results[1].conflictFiles).toBeDefined();
+    });
+
+    test("continues with remaining stories after failure", async () => {
+      const storyIds = ["story-base", "story-conflict", "story-3"];
+      const dependencies = {
+        "story-base": [],
+        "story-conflict": [],
+        "story-3": [],
+      };
+
+      // Create base story with a file
+      await manager.create(projectRoot, "story-base");
+      const pathBase = join(projectRoot, ".nax-wt", "story-base");
+      writeFileSync(join(pathBase, "shared.txt"), "base content");
+      execSync("git add shared.txt", { cwd: pathBase, stdio: "pipe" });
+      execSync('git commit -m "Add shared file"', {
+        cwd: pathBase,
+        stdio: "pipe",
+      });
+
+      // Create conflicting story (modifies same file)
+      await manager.create(projectRoot, "story-conflict");
+      const pathConflict = join(projectRoot, ".nax-wt", "story-conflict");
+      writeFileSync(join(pathConflict, "shared.txt"), "conflict content");
+      execSync("git add shared.txt", {
+        cwd: pathConflict,
+        stdio: "pipe",
+      });
+      execSync('git commit -m "Modify shared file in story-conflict"', {
+        cwd: pathConflict,
+        stdio: "pipe",
+      });
+
+      // Create third story (no conflict)
+      await manager.create(projectRoot, "story-3");
+      const path3 = join(projectRoot, ".nax-wt", "story-3");
+      writeFileSync(join(path3, "file3.txt"), "content 3");
+      execSync("git add file3.txt", { cwd: path3, stdio: "pipe" });
+      execSync('git commit -m "Story 3"', { cwd: path3, stdio: "pipe" });
+
+      const results = await engine.mergeAll(projectRoot, storyIds, dependencies);
+
+      // Base should succeed, conflict should fail, story-3 should succeed
+      expect(results.length).toBe(3);
+      expect(results[0].success).toBe(true);
+      expect(results[0].storyId).toBe("story-base");
+      expect(results[1].success).toBe(false);
+      expect(results[1].storyId).toBe("story-conflict");
+      expect(results[2].success).toBe(true);
+      expect(results[2].storyId).toBe("story-3");
+    });
+  });
+});

package/test/manual/logging-formatter-demo.ts

@@ -0,0 +1,158 @@
+/**
+ * Manual demo of the logging formatter
+ *
+ * Run with: bun run test/manual/logging-formatter-demo.ts
+ */
+
+import type { LogEntry } from "../../src/logger/types.js";
+import { formatLogEntry, formatRunSummary } from "../../src/logging/formatter.js";
+import type { RunSummary } from "../../src/logging/types.js";
+
+console.log("\n=== LOGGING FORMATTER DEMO ===\n");
+
+// Run start
+const runStart: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "info",
+  stage: "run.start",
+  message: "Starting feature",
+  data: {
+    runId: "run-2026-02-27T14-00-00-000Z",
+    feature: "authentication",
+    workdir: "/Users/test/project",
+    totalStories: 5,
+  },
+};
+
+console.log(formatLogEntry(runStart, { mode: "normal", useColor: true }).output);
+
+// Story start
+const storyStart: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "info",
+  stage: "story.start",
+  storyId: "US-001",
+  message: "Starting story",
+  data: {
+    storyId: "US-001",
+    storyTitle: "Add user authentication with JWT",
+    complexity: "medium",
+    modelTier: "balanced",
+  },
+};
+
+console.log(formatLogEntry(storyStart, { mode: "normal", useColor: true }).output);
+
+// TDD session
+const tddSession: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "info",
+  stage: "tdd",
+  message: "→ Session: test-writer",
+  data: {
+    role: "test-writer",
+    storyId: "US-001",
+  },
+};
+
+console.log(formatLogEntry(tddSession, { mode: "normal", useColor: true }).output);
+
+// Routing (verbose only)
+const routing: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "debug",
+  stage: "routing",
+  message: "Task classified",
+  data: {
+    complexity: "medium",
+    modelTier: "balanced",
+    tokens: 1500,
+    contextFiles: ["src/auth.ts", "src/middleware.ts"],
+  },
+};
+
+console.log("\n--- Normal mode (should hide debug) ---");
+console.log(formatLogEntry(routing, { mode: "normal", useColor: true }).output);
+
+console.log("\n--- Verbose mode (should show debug with data) ---");
+console.log(formatLogEntry(routing, { mode: "verbose", useColor: true }).output);
+
+// Story complete - success
+const storySuccess: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "info",
+  stage: "story.complete",
+  storyId: "US-001",
+  message: "Story completed",
+  data: {
+    storyId: "US-001",
+    success: true,
+    cost: 0.2567,
+    durationMs: 45000,
+  },
+};
+
+console.log("\n");
+console.log(formatLogEntry(storySuccess, { mode: "normal", useColor: true }).output);
+
+// Story complete - escalation
+const storyEscalate: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "warn",
+  stage: "agent.complete",
+  storyId: "US-002",
+  message: "Escalated",
+  data: {
+    storyId: "US-002",
+    success: false,
+    finalAction: "escalate",
+    cost: 0.12,
+    durationMs: 30000,
+  },
+};
+
+console.log(formatLogEntry(storyEscalate, { mode: "normal", useColor: true }).output);
+
+// Story complete - failure
+const storyFail: LogEntry = {
+  timestamp: new Date().toISOString(),
+  level: "error",
+  stage: "story.complete",
+  storyId: "US-003",
+  message: "Failed",
+  data: {
+    storyId: "US-003",
+    success: false,
+    finalAction: "fail",
+    reason: "Test suite failed after 3 attempts",
+    cost: 0.35,
+    durationMs: 120000,
+  },
+};
+
+console.log(formatLogEntry(storyFail, { mode: "verbose", useColor: true }).output);
+
+// Run summary
+const summary: RunSummary = {
+  total: 10,
+  passed: 8,
+  failed: 1,
+  skipped: 1,
+  durationMs: 300000,
+  totalCost: 1.2345,
+  startedAt: "2026-02-27T14:00:00Z",
+  completedAt: "2026-02-27T14:05:00Z",
+};
+
+console.log(formatRunSummary(summary, { mode: "normal", useColor: true }));
+
+console.log("\n=== JSON MODE ===\n");
+console.log(formatLogEntry(storyStart, { mode: "json" }).output);
+console.log(formatRunSummary(summary, { mode: "json" }));
+
+console.log("\n=== QUIET MODE (only shows critical events) ===\n");
+console.log("Run start:", formatLogEntry(runStart, { mode: "quiet" }).shouldDisplay);
+console.log("Story start:", formatLogEntry(storyStart, { mode: "quiet" }).shouldDisplay);
+console.log("TDD session:", formatLogEntry(tddSession, { mode: "quiet" }).shouldDisplay);
+console.log("Routing debug:", formatLogEntry(routing, { mode: "quiet" }).shouldDisplay);
+console.log("Story complete:", formatLogEntry(storySuccess, { mode: "quiet" }).shouldDisplay);

package/test/ui/tui-agent-panel.test.tsx

@@ -0,0 +1,99 @@
+/**
+ * Tests for TUI Agent Panel and PTY integration (Phase 3).
+ */
+
+import { describe, expect, test } from "bun:test";
+import { render } from "ink-testing-library";
+import { ClaudeCodeAdapter } from "../../src/agents/claude";
+import type { PtyHandle } from "../../src/agents/types";
+import { AgentPanel } from "../../src/tui/components/AgentPanel";
+
+describe("AgentPanel", () => {
+  test("renders placeholder when no output", () => {
+    const { lastFrame } = render(<AgentPanel outputLines={[]} />);
+    expect(lastFrame()).toContain("Waiting for agent...");
+  });
+
+  test("renders output lines", () => {
+    const lines = ["Line 1", "Line 2", "Line 3"];
+    const { lastFrame } = render(<AgentPanel outputLines={lines} />);
+
+    for (const line of lines) {
+      expect(lastFrame()).toContain(line);
+    }
+  });
+
+  test("shows focus indicator when focused", () => {
+    const { lastFrame } = render(<AgentPanel focused outputLines={[]} />);
+    expect(lastFrame()).toContain("(focused)");
+  });
+
+  test("does not show focus indicator when not focused", () => {
+    const { lastFrame } = render(<AgentPanel focused={false} outputLines={[]} />);
+    expect(lastFrame()).not.toContain("(focused)");
+  });
+
+  test("buffers only last N lines", () => {
+    // Generate 600 lines (exceeds MAX_OUTPUT_LINES = 500)
+    const lines = Array.from({ length: 600 }, (_, i) => `Output ${i + 1}`);
+    const { lastFrame } = render(<AgentPanel outputLines={lines} />);
+    const frame = lastFrame();
+
+    // Should contain last 500 lines
+    expect(frame).toContain("Output 600");
+    expect(frame).toContain("Output 101");
+
+    // Should NOT contain first 100 lines (trimmed)
+    // Use exact line boundaries to avoid substring matches
+    expect(frame).not.toContain("Output 1\n");
+    expect(frame).not.toContain("Output 100\n");
+  });
+});
+
+describe("PtyHandle interface", () => {
+  test("ClaudeCodeAdapter has PtyHandle interface", () => {
+    const adapter = new ClaudeCodeAdapter();
+
+    // Check that runInteractive method exists
+    expect(adapter.runInteractive).toBeDefined();
+    expect(typeof adapter.runInteractive).toBe("function");
+  });
+
+  test("PtyHandle has required methods", () => {
+    // Mock PtyHandle to verify interface contract
+    const mockHandle: PtyHandle = {
+      write: (data: string) => {
+        expect(typeof data).toBe("string");
+      },
+      resize: (cols: number, rows: number) => {
+        expect(typeof cols).toBe("number");
+        expect(typeof rows).toBe("number");
+      },
+      kill: () => {
+        // noop
+      },
+      pid: 12345,
+    };
+
+    // Verify all methods exist
+    expect(mockHandle.write).toBeDefined();
+    expect(mockHandle.resize).toBeDefined();
+    expect(mockHandle.kill).toBeDefined();
+    expect(mockHandle.pid).toBe(12345);
+
+    // Test methods
+    mockHandle.write("test");
+    mockHandle.resize(80, 24);
+    mockHandle.kill();
+  });
+});
+
+describe("usePty hook", () => {
+  test("returns null handle when options is null", () => {
+    // This test would require rendering a component that uses usePty
+    // For now, we just document the expected behavior
+    // const { handle } = usePty(null);
+    // expect(handle).toBeNull();
+    expect(true).toBe(true); // Placeholder
+  });
+});