@nathapp/nax 0.18.1

package/test/unit/test-output-parser.test.ts

@@ -0,0 +1,377 @@
+import { describe, expect, test } from "bun:test";
+import { type TestFailure, formatFailureSummary, parseBunTestOutput } from "../../src/execution/test-output-parser";
+
+describe("parseBunTestOutput", () => {
+  test("parses passing output (0 failures)", () => {
+    const output = `
+bun test v1.0.0
+
+test/example.test.ts:
+✓ test 1 [0.5ms]
+✓ test 2 [0.3ms]
+✓ test 3 [0.7ms]
+
+3 tests passed [1.5ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.passed).toBe(3);
+    expect(result.failed).toBe(0);
+    expect(result.failures).toHaveLength(0);
+  });
+
+  test("parses mixed pass/fail output", () => {
+    const output = `
+bun test v1.0.0
+
+test/example.test.ts:
+✓ passing test [0.5ms]
+✗ failing test [1.2ms]
+
+(fail) failing test [1.2ms]
+Error: Expected 1 to equal 2
+  at /path/to/file.ts:10:15
+  at Object.test (/path/to/file.ts:8:3)
+
+1 passed, 1 failed [1.7ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.passed).toBe(1);
+    expect(result.failed).toBe(1);
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0].file).toBe("test/example.test.ts");
+    expect(result.failures[0].testName).toBe("failing test");
+    expect(result.failures[0].error).toBe("Error: Expected 1 to equal 2");
+    expect(result.failures[0].stackTrace).toHaveLength(2);
+  });
+
+  test("extracts test names from nested describe blocks", () => {
+    const output = `
+bun test v1.0.0
+
+test/nested.test.ts:
+✓ outer test [0.2ms]
+✗ inner test [0.8ms]
+
+(fail) describe block > nested block > inner test [0.8ms]
+Error: Assertion failed
+  at /path/to/nested.ts:20:10
+
+1 passed, 1 failed [1.0ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0].testName).toBe("describe block > nested block > inner test");
+    expect(result.failures[0].file).toBe("test/nested.test.ts");
+  });
+
+  test("truncates stack trace to 5 lines", () => {
+    const output = `
+bun test v1.0.0
+
+test/stack.test.ts:
+✗ test with long stack [2.0ms]
+
+(fail) test with long stack [2.0ms]
+Error: Stack overflow
+  at line1 (/path/to/file.ts:1:1)
+  at line2 (/path/to/file.ts:2:2)
+  at line3 (/path/to/file.ts:3:3)
+  at line4 (/path/to/file.ts:4:4)
+  at line5 (/path/to/file.ts:5:5)
+  at line6 (/path/to/file.ts:6:6)
+  at line7 (/path/to/file.ts:7:7)
+  at line8 (/path/to/file.ts:8:8)
+
+0 passed, 1 failed [2.0ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0].stackTrace).toHaveLength(5);
+    expect(result.failures[0].stackTrace[0]).toBe("at line1 (/path/to/file.ts:1:1)");
+    expect(result.failures[0].stackTrace[4]).toBe("at line5 (/path/to/file.ts:5:5)");
+  });
+
+  test("handles empty/malformed input", () => {
+    const emptyResult = parseBunTestOutput("");
+    expect(emptyResult.passed).toBe(0);
+    expect(emptyResult.failed).toBe(0);
+    expect(emptyResult.failures).toHaveLength(0);
+
+    const malformedResult = parseBunTestOutput("random text\nno test output");
+    expect(malformedResult.passed).toBe(0);
+    expect(malformedResult.failed).toBe(0);
+    expect(malformedResult.failures).toHaveLength(0);
+  });
+
+  test("handles multiple test files", () => {
+    const output = `
+bun test v1.0.0
+
+test/file1.test.ts:
+✓ test 1 [0.5ms]
+✗ test 2 [1.2ms]
+
+(fail) test 2 [1.2ms]
+Error: File 1 error
+  at /path/to/file1.ts:10:15
+
+test/file2.test.ts:
+✓ test 3 [0.3ms]
+✗ test 4 [0.8ms]
+
+(fail) test 4 [0.8ms]
+Error: File 2 error
+  at /path/to/file2.ts:20:25
+
+2 passed, 2 failed [2.8ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.passed).toBe(2);
+    expect(result.failed).toBe(2);
+    expect(result.failures).toHaveLength(2);
+    expect(result.failures[0].file).toBe("test/file1.test.ts");
+    expect(result.failures[0].error).toBe("Error: File 1 error");
+    expect(result.failures[1].file).toBe("test/file2.test.ts");
+    expect(result.failures[1].error).toBe("Error: File 2 error");
+  });
+
+  test("handles test files with .js extension", () => {
+    const output = `
+bun test v1.0.0
+
+test/example.test.js:
+✗ failing test [1.0ms]
+
+(fail) failing test [1.0ms]
+Error: JS test error
+  at /path/to/file.js:5:10
+
+0 passed, 1 failed [1.0ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0].file).toBe("test/example.test.js");
+  });
+
+  test("handles failures without file context", () => {
+    const output = `
+bun test v1.0.0
+
+✗ orphan test [1.0ms]
+
+(fail) orphan test [1.0ms]
+Error: No file context
+  at /path/to/unknown.ts:1:1
+
+0 passed, 1 failed [1.0ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0].file).toBe("unknown");
+  });
+
+  test("handles failures with no error message", () => {
+    const output = `
+bun test v1.0.0
+
+test/minimal.test.ts:
+✗ minimal fail [0.5ms]
+
+(fail) minimal fail [0.5ms]
+
+0 passed, 1 failed [0.5ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.failures).toHaveLength(1);
+    expect(result.failures[0].error).toBe("Unknown error");
+    expect(result.failures[0].stackTrace).toHaveLength(0);
+  });
+
+  test("handles alternative check marks (✔ and ✘)", () => {
+    const output = `
+bun test v1.0.0
+
+test/marks.test.ts:
+✔ pass with heavy check [0.2ms]
+✘ fail with heavy X [0.5ms]
+
+(fail) fail with heavy X [0.5ms]
+Error: Alternative marks error
+
+1 passed, 1 failed [0.7ms]
+    `.trim();
+
+    const result = parseBunTestOutput(output);
+
+    expect(result.passed).toBe(1);
+    expect(result.failed).toBe(1);
+    expect(result.failures).toHaveLength(1);
+  });
+});
+
+describe("formatFailureSummary", () => {
+  test("returns 'No test failures' for empty array", () => {
+    const result = formatFailureSummary([]);
+    expect(result).toBe("No test failures");
+  });
+
+  test("formats single failure", () => {
+    const failures: TestFailure[] = [
+      {
+        file: "test/example.test.ts",
+        testName: "failing test",
+        error: "Expected 1 to equal 2",
+        stackTrace: ["at /path/to/file.ts:10:15"],
+      },
+    ];
+
+    const result = formatFailureSummary(failures);
+
+    expect(result).toContain("1. test/example.test.ts > failing test");
+    expect(result).toContain("Error: Expected 1 to equal 2");
+    expect(result).toContain("at /path/to/file.ts:10:15");
+  });
+
+  test("formats multiple failures", () => {
+    const failures: TestFailure[] = [
+      {
+        file: "test/file1.test.ts",
+        testName: "test 1",
+        error: "Error 1",
+        stackTrace: ["at /path/file1.ts:5:10"],
+      },
+      {
+        file: "test/file2.test.ts",
+        testName: "test 2",
+        error: "Error 2",
+        stackTrace: ["at /path/file2.ts:15:20"],
+      },
+    ];
+
+    const result = formatFailureSummary(failures);
+
+    expect(result).toContain("1. test/file1.test.ts > test 1");
+    expect(result).toContain("Error: Error 1");
+    expect(result).toContain("2. test/file2.test.ts > test 2");
+    expect(result).toContain("Error: Error 2");
+  });
+
+  test("respects maxChars limit", () => {
+    const failures: TestFailure[] = Array.from({ length: 10 }, (_, i) => ({
+      file: `test/file${i}.test.ts`,
+      testName: `test ${i}`,
+      error: `Error message ${i}`,
+      stackTrace: [`at /path/file${i}.ts:${i}:${i}`],
+    }));
+
+    const result = formatFailureSummary(failures, 300);
+
+    expect(result.length).toBeLessThanOrEqual(350); // Some buffer for truncation message
+    expect(result).toContain("... and");
+    expect(result).toContain("more failure(s) (truncated)");
+  });
+
+  test("handles failure without stack trace", () => {
+    const failures: TestFailure[] = [
+      {
+        file: "test/nostack.test.ts",
+        testName: "no stack",
+        error: "Error without stack",
+        stackTrace: [],
+      },
+    ];
+
+    const result = formatFailureSummary(failures);
+
+    expect(result).toContain("1. test/nostack.test.ts > no stack");
+    expect(result).toContain("Error: Error without stack");
+    expect(result).not.toContain("at ");
+  });
+
+  test("handles nested test names", () => {
+    const failures: TestFailure[] = [
+      {
+        file: "test/nested.test.ts",
+        testName: "outer > middle > inner",
+        error: "Nested test error",
+        stackTrace: ["at /path/nested.ts:30:5"],
+      },
+    ];
+
+    const result = formatFailureSummary(failures);
+
+    expect(result).toContain("1. test/nested.test.ts > outer > middle > inner");
+    expect(result).toContain("Error: Nested test error");
+  });
+
+  test("includes only first stack trace line", () => {
+    const failures: TestFailure[] = [
+      {
+        file: "test/multi.test.ts",
+        testName: "multi stack",
+        error: "Error with multiple stack lines",
+        stackTrace: ["at /path/file.ts:10:5", "at /path/file.ts:20:10", "at /path/file.ts:30:15"],
+      },
+    ];
+
+    const result = formatFailureSummary(failures);
+
+    expect(result).toContain("at /path/file.ts:10:5");
+    expect(result).not.toContain("at /path/file.ts:20:10");
+    expect(result).not.toContain("at /path/file.ts:30:15");
+  });
+
+  test("separates failures with blank lines", () => {
+    const failures: TestFailure[] = [
+      {
+        file: "test/a.test.ts",
+        testName: "test a",
+        error: "Error A",
+        stackTrace: ["at a.ts:1:1"],
+      },
+      {
+        file: "test/b.test.ts",
+        testName: "test b",
+        error: "Error B",
+        stackTrace: ["at b.ts:2:2"],
+      },
+    ];
+
+    const result = formatFailureSummary(failures);
+
+    // Check that there's proper separation between failures
+    const lines = result.split("\n");
+    const blankLines = lines.filter((line) => line.trim() === "");
+    expect(blankLines.length).toBeGreaterThan(0);
+  });
+
+  test("uses default maxChars of 2000", () => {
+    const failures: TestFailure[] = Array.from({ length: 50 }, (_, i) => ({
+      file: `test/file${i}.test.ts`,
+      testName: `test ${i}`,
+      error: `Error message ${i}`,
+      stackTrace: [`at /path/file${i}.ts:${i}:${i}`],
+    }));
+
+    const result = formatFailureSummary(failures); // No maxChars argument
+
+    expect(result.length).toBeLessThanOrEqual(2100); // Some buffer
+    expect(result).toContain("(truncated)");
+  });
+});

