@nathapp/nax 0.18.1

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

@@ -0,0 +1,332 @@
+/**
+ * TUI Stories Panel Tests
+ *
+ * Tests the StoriesPanel component rendering with different story states,
+ * cost display, elapsed time formatting, and layout breakpoint logic.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { render } from "ink-testing-library";
+import { createElement } from "react";
+import type { UserStory } from "../../src/prd/types";
+import { StatusBar } from "../../src/tui/components/StatusBar";
+import { StoriesPanel } from "../../src/tui/components/StoriesPanel";
+import type { StoryDisplayState } from "../../src/tui/types";
+
+// Helper to create mock stories
+function createMockStory(id: string, status: StoryDisplayState["status"]): 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: 0.01,
+  };
+}
+
+describe("StoriesPanel", () => {
+  test("renders pending story with ⬚ icon", () => {
+    const stories = [createMockStory("US-001", "pending")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("⬚ US-001");
+  });
+
+  test("renders running story with 🔄 icon", () => {
+    const stories = [createMockStory("US-001", "running")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("🔄 US-001");
+  });
+
+  test("renders passed story with ✅ icon", () => {
+    const stories = [createMockStory("US-001", "passed")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("✅ US-001");
+  });
+
+  test("renders failed story with ❌ icon", () => {
+    const stories = [createMockStory("US-001", "failed")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("❌ US-001");
+  });
+
+  test("renders skipped story with ⏭️ icon", () => {
+    const stories = [createMockStory("US-001", "skipped")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("⏭️ US-001");
+  });
+
+  test("renders retrying story with 🔁 icon", () => {
+    const stories = [createMockStory("US-001", "retrying")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("🔁 US-001");
+  });
+
+  test("renders paused story with ⏸️ icon", () => {
+    const stories = [createMockStory("US-001", "paused")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("⏸️ US-001");
+  });
+
+  test("displays routing info (complexity and model tier)", () => {
+    const stories = [createMockStory("US-001", "pending")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("sim"); // "simple".slice(0, 3) = "sim"
+    expect(output).toContain("fast");
+  });
+
+  test("displays total cost", () => {
+    const stories = [createMockStory("US-001", "passed")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0.4235,
+        elapsedMs: 0,
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("$0.4235");
+  });
+
+  test("displays elapsed time in mm:ss format", () => {
+    const stories = [createMockStory("US-001", "running")];
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0,
+        elapsedMs: 263000, // 4 minutes 23 seconds
+        width: 30,
+      }),
+    );
+
+    expect(lastFrame()).toContain("4m 23s");
+  });
+
+  test("renders multiple stories", () => {
+    const stories = [
+      createMockStory("US-001", "passed"),
+      createMockStory("US-002", "running"),
+      createMockStory("US-003", "pending"),
+    ];
+
+    const { lastFrame } = render(
+      createElement(StoriesPanel, {
+        stories,
+        totalCost: 0.05,
+        elapsedMs: 120000,
+        width: 30,
+      }),
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("✅ US-001");
+    expect(output).toContain("🔄 US-002");
+    expect(output).toContain("⬚ US-003");
+  });
+});
+
+describe("StatusBar", () => {
+  test("displays 'Idle' when no current story", () => {
+    const { lastFrame } = render(createElement(StatusBar, {}));
+    expect(lastFrame()).toContain("Idle");
+  });
+
+  test("displays current story ID", () => {
+    const story: UserStory = {
+      id: "US-042",
+      title: "Test story",
+      description: "Test",
+      acceptanceCriteria: [],
+      dependencies: [],
+      tags: [],
+      passes: false,
+      status: "pending",
+      escalations: [],
+      attempts: 0,
+    };
+
+    const { lastFrame } = render(
+      createElement(StatusBar, {
+        currentStory: story,
+      }),
+    );
+
+    expect(lastFrame()).toContain("Story US-042");
+  });
+
+  test("displays current stage", () => {
+    const story: UserStory = {
+      id: "US-001",
+      title: "Test",
+      description: "Test",
+      acceptanceCriteria: [],
+      dependencies: [],
+      tags: [],
+      passes: false,
+      status: "pending",
+      escalations: [],
+      attempts: 0,
+    };
+
+    const { lastFrame } = render(
+      createElement(StatusBar, {
+        currentStory: story,
+        currentStage: "execution",
+      }),
+    );
+
+    expect(lastFrame()).toContain("execution");
+  });
+
+  test("displays model tier", () => {
+    const story: UserStory = {
+      id: "US-001",
+      title: "Test",
+      description: "Test",
+      acceptanceCriteria: [],
+      dependencies: [],
+      tags: [],
+      passes: false,
+      status: "pending",
+      escalations: [],
+      attempts: 0,
+    };
+
+    const { lastFrame } = render(
+      createElement(StatusBar, {
+        currentStory: story,
+        modelTier: "balanced",
+      }),
+    );
+
+    expect(lastFrame()).toContain("balanced");
+  });
+
+  test("displays test strategy", () => {
+    const story: UserStory = {
+      id: "US-001",
+      title: "Test",
+      description: "Test",
+      acceptanceCriteria: [],
+      dependencies: [],
+      tags: [],
+      passes: false,
+      status: "pending",
+      escalations: [],
+      attempts: 0,
+    };
+
+    const { lastFrame } = render(
+      createElement(StatusBar, {
+        currentStory: story,
+        testStrategy: "three-session-tdd",
+      }),
+    );
+
+    expect(lastFrame()).toContain("three-session-tdd");
+  });
+});
+
+describe("Layout breakpoints", () => {
+  test("single column mode for width < 80", () => {
+    // This would be tested via useLayout hook, but since we can't mock process.stdout.columns
+    // in Bun tests easily, we verify the logic manually:
+    const width = 70;
+    const mode = width < 80 ? "single" : width < 140 ? "narrow" : "wide";
+    expect(mode).toBe("single");
+  });
+
+  test("narrow mode for width 80-140", () => {
+    const width = 100;
+    const mode = width < 80 ? "single" : width < 140 ? "narrow" : "wide";
+    expect(mode).toBe("narrow");
+  });
+
+  test("wide mode for width > 140", () => {
+    const width = 150;
+    const mode = width < 80 ? "single" : width < 140 ? "narrow" : "wide";
+    expect(mode).toBe("wide");
+  });
+});

package/test/unit/acceptance.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Tests for acceptance test generation module
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  buildAcceptanceTestPrompt,
+  generateSkeletonTests,
+  parseAcceptanceCriteria,
+} from "../../src/acceptance/generator";
+
+describe("parseAcceptanceCriteria", () => {
+  test("parses AC-N: format", () => {
+    const spec = `
+## Acceptance Criteria
+- AC-1: System should handle empty input
+- AC-2: set(key, value, ttl) expires after ttl milliseconds
+`;
+
+    const criteria = parseAcceptanceCriteria(spec);
+
+    expect(criteria).toHaveLength(2);
+    expect(criteria[0]).toEqual({
+      id: "AC-1",
+      text: "System should handle empty input",
+      lineNumber: 3,
+    });
+    expect(criteria[1]).toEqual({
+      id: "AC-2",
+      text: "set(key, value, ttl) expires after ttl milliseconds",
+      lineNumber: 4,
+    });
+  });
+
+  test("parses checklist format", () => {
+    const spec = `
+## Acceptance Criteria
+- [ ] AC-1: Feature works correctly
+- [x] AC-2: Tests pass
+`;
+
+    const criteria = parseAcceptanceCriteria(spec);
+
+    expect(criteria).toHaveLength(2);
+    expect(criteria[0].id).toBe("AC-1");
+    expect(criteria[1].id).toBe("AC-2");
+  });
+
+  test("normalizes AC IDs to uppercase", () => {
+    const spec = "- ac-1: lowercase id";
+    const criteria = parseAcceptanceCriteria(spec);
+
+    expect(criteria[0].id).toBe("AC-1");
+  });
+
+  test("handles AC without list marker", () => {
+    const spec = `
+AC-1: Standalone criterion
+AC-2: Another criterion
+`;
+
+    const criteria = parseAcceptanceCriteria(spec);
+
+    expect(criteria).toHaveLength(2);
+    expect(criteria[0].text).toBe("Standalone criterion");
+  });
+
+  test("returns empty array when no AC found", () => {
+    const spec = `
+# Feature
+This is a spec with no acceptance criteria.
+`;
+
+    const criteria = parseAcceptanceCriteria(spec);
+
+    expect(criteria).toEqual([]);
+  });
+
+  test("tracks correct line numbers", () => {
+    const spec = `Line 1
+Line 2
+- AC-1: First criterion
+Line 4
+- AC-2: Second criterion`;
+
+    const criteria = parseAcceptanceCriteria(spec);
+
+    expect(criteria[0].lineNumber).toBe(3);
+    expect(criteria[1].lineNumber).toBe(5);
+  });
+});
+
+describe("buildAcceptanceTestPrompt", () => {
+  test("includes all criteria in prompt", () => {
+    const criteria = [
+      { id: "AC-1", text: "handles empty input", lineNumber: 5 },
+      { id: "AC-2", text: "validates email format", lineNumber: 6 },
+    ];
+
+    const prompt = buildAcceptanceTestPrompt(criteria, "auth", "File tree:\nsrc/\n  auth.ts\n");
+
+    expect(prompt).toContain("AC-1: handles empty input");
+    expect(prompt).toContain("AC-2: validates email format");
+    expect(prompt).toContain('"auth"');
+    expect(prompt).toContain("File tree:");
+  });
+
+  test("formats prompt with correct structure", () => {
+    const criteria = [{ id: "AC-1", text: "test criterion", lineNumber: 1 }];
+
+    const prompt = buildAcceptanceTestPrompt(criteria, "feature", "context");
+
+    expect(prompt).toContain("CODEBASE CONTEXT:");
+    expect(prompt).toContain("ACCEPTANCE CRITERIA:");
+    expect(prompt).toContain("One test per AC");
+    expect(prompt).toContain("bun:test");
+  });
+});
+
+describe("generateSkeletonTests", () => {
+  test("generates skeleton with TODO placeholders", () => {
+    const criteria = [
+      { id: "AC-1", text: "handles empty input", lineNumber: 5 },
+      { id: "AC-2", text: "validates email", lineNumber: 6 },
+    ];
+
+    const skeleton = generateSkeletonTests("auth", criteria);
+
+    expect(skeleton).toContain('describe("auth - Acceptance Tests"');
+    expect(skeleton).toContain('test("AC-1: handles empty input"');
+    expect(skeleton).toContain('test("AC-2: validates email"');
+    expect(skeleton).toContain("// TODO: Implement acceptance test for AC-1");
+    expect(skeleton).toContain("// TODO: Implement acceptance test for AC-2");
+    expect(skeleton).toContain("expect(true).toBe(false)");
+  });
+
+  test("generates valid TypeScript structure", () => {
+    const criteria = [{ id: "AC-1", text: "test", lineNumber: 1 }];
+
+    const skeleton = generateSkeletonTests("feature", criteria);
+
+    expect(skeleton).toContain('import { describe, test, expect } from "bun:test"');
+    expect(skeleton).toContain("describe(");
+    expect(skeleton).toContain("test(");
+    expect(skeleton).toContain("async () => {");
+  });
+
+  test("handles empty criteria array", () => {
+    const skeleton = generateSkeletonTests("feature", []);
+
+    expect(skeleton).toContain('describe("feature - Acceptance Tests"');
+    expect(skeleton).toContain("// No acceptance criteria found");
+  });
+
+  test("escapes special characters in criteria text", () => {
+    const criteria = [{ id: "AC-1", text: 'handles "quotes" correctly', lineNumber: 1 }];
+
+    const skeleton = generateSkeletonTests("feature", criteria);
+
+    // Should still contain the escaped text
+    expect(skeleton).toContain('handles "quotes" correctly');
+  });
+});
+
+describe("integration: AC parsing and skeleton generation", () => {
+  test("full workflow from spec to skeleton", () => {
+    const spec = `
+# Feature: URL Shortener
+
+## Acceptance Criteria
+- AC-1: Shortened URLs redirect to original URL
+- AC-2: Invalid URLs return 404
+- AC-3: Analytics track click counts
+`;
+
+    const criteria = parseAcceptanceCriteria(spec);
+    expect(criteria).toHaveLength(3);
+
+    const skeleton = generateSkeletonTests("url-shortener", criteria);
+
+    expect(skeleton).toContain("AC-1: Shortened URLs redirect to original URL");
+    expect(skeleton).toContain("AC-2: Invalid URLs return 404");
+    expect(skeleton).toContain("AC-3: Analytics track click counts");
+    expect(skeleton).toContain("url-shortener");
+  });
+});

package/test/unit/agent-stderr-capture.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Tests for stderr capture in agent result type
+ *
+ * Covers: AgentResult interface includes stderr field
+ */
+
+import { describe, expect, it } from "bun:test";
+import type { AgentResult } from "../../src/agents/types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Test fixtures
+// ─────────────────────────────────────────────────────────────────────────────
+
+function createAgentResult(overrides: Partial<AgentResult> = {}): AgentResult {
+  return {
+    success: false,
+    exitCode: 1,
+    output: "",
+    stderr: "",
+    rateLimited: false,
+    durationMs: 1000,
+    estimatedCost: 0.01,
+    ...overrides,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Tests for AgentResult interface
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("AgentResult stderr field", () => {
+  it("supports stderr field in AgentResult", () => {
+    const result = createAgentResult({
+      exitCode: 1,
+      stderr: "Error: 401 Unauthorized",
+    });
+
+    expect(result.stderr).toBe("Error: 401 Unauthorized");
+  });
+
+  it("supports empty stderr string", () => {
+    const result = createAgentResult({
+      stderr: "",
+    });
+
+    expect(result.stderr).toBe("");
+  });
+
+  it("supports undefined stderr for backward compatibility", () => {
+    const result: AgentResult = {
+      success: false,
+      exitCode: 1,
+      output: "output",
+      // stderr not provided
+      rateLimited: false,
+      durationMs: 1000,
+      estimatedCost: 0.01,
+    };
+
+    expect(result.stderr).toBeUndefined();
+  });
+
+  it("can store long error messages in stderr", () => {
+    const longStderr = "Error: ".padEnd(1000, "x");
+    const result = createAgentResult({
+      stderr: longStderr,
+    });
+
+    expect(result.stderr).toHaveLength(1000);
+    expect(result.stderr).toContain("Error:");
+  });
+
+  it("includes stderr in all failure scenarios", () => {
+    const scenarios = [
+      { exitCode: 1, stderr: "Generic error" },
+      { exitCode: 401, stderr: "Unauthorized" },
+      { exitCode: 500, stderr: "Internal server error" },
+      { exitCode: 124, stderr: "Timeout" },
+    ];
+
+    for (const scenario of scenarios) {
+      const result = createAgentResult({
+        exitCode: scenario.exitCode,
+        stderr: scenario.stderr,
+      });
+
+      expect(result.exitCode).toBe(scenario.exitCode);
+      expect(result.stderr).toBe(scenario.stderr);
+    }
+  });
+
+  it("preserves newlines in stderr", () => {
+    const multilineStderr = "Error: Something failed\nDetails: xyz\nContext: abc";
+    const result = createAgentResult({
+      stderr: multilineStderr,
+    });
+
+    expect(result.stderr).toContain("\n");
+    expect(result.stderr).toContain("Details:");
+  });
+
+  it("allows stderr with special characters", () => {
+    const specialStderr = 'Error: "quoted" with \\backslash and \t tab';
+    const result = createAgentResult({
+      stderr: specialStderr,
+    });
+
+    expect(result.stderr).toBe(specialStderr);
+  });
+
+  it("can be serialized to JSON", () => {
+    const result = createAgentResult({
+      exitCode: 401,
+      stderr: "401 Unauthorized: Invalid API key",
+    });
+
+    const json = JSON.stringify(result);
+    expect(json).toContain("401");
+    expect(json).toContain("Unauthorized");
+
+    const parsed = JSON.parse(json) as AgentResult;
+    expect(parsed.stderr).toBe("401 Unauthorized: Invalid API key");
+  });
+
+  it("maintains other fields when stderr is set", () => {
+    const result = createAgentResult({
+      success: false,
+      exitCode: 1,
+      output: "stdout output",
+      stderr: "stderr output",
+      rateLimited: false,
+      durationMs: 5000,
+      estimatedCost: 0.05,
+      pid: 12345,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.exitCode).toBe(1);
+    expect(result.output).toBe("stdout output");
+    expect(result.stderr).toBe("stderr output");
+    expect(result.rateLimited).toBe(false);
+    expect(result.durationMs).toBe(5000);
+    expect(result.estimatedCost).toBe(0.05);
+    expect(result.pid).toBe(12345);
+  });
+});