@nathapp/nax 0.18.1

package/test/ui/tui-controls.test.ts

@@ -0,0 +1,334 @@
+/**
+ * TUI Controls Tests
+ *
+ * Tests keyboard shortcuts, overlays, focus mode switching,
+ * and queue command writing.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { render } from "ink-testing-library";
+import { createElement } from "react";
+import type { UserStory } from "../../src/prd/types";
+import { CostOverlay } from "../../src/tui/components/CostOverlay";
+import { HelpOverlay } from "../../src/tui/components/HelpOverlay";
+import type { KeyboardAction } from "../../src/tui/hooks/useKeyboard";
+import { PanelFocus } from "../../src/tui/types";
+import type { StoryDisplayState } from "../../src/tui/types";
+import { writeQueueCommand } from "../../src/utils/queue-writer";
+
+// Helper to create mock stories
+function createMockStory(id: string, status: StoryDisplayState["status"], cost = 0.01): StoryDisplayState {
+  const story: UserStory = {
+    id,
+    title: `Test story ${id}`,
+    description: "Test description",
+    acceptanceCriteria: [],
+    dependencies: [],
+    tags: [],
+    passes: status === "passed",
+    status: status === "passed" ? "passed" : "pending",
+    escalations: [],
+    attempts: 0,
+  };
+
+  return {
+    story,
+    status,
+    routing: {
+      complexity: "simple",
+      modelTier: "fast",
+      testStrategy: "test-after",
+      reasoning: "Test routing",
+    },
+    cost,
+  };
+}
+
+describe("HelpOverlay", () => {
+  test("does not render when visible=false", () => {
+    const { lastFrame } = render(createElement(HelpOverlay, { visible: false }));
+    expect(lastFrame()).toBe("");
+  });
+
+  test("renders keybindings when visible=true", () => {
+    const { lastFrame } = render(createElement(HelpOverlay, { visible: true }));
+    const output = lastFrame();
+
+    expect(output).toContain("Keyboard Shortcuts");
+    expect(output).toContain("p"); // Pause
+    expect(output).toContain("a"); // Abort
+    expect(output).toContain("s"); // Skip
+    expect(output).toContain("Tab"); // Toggle focus
+    expect(output).toContain("q"); // Quit
+    expect(output).toContain("?"); // Show help
+    expect(output).toContain("c"); // Show cost
+    expect(output).toContain("r"); // Retry
+    expect(output).toContain("Esc"); // Close overlay
+    expect(output).toContain("Ctrl+]"); // Escape agent panel
+  });
+
+  test("displays Stories panel keybindings", () => {
+    const { lastFrame } = render(createElement(HelpOverlay, { visible: true }));
+    const output = lastFrame();
+
+    expect(output).toContain("Stories Panel");
+    expect(output).toContain("Pause after current story");
+    expect(output).toContain("Abort run");
+    expect(output).toContain("Skip current story");
+  });
+
+  test("displays Agent panel keybindings", () => {
+    const { lastFrame } = render(createElement(HelpOverlay, { visible: true }));
+    const output = lastFrame();
+
+    expect(output).toContain("Agent Panel");
+    expect(output).toContain("Escape back to Stories panel");
+    expect(output).toContain("Forwarded to agent PTY");
+  });
+});
+
+describe("CostOverlay", () => {
+  test("does not render when visible=false", () => {
+    const { lastFrame } = render(createElement(CostOverlay, { visible: false }));
+    expect(lastFrame()).toBe("");
+  });
+
+  test("renders cost breakdown when visible=true", () => {
+    const stories = [
+      createMockStory("US-001", "passed", 0.023),
+      createMockStory("US-002", "running", 0.015),
+      createMockStory("US-003", "pending", 0),
+    ];
+
+    const { lastFrame } = render(
+      createElement(CostOverlay, {
+        visible: true,
+        stories,
+        totalCost: 0.038,
+      }),
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("Cost Breakdown");
+    expect(output).toContain("Story ID");
+    expect(output).toContain("Status");
+    expect(output).toContain("Cost");
+  });
+
+  test("displays executed stories with costs", () => {
+    const stories = [createMockStory("US-001", "passed", 0.023), createMockStory("US-002", "failed", 0.015)];
+
+    const { lastFrame } = render(
+      createElement(CostOverlay, {
+        visible: true,
+        stories,
+        totalCost: 0.038,
+      }),
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("US-001");
+    expect(output).toContain("passed");
+    expect(output).toContain("$0.0230");
+    expect(output).toContain("US-002");
+    expect(output).toContain("failed");
+    expect(output).toContain("$0.0150");
+  });
+
+  test("displays total cost", () => {
+    const stories = [createMockStory("US-001", "passed", 0.023)];
+
+    const { lastFrame } = render(
+      createElement(CostOverlay, {
+        visible: true,
+        stories,
+        totalCost: 0.123456,
+      }),
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("Total Cost:");
+    expect(output).toContain("$0.1235");
+  });
+
+  test("shows message when no stories executed", () => {
+    const stories = [createMockStory("US-001", "pending", 0)];
+
+    const { lastFrame } = render(
+      createElement(CostOverlay, {
+        visible: true,
+        stories,
+        totalCost: 0,
+      }),
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("No stories executed yet");
+  });
+});
+
+describe("Keyboard action types", () => {
+  test("PAUSE action has correct type", () => {
+    const action: KeyboardAction = { type: "PAUSE" };
+    expect(action.type).toBe("PAUSE");
+  });
+
+  test("ABORT action has correct type", () => {
+    const action: KeyboardAction = { type: "ABORT" };
+    expect(action.type).toBe("ABORT");
+  });
+
+  test("SKIP action has story ID", () => {
+    const action: KeyboardAction = { type: "SKIP", storyId: "US-042" };
+    expect(action.type).toBe("SKIP");
+    expect(action.storyId).toBe("US-042");
+  });
+
+  test("TOGGLE_FOCUS action has correct type", () => {
+    const action: KeyboardAction = { type: "TOGGLE_FOCUS" };
+    expect(action.type).toBe("TOGGLE_FOCUS");
+  });
+
+  test("ESCAPE_AGENT action has correct type", () => {
+    const action: KeyboardAction = { type: "ESCAPE_AGENT" };
+    expect(action.type).toBe("ESCAPE_AGENT");
+  });
+
+  test("QUIT action has correct type", () => {
+    const action: KeyboardAction = { type: "QUIT" };
+    expect(action.type).toBe("QUIT");
+  });
+
+  test("SHOW_HELP action has correct type", () => {
+    const action: KeyboardAction = { type: "SHOW_HELP" };
+    expect(action.type).toBe("SHOW_HELP");
+  });
+
+  test("SHOW_COST action has correct type", () => {
+    const action: KeyboardAction = { type: "SHOW_COST" };
+    expect(action.type).toBe("SHOW_COST");
+  });
+
+  test("RETRY action has correct type", () => {
+    const action: KeyboardAction = { type: "RETRY" };
+    expect(action.type).toBe("RETRY");
+  });
+
+  test("CLOSE_OVERLAY action has correct type", () => {
+    const action: KeyboardAction = { type: "CLOSE_OVERLAY" };
+    expect(action.type).toBe("CLOSE_OVERLAY");
+  });
+});
+
+describe("Focus mode", () => {
+  test("PanelFocus enum has Stories value", () => {
+    expect(PanelFocus.Stories).toBe("stories");
+  });
+
+  test("PanelFocus enum has Agent value", () => {
+    expect(PanelFocus.Agent).toBe("agent");
+  });
+
+  test("focus mode toggles between Stories and Agent", () => {
+    let focus: PanelFocus = PanelFocus.Stories;
+    focus = focus === PanelFocus.Stories ? PanelFocus.Agent : PanelFocus.Stories;
+    expect(focus).toBe(PanelFocus.Agent);
+
+    focus = focus === PanelFocus.Stories ? PanelFocus.Agent : PanelFocus.Stories;
+    expect(focus).toBe(PanelFocus.Stories);
+  });
+});
+
+describe("Queue command writer", () => {
+  const tempQueueFile = "/tmp/nax-test-queue.txt";
+
+  beforeEach(async () => {
+    // Clean up any existing test file
+    try {
+      await unlink(tempQueueFile);
+    } catch {
+      // Ignore if doesn't exist
+    }
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    try {
+      await unlink(tempQueueFile);
+    } catch {
+      // Ignore if doesn't exist
+    }
+  });
+
+  test("writes PAUSE command to queue file", async () => {
+    await writeQueueCommand(tempQueueFile, { type: "PAUSE" });
+
+    const content = await Bun.file(tempQueueFile).text();
+    expect(content.trim()).toBe("PAUSE");
+  });
+
+  test("writes ABORT command to queue file", async () => {
+    await writeQueueCommand(tempQueueFile, { type: "ABORT" });
+
+    const content = await Bun.file(tempQueueFile).text();
+    expect(content.trim()).toBe("ABORT");
+  });
+
+  test("writes SKIP command with story ID to queue file", async () => {
+    await writeQueueCommand(tempQueueFile, { type: "SKIP", storyId: "US-042" });
+
+    const content = await Bun.file(tempQueueFile).text();
+    expect(content.trim()).toBe("SKIP US-042");
+  });
+
+  test("appends multiple commands to queue file", async () => {
+    await writeQueueCommand(tempQueueFile, { type: "SKIP", storyId: "US-001" });
+    await writeQueueCommand(tempQueueFile, { type: "PAUSE" });
+    await writeQueueCommand(tempQueueFile, { type: "ABORT" });
+
+    const content = await Bun.file(tempQueueFile).text();
+    const lines = content.trim().split("\n");
+
+    expect(lines).toEqual(["SKIP US-001", "PAUSE", "ABORT"]);
+  });
+
+  test("creates queue file if it doesn't exist", async () => {
+    // Ensure file doesn't exist
+    try {
+      await unlink(tempQueueFile);
+    } catch {
+      // Ignore
+    }
+
+    await writeQueueCommand(tempQueueFile, { type: "PAUSE" });
+
+    const file = Bun.file(tempQueueFile);
+    expect(await file.exists()).toBe(true);
+
+    const content = await file.text();
+    expect(content.trim()).toBe("PAUSE");
+  });
+});
+
+describe("Ctrl+] escape sequence", () => {
+  test("Ctrl+] should escape from agent panel", () => {
+    // This would be tested in integration with the useKeyboard hook
+    // For now, we verify the concept:
+    const input = "]";
+    const keyCtrl = true;
+
+    if (keyCtrl && input === "]") {
+      const action: KeyboardAction = { type: "ESCAPE_AGENT" };
+      expect(action.type).toBe("ESCAPE_AGENT");
+    }
+  });
+
+  test("regular ] without Ctrl should not escape", () => {
+    const input = "]";
+    const keyCtrl = false;
+
+    // Should not trigger escape
+    expect(keyCtrl && input === "]").toBe(false);
+  });
+});

package/test/ui/tui-cost-and-pty.test.ts

@@ -0,0 +1,189 @@
+/**
+ * TUI Cost Accumulation and PTY Line Length Tests
+ *
+ * Tests for BUG-1 (story cost accumulation) and MEM-1 (PTY line length limits).
+ */
+
+import { describe, expect, test } from "bun:test";
+import { PipelineEventEmitter } from "../../src/pipeline/events";
+import type { StageResult } from "../../src/pipeline/types";
+import type { UserStory } from "../../src/prd/types";
+
+// ── Test Fixtures ────────────────────────────────────
+
+const createMockStory = (id: string): UserStory => ({
+  id,
+  title: `Test story ${id}`,
+  description: "Test description",
+  acceptanceCriteria: [],
+  dependencies: [],
+  tags: [],
+  passes: false,
+  status: "pending",
+  escalations: [],
+  attempts: 0,
+});
+
+// ── Cost Accumulation Tests (BUG-1) ──────────────────
+
+describe("StageResult - Cost field in types (BUG-1)", () => {
+  test("should support cost field in continue action", () => {
+    const result: StageResult = { action: "continue", cost: 0.05 };
+    expect(result.action).toBe("continue");
+    expect(result.cost).toBe(0.05);
+  });
+
+  test("should support cost field in fail action", () => {
+    const result: StageResult = { action: "fail", reason: "Build failed", cost: 0.02 };
+    expect(result.action).toBe("fail");
+    expect(result.cost).toBe(0.02);
+  });
+
+  test("should support cost field in skip action", () => {
+    const result: StageResult = { action: "skip", reason: "Dependency not met", cost: 0.01 };
+    expect(result.action).toBe("skip");
+    expect(result.cost).toBe(0.01);
+  });
+
+  test("should support cost field in escalate action", () => {
+    const result: StageResult = { action: "escalate", cost: 0.03 };
+    expect(result.action).toBe("escalate");
+    expect(result.cost).toBe(0.03);
+  });
+
+  test("should support cost field in pause action", () => {
+    const result: StageResult = { action: "pause", reason: "User requested", cost: 0.01 };
+    expect(result.action).toBe("pause");
+    expect(result.cost).toBe(0.01);
+  });
+
+  test("should allow omitting cost field (backward compatibility)", () => {
+    const result: StageResult = { action: "continue" };
+    expect(result.action).toBe("continue");
+    expect(result.cost).toBeUndefined();
+  });
+});
+
+describe("PipelineEventEmitter - Cost in story:complete (BUG-1)", () => {
+  test("should emit story:complete with cost field", () => {
+    const emitter = new PipelineEventEmitter();
+    const story = createMockStory("US-001");
+
+    const events: Array<{ story: UserStory; result: StageResult }> = [];
+    emitter.on("story:complete", (story, result) => {
+      events.push({ story, result });
+    });
+
+    const result: StageResult = { action: "continue", cost: 0.05 };
+    emitter.emit("story:complete", story, result);
+
+    expect(events).toHaveLength(1);
+    expect(events[0].story.id).toBe("US-001");
+    expect(events[0].result.cost).toBe(0.05);
+  });
+
+  test("should emit story:complete without cost field", () => {
+    const emitter = new PipelineEventEmitter();
+    const story = createMockStory("US-001");
+
+    const events: Array<{ story: UserStory; result: StageResult }> = [];
+    emitter.on("story:complete", (story, result) => {
+      events.push({ story, result });
+    });
+
+    const result: StageResult = { action: "continue" };
+    emitter.emit("story:complete", story, result);
+
+    expect(events).toHaveLength(1);
+    expect(events[0].result.cost).toBeUndefined();
+  });
+});
+
+// ── PTY Line Length Tests (MEM-1) ────────────────────
+
+describe("usePty - Line Length Limits (MEM-1)", () => {
+  test("should truncate lines exceeding MAX_LINE_LENGTH", async () => {
+    // This test verifies the line truncation logic exists
+    // We'll check the source code directly since node-pty mocking is complex
+
+    const usePtySource = await Bun.file("src/tui/hooks/usePty.ts").text();
+
+    // Verify MAX_LINE_LENGTH constant exists
+    expect(usePtySource).toContain("const MAX_LINE_LENGTH = 10_000");
+
+    // Verify truncation logic for complete lines
+    expect(usePtySource).toContain("line.length > MAX_LINE_LENGTH");
+    expect(usePtySource).toContain("`${line.slice(0, MAX_LINE_LENGTH)}…` : line");
+
+    // Verify truncation logic for incomplete lines (currentLine)
+    expect(usePtySource).toContain("if (currentLine.length > MAX_LINE_LENGTH)");
+    expect(usePtySource).toContain("currentLine = currentLine.slice(-MAX_LINE_LENGTH)");
+  });
+
+  test("should have MAX_LINE_LENGTH constant set to 10000", async () => {
+    const usePtySource = await Bun.file("src/tui/hooks/usePty.ts").text();
+    const match = usePtySource.match(/const MAX_LINE_LENGTH = ([\d_]+)/);
+
+    expect(match).toBeTruthy();
+    expect(match?.[1]).toBe("10_000");
+  });
+
+  test("PTY truncation behavior - unit test for truncation logic", () => {
+    const MAX_LINE_LENGTH = 10_000;
+
+    // Simulate the truncation logic
+    const longLine = "x".repeat(15_000);
+    const truncatedLine = longLine.length > MAX_LINE_LENGTH ? longLine.slice(0, MAX_LINE_LENGTH) + "…" : longLine;
+
+    expect(truncatedLine.length).toBe(MAX_LINE_LENGTH + 1); // +1 for ellipsis
+    expect(truncatedLine.endsWith("…")).toBe(true);
+    expect(truncatedLine.startsWith("x".repeat(100))).toBe(true);
+  });
+
+  test("PTY incomplete line truncation - unit test for currentLine logic", () => {
+    const MAX_LINE_LENGTH = 10_000;
+
+    // Simulate incomplete line accumulation
+    let currentLine = "y".repeat(15_000);
+
+    // Apply truncation (keep last N chars)
+    if (currentLine.length > MAX_LINE_LENGTH) {
+      currentLine = currentLine.slice(-MAX_LINE_LENGTH);
+    }
+
+    expect(currentLine.length).toBe(MAX_LINE_LENGTH);
+    expect(currentLine).toBe("y".repeat(MAX_LINE_LENGTH));
+  });
+});
+
+// ── Integration Test: Cost Events ────────────────────
+
+describe("Integration - Cost in multiple story:complete events", () => {
+  test("should emit multiple story:complete events with different costs", () => {
+    const emitter = new PipelineEventEmitter();
+    const stories = [createMockStory("US-001"), createMockStory("US-002"), createMockStory("US-003")];
+
+    const events: Array<{ story: UserStory; result: StageResult }> = [];
+    emitter.on("story:complete", (story, result) => {
+      events.push({ story, result });
+    });
+
+    // Story 1: passed ($0.05)
+    emitter.emit("story:complete", stories[0], { action: "continue", cost: 0.05 });
+
+    // Story 2: failed ($0.03)
+    emitter.emit("story:complete", stories[1], { action: "fail", reason: "test", cost: 0.03 });
+
+    // Story 3: skipped ($0.01)
+    emitter.emit("story:complete", stories[2], { action: "skip", reason: "test", cost: 0.01 });
+
+    expect(events).toHaveLength(3);
+    expect(events[0].result.cost).toBe(0.05);
+    expect(events[1].result.cost).toBe(0.03);
+    expect(events[2].result.cost).toBe(0.01);
+
+    // Verify total cost would be sum
+    const totalCost = events.reduce((sum, e) => sum + (e.result.cost || 0), 0);
+    expect(totalCost).toBe(0.09);
+  });
+});