package/test/unit/verdict.test.ts

@@ -0,0 +1,324 @@
+/**
+ * Tests for src/tdd/verdict.ts
+ *
+ * Covers: readVerdict, cleanupVerdict, categorizeVerdict
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { categorizeVerdict, cleanupVerdict, readVerdict } from "../../src/tdd/verdict";
+import type { VerifierVerdict } from "../../src/tdd/verdict";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Test fixtures
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Build a fully valid verdict with sensible defaults. */
+function makeVerdict(overrides: Partial<VerifierVerdict> = {}): VerifierVerdict {
+  return {
+    version: 1,
+    approved: true,
+    tests: { allPassing: true, passCount: 10, failCount: 0 },
+    testModifications: { detected: false, files: [], legitimate: true, reasoning: "No modifications" },
+    acceptanceCriteria: {
+      allMet: true,
+      criteria: [{ criterion: "Feature works", met: true }],
+    },
+    quality: { rating: "good", issues: [] },
+    fixes: [],
+    reasoning: "All good.",
+    ...overrides,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Setup / teardown
+// ─────────────────────────────────────────────────────────────────────────────
+
+let workdir: string;
+
+beforeEach(async () => {
+  workdir = path.join(tmpdir(), `verdict-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  await mkdir(workdir, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(workdir, { recursive: true, force: true });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// readVerdict
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("readVerdict", () => {
+  it("returns parsed verdict when file exists and is valid", async () => {
+    const verdict = makeVerdict();
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(verdict), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).not.toBeNull();
+    expect(result?.version).toBe(1);
+    expect(result?.approved).toBe(true);
+    expect(result?.tests.allPassing).toBe(true);
+    expect(result?.tests.passCount).toBe(10);
+    expect(result?.tests.failCount).toBe(0);
+  });
+
+  it("returns null when file does not exist (no throw)", async () => {
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when JSON is malformed (no throw, logs warning)", async () => {
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), "{ this is not valid json !!!", "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when required field 'version' is missing", async () => {
+    const bad = { approved: true, tests: { allPassing: true, passCount: 5, failCount: 0 } };
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when required field 'approved' is missing", async () => {
+    const bad = { version: 1, tests: { allPassing: true, passCount: 5, failCount: 0 } };
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when required field 'tests' is missing", async () => {
+    const bad = { version: 1, approved: true };
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when tests sub-fields are missing", async () => {
+    const bad = { version: 1, approved: true, tests: { allPassing: true } };
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when version is not 1", async () => {
+    const bad = { version: 2, approved: true, tests: { allPassing: true, passCount: 5, failCount: 0 } };
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null for empty JSON object", async () => {
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify({}), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+
+  it("returns null for JSON array (not an object)", async () => {
+    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify([1, 2, 3]), "utf-8");
+
+    const result = await readVerdict(workdir);
+    expect(result).toBeNull();
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// cleanupVerdict
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("cleanupVerdict", () => {
+  it("deletes the verdict file when it exists", async () => {
+    const verdictPath = path.join(workdir, ".nax-verifier-verdict.json");
+    await writeFile(verdictPath, JSON.stringify(makeVerdict()), "utf-8");
+
+    expect(existsSync(verdictPath)).toBe(true);
+
+    await cleanupVerdict(workdir);
+
+    expect(existsSync(verdictPath)).toBe(false);
+  });
+
+  it("does not throw when verdict file does not exist", async () => {
+    // Should not throw
+    await expect(cleanupVerdict(workdir)).resolves.toBeUndefined();
+  });
+
+  it("does not throw when called twice (second call is a no-op)", async () => {
+    const verdictPath = path.join(workdir, ".nax-verifier-verdict.json");
+    await writeFile(verdictPath, JSON.stringify(makeVerdict()), "utf-8");
+
+    await cleanupVerdict(workdir);
+    // Second call — file already gone
+    await expect(cleanupVerdict(workdir)).resolves.toBeUndefined();
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// categorizeVerdict — with valid verdict
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("categorizeVerdict — with verdict", () => {
+  it("returns success when approved=true", () => {
+    const result = categorizeVerdict(makeVerdict({ approved: true }), false);
+    expect(result.success).toBe(true);
+    expect(result.failureCategory).toBeUndefined();
+  });
+
+  it("returns success when approved=true regardless of testsPass", () => {
+    const result = categorizeVerdict(makeVerdict({ approved: true }), false);
+    expect(result.success).toBe(true);
+  });
+
+  it("returns verifier-rejected when illegitimate test modifications detected", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      testModifications: {
+        detected: true,
+        files: ["test/foo.test.ts"],
+        legitimate: false,
+        reasoning: "Assertions loosened to hide failures",
+      },
+    });
+
+    const result = categorizeVerdict(verdict, true);
+    expect(result.success).toBe(false);
+    expect(result.failureCategory).toBe("verifier-rejected");
+    expect(result.reviewReason).toContain("illegitimate test modifications");
+    expect(result.reviewReason).toContain("test/foo.test.ts");
+  });
+
+  it("returns tests-failing when tests are not all passing", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      tests: { allPassing: false, passCount: 8, failCount: 3 },
+      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
+    });
+
+    const result = categorizeVerdict(verdict, false);
+    expect(result.success).toBe(false);
+    expect(result.failureCategory).toBe("tests-failing");
+    expect(result.reviewReason).toContain("3 failure(s)");
+  });
+
+  it("returns verifier-rejected when acceptance criteria not met", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      tests: { allPassing: true, passCount: 10, failCount: 0 },
+      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
+      acceptanceCriteria: {
+        allMet: false,
+        criteria: [
+          { criterion: "Feature works", met: true },
+          { criterion: "Error handling", met: false },
+        ],
+      },
+    });
+
+    const result = categorizeVerdict(verdict, true);
+    expect(result.success).toBe(false);
+    expect(result.failureCategory).toBe("verifier-rejected");
+    expect(result.reviewReason).toContain("Acceptance criteria not met");
+    expect(result.reviewReason).toContain("Error handling");
+  });
+
+  it("returns verifier-rejected when quality rating is poor", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      tests: { allPassing: true, passCount: 10, failCount: 0 },
+      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
+      acceptanceCriteria: {
+        allMet: true,
+        criteria: [{ criterion: "Feature works", met: true }],
+      },
+      quality: { rating: "poor", issues: ["Security vulnerability", "Memory leak"] },
+    });
+
+    const result = categorizeVerdict(verdict, true);
+    expect(result.success).toBe(false);
+    expect(result.failureCategory).toBe("verifier-rejected");
+    expect(result.reviewReason).toContain("Poor code quality");
+    expect(result.reviewReason).toContain("Security vulnerability");
+  });
+
+  it("returns verifier-rejected for catch-all (approved=false, no matching reason)", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      tests: { allPassing: true, passCount: 10, failCount: 0 },
+      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
+      acceptanceCriteria: { allMet: true, criteria: [] },
+      quality: { rating: "acceptable", issues: [] },
+      reasoning: "Something else went wrong",
+    });
+
+    const result = categorizeVerdict(verdict, true);
+    expect(result.success).toBe(false);
+    expect(result.failureCategory).toBe("verifier-rejected");
+    expect(result.reviewReason).toContain("Something else went wrong");
+  });
+
+  it("legitimate test modifications do not trigger verifier-rejected", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      tests: { allPassing: false, passCount: 5, failCount: 2 },
+      testModifications: {
+        detected: true,
+        files: ["test/bar.test.ts"],
+        legitimate: true,
+        reasoning: "Tests updated to fix incorrect expected values",
+      },
+      acceptanceCriteria: { allMet: true, criteria: [] },
+      quality: { rating: "good", issues: [] },
+    });
+
+    // Should fall through to tests-failing (not illegitimate mod path)
+    const result = categorizeVerdict(verdict, false);
+    expect(result.failureCategory).toBe("tests-failing");
+  });
+
+  it("not-detected test modifications do not trigger verifier-rejected for test mods", () => {
+    const verdict = makeVerdict({
+      approved: false,
+      tests: { allPassing: false, passCount: 3, failCount: 4 },
+      testModifications: {
+        detected: false,
+        files: [],
+        legitimate: true,
+        reasoning: "",
+      },
+    });
+
+    const result = categorizeVerdict(verdict, false);
+    expect(result.failureCategory).toBe("tests-failing");
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// categorizeVerdict — null verdict (fallback)
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("categorizeVerdict — null verdict (fallback)", () => {
+  it("returns success when null verdict + testsPass=true", () => {
+    const result = categorizeVerdict(null, true);
+    expect(result.success).toBe(true);
+    expect(result.failureCategory).toBeUndefined();
+  });
+
+  it("returns tests-failing when null verdict + testsPass=false", () => {
+    const result = categorizeVerdict(null, false);
+    expect(result.success).toBe(false);
+    expect(result.failureCategory).toBe("tests-failing");
+    expect(result.reviewReason).toContain("no verdict file");
+  });
+});