@nathapp/nax 0.28.0 → 0.30.0

package/test/unit/execution/structured-failure.test.ts

@@ -1,415 +0,0 @@
-// RE-ARCH: keep
-/**
- * Unit tests for StructuredFailure and priorFailures tracking
- *
- * Tests the structured failure context for escalated tiers to know exactly what failed.
- */
-
-import { describe, expect, test } from "bun:test";
-import { loadPRD } from "../../../src/prd";
-import type { StructuredFailure, TestFailureContext, UserStory } from "../../../src/prd";
-
-describe("StructuredFailure Type", () => {
-  test("should have all required fields", () => {
-    const failure: StructuredFailure = {
-      attempt: 1,
-      modelTier: "balanced",
-      stage: "verify",
-      summary: "Test failed",
-      timestamp: new Date().toISOString(),
-    };
-
-    expect(failure.attempt).toBe(1);
-    expect(failure.modelTier).toBe("balanced");
-    expect(failure.stage).toBe("verify");
-    expect(failure.summary).toBe("Test failed");
-    expect(failure.timestamp).toBeDefined();
-    expect(typeof failure.timestamp).toBe("string");
-  });
-
-  test("should have optional testFailures field", () => {
-    const testFailure: TestFailureContext = {
-      file: "test/foo.test.ts",
-      testName: "should pass",
-      error: "Expected 1 to equal 2",
-      stackTrace: ["at foo.ts:10:15", "at Object.test (foo.ts:8:3)"],
-    };
-
-    const failure: StructuredFailure = {
-      attempt: 1,
-      modelTier: "balanced",
-      stage: "verify",
-      summary: "Test failed",
-      testFailures: [testFailure],
-      timestamp: new Date().toISOString(),
-    };
-
-    expect(failure.testFailures).toBeDefined();
-    expect(failure.testFailures?.length).toBe(1);
-    expect(failure.testFailures?.[0].file).toBe("test/foo.test.ts");
-    expect(failure.testFailures?.[0].testName).toBe("should pass");
-    expect(failure.testFailures?.[0].error).toBe("Expected 1 to equal 2");
-    expect(failure.testFailures?.[0].stackTrace.length).toBe(2);
-  });
-
-  test("should support all verification stages", () => {
-    const stages: Array<StructuredFailure["stage"]> = [
-      "verify",
-      "review",
-      "regression",
-      "rectification",
-      "agent-session",
-      "escalation",
-    ];
-
-    for (const stage of stages) {
-      const failure: StructuredFailure = {
-        attempt: 1,
-        modelTier: "balanced",
-        stage,
-        summary: "Test failed",
-        timestamp: new Date().toISOString(),
-      };
-      expect(failure.stage).toBe(stage);
-    }
-  });
-
-  test("should allow different model tiers", () => {
-    const tiers = ["fast", "balanced", "powerful"];
-
-    for (const tier of tiers) {
-      const failure: StructuredFailure = {
-        attempt: 1,
-        modelTier: tier,
-        stage: "verify",
-        summary: "Test failed",
-        timestamp: new Date().toISOString(),
-      };
-      expect(failure.modelTier).toBe(tier);
-    }
-  });
-
-  test("should track multiple test failures", () => {
-    const testFailures: TestFailureContext[] = [
-      {
-        file: "test/foo.test.ts",
-        testName: "test 1",
-        error: "Error 1",
-        stackTrace: ["at foo.ts:10"],
-      },
-      {
-        file: "test/bar.test.ts",
-        testName: "test 2",
-        error: "Error 2",
-        stackTrace: ["at bar.ts:20"],
-      },
-      {
-        file: "test/baz.test.ts",
-        testName: "test 3",
-        error: "Error 3",
-        stackTrace: ["at baz.ts:30"],
-      },
-    ];
-
-    const failure: StructuredFailure = {
-      attempt: 2,
-      modelTier: "balanced",
-      stage: "regression",
-      summary: "Multiple test failures",
-      testFailures,
-      timestamp: new Date().toISOString(),
-    };
-
-    expect(failure.testFailures?.length).toBe(3);
-    expect(failure.testFailures?.[0].file).toBe("test/foo.test.ts");
-    expect(failure.testFailures?.[1].file).toBe("test/bar.test.ts");
-    expect(failure.testFailures?.[2].file).toBe("test/baz.test.ts");
-  });
-});
-
-describe("TestFailureContext Type", () => {
-  test("should have all required fields", () => {
-    const context: TestFailureContext = {
-      file: "test/example.test.ts",
-      testName: "should do something",
-      error: "AssertionError: expected true to be false",
-      stackTrace: ["at Object.test (example.test.ts:42:10)", "at async runTest (test.ts:100:5)"],
-    };
-
-    expect(context.file).toBe("test/example.test.ts");
-    expect(context.testName).toBe("should do something");
-    expect(context.error).toBe("AssertionError: expected true to be false");
-    expect(context.stackTrace.length).toBe(2);
-  });
-
-  test("should handle nested test names", () => {
-    const context: TestFailureContext = {
-      file: "test/example.test.ts",
-      testName: "describe block > nested block > test name",
-      error: "Error",
-      stackTrace: [],
-    };
-
-    expect(context.testName).toContain("describe block");
-    expect(context.testName).toContain("nested block");
-    expect(context.testName).toContain("test name");
-  });
-
-  test("should support empty stack traces", () => {
-    const context: TestFailureContext = {
-      file: "test/example.test.ts",
-      testName: "test",
-      error: "Error",
-      stackTrace: [],
-    };
-
-    expect(context.stackTrace.length).toBe(0);
-  });
-
-  test("should support multiple stack trace lines", () => {
-    const context: TestFailureContext = {
-      file: "test/example.test.ts",
-      testName: "test",
-      error: "Error",
-      stackTrace: [
-        "at foo.ts:10:15",
-        "at bar.ts:20:10",
-        "at baz.ts:30:5",
-        "at Object.test (example.ts:40:3)",
-        "at async runTest (test.ts:50:5)",
-      ],
-    };
-
-    expect(context.stackTrace.length).toBe(5);
-  });
-});
-
-describe("UserStory priorFailures Field", () => {
-  test("should have optional priorFailures field", () => {
-    const story: UserStory = {
-      id: "US-001",
-      title: "Test Story",
-      description: "A test story",
-      acceptanceCriteria: [],
-      tags: [],
-      dependencies: [],
-      status: "pending",
-      passes: false,
-      escalations: [],
-      attempts: 0,
-    };
-
-    expect(story.priorFailures).toBeUndefined();
-  });
-
-  test("should initialize priorFailures to empty array in loadPRD", async () => {
-    // Create a temporary PRD file without priorFailures
-    const prdContent = JSON.stringify({
-      project: "test",
-      feature: "test-feature",
-      branchName: "test-branch",
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      userStories: [
-        {
-          id: "US-001",
-          title: "Test Story",
-          description: "Description",
-          acceptanceCriteria: [],
-          tags: [],
-          dependencies: [],
-          status: "pending",
-          passes: false,
-          escalations: [],
-          attempts: 0,
-        },
-      ],
-    });
-
-    // Write to temp file
-    const tmpFile = "/tmp/test-prd-priorFailures.json";
-    await Bun.write(tmpFile, prdContent);
-
-    // Load and verify
-    const prd = await loadPRD(tmpFile);
-    expect(prd.userStories[0].priorFailures).toBeDefined();
-    expect(Array.isArray(prd.userStories[0].priorFailures)).toBe(true);
-    expect(prd.userStories[0].priorFailures?.length).toBe(0);
-
-    // Cleanup
-    await Bun.file(tmpFile).delete();
-  });
-
-  test("should preserve existing priorFailures when loading PRD", async () => {
-    const existingFailure: StructuredFailure = {
-      attempt: 1,
-      modelTier: "balanced",
-      stage: "verify",
-      summary: "Test failed",
-      timestamp: new Date().toISOString(),
-    };
-
-    const prdContent = JSON.stringify({
-      project: "test",
-      feature: "test-feature",
-      branchName: "test-branch",
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      userStories: [
-        {
-          id: "US-001",
-          title: "Test Story",
-          description: "Description",
-          acceptanceCriteria: [],
-          tags: [],
-          dependencies: [],
-          status: "pending",
-          passes: false,
-          escalations: [],
-          attempts: 1,
-          priorFailures: [existingFailure],
-        },
-      ],
-    });
-
-    const tmpFile = "/tmp/test-prd-existing-failures.json";
-    await Bun.write(tmpFile, prdContent);
-
-    const prd = await loadPRD(tmpFile);
-    expect(prd.userStories[0].priorFailures?.length).toBe(1);
-    expect(prd.userStories[0].priorFailures?.[0].attempt).toBe(1);
-    expect(prd.userStories[0].priorFailures?.[0].stage).toBe("verify");
-
-    await Bun.file(tmpFile).delete();
-  });
-
-  test("should allow adding multiple priorFailures to a story", () => {
-    const story: UserStory = {
-      id: "US-001",
-      title: "Test Story",
-      description: "Description",
-      acceptanceCriteria: [],
-      tags: [],
-      dependencies: [],
-      status: "failed",
-      passes: false,
-      escalations: [],
-      attempts: 3,
-      priorFailures: [
-        {
-          attempt: 1,
-          modelTier: "fast",
-          stage: "verify",
-          summary: "First failure",
-          timestamp: new Date().toISOString(),
-        },
-        {
-          attempt: 2,
-          modelTier: "balanced",
-          stage: "regression",
-          summary: "Second failure",
-          timestamp: new Date().toISOString(),
-        },
-      ],
-    };
-
-    expect(story.priorFailures?.length).toBe(2);
-    expect(story.priorFailures?.[0].modelTier).toBe("fast");
-    expect(story.priorFailures?.[1].modelTier).toBe("balanced");
-  });
-});
-
-describe("StructuredFailure Attempt Tracking", () => {
-  test("should increment attempt number correctly", () => {
-    const failures: StructuredFailure[] = [];
-
-    for (let i = 1; i <= 3; i++) {
-      failures.push({
-        attempt: i,
-        modelTier: "balanced",
-        stage: "verify",
-        summary: `Attempt ${i} failed`,
-        timestamp: new Date().toISOString(),
-      });
-    }
-
-    expect(failures[0].attempt).toBe(1);
-    expect(failures[1].attempt).toBe(2);
-    expect(failures[2].attempt).toBe(3);
-  });
-
-  test("should track tier escalation in priorFailures", () => {
-    const failures: StructuredFailure[] = [
-      {
-        attempt: 1,
-        modelTier: "fast",
-        stage: "verify",
-        summary: "Failed on fast tier",
-        timestamp: new Date().toISOString(),
-      },
-      {
-        attempt: 2,
-        modelTier: "balanced",
-        stage: "escalation",
-        summary: "Escalated to balanced tier",
-        timestamp: new Date().toISOString(),
-      },
-      {
-        attempt: 3,
-        modelTier: "powerful",
-        stage: "escalation",
-        summary: "Escalated to powerful tier",
-        timestamp: new Date().toISOString(),
-      },
-    ];
-
-    expect(failures.length).toBe(3);
-    expect(failures[0].modelTier).toBe("fast");
-    expect(failures[1].modelTier).toBe("balanced");
-    expect(failures[2].modelTier).toBe("powerful");
-
-    // Verify escalation stages
-    expect(failures[1].stage).toBe("escalation");
-    expect(failures[2].stage).toBe("escalation");
-  });
-});
-
-describe("StructuredFailure Timestamps", () => {
-  test("should use ISO format timestamps", () => {
-    const failure: StructuredFailure = {
-      attempt: 1,
-      modelTier: "balanced",
-      stage: "verify",
-      summary: "Test failed",
-      timestamp: new Date().toISOString(),
-    };
-
-    // ISO format: YYYY-MM-DDTHH:mm:ss.sssZ
-    expect(failure.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
-  });
-
-  test("should have different timestamps for different failures", async () => {
-    const failure1: StructuredFailure = {
-      attempt: 1,
-      modelTier: "balanced",
-      stage: "verify",
-      summary: "First failure",
-      timestamp: new Date().toISOString(),
-    };
-
-    // Small delay to ensure different timestamp
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    const failure2: StructuredFailure = {
-      attempt: 2,
-      modelTier: "balanced",
-      stage: "verify",
-      summary: "Second failure",
-      timestamp: new Date().toISOString(),
-    };
-
-    // While millisecond precision should make them different, we just verify they're valid
-    expect(failure1.timestamp).toBeDefined();
-    expect(failure2.timestamp).toBeDefined();
-  });
-});

package/test/unit/execution-logging-stderr.test.ts

@@ -1,157 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for exitCode and stderr in agent error scenarios
- *
- * Covers: AgentResult includes exitCode and stderr for debugging failures
- */
-
-import { describe, expect, it } from "bun:test";
-import type { AgentResult } from "../../src/agents/types";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test fixtures
-// ─────────────────────────────────────────────────────────────────────────────
-
-function createFailedResult(overrides: Partial<AgentResult> = {}): AgentResult {
-  return {
-    success: false,
-    exitCode: 1,
-    output: "",
-    stderr: "",
-    rateLimited: false,
-    durationMs: 1000,
-    estimatedCost: 0.01,
-    ...overrides,
-  };
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Tests for AgentResult failure logging
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("AgentResult failure logging fields", () => {
-  it("includes exitCode for diagnosing failures", () => {
-    const result = createFailedResult({
-      exitCode: 1,
-      stderr: "Error message",
-    });
-
-    expect(result.exitCode).toBe(1);
-    expect(result.success).toBe(false);
-  });
-
-  it("captures stderr for root cause analysis", () => {
-    const result = createFailedResult({
-      exitCode: 401,
-      stderr: "401 Unauthorized: Invalid API key",
-    });
-
-    expect(result.exitCode).toBe(401);
-    expect(result.stderr).toContain("Unauthorized");
-  });
-
-  it("logs timeout with exit code 124", () => {
-    const result = createFailedResult({
-      exitCode: 124,
-      stderr: "SIGTERM: Process timeout",
-    });
-
-    expect(result.exitCode).toBe(124);
-    expect(result.stderr).toContain("timeout");
-  });
-
-  it("handles rate limit failures with exit code and stderr", () => {
-    const result = createFailedResult({
-      exitCode: 429,
-      stderr: "Rate limit exceeded",
-      rateLimited: true,
-    });
-
-    expect(result.exitCode).toBe(429);
-    expect(result.stderr).toContain("Rate limit");
-    expect(result.rateLimited).toBe(true);
-  });
-
-  it("logs server errors with 500 exit code", () => {
-    const result = createFailedResult({
-      exitCode: 500,
-      stderr: "Internal server error: database connection failed",
-    });
-
-    expect(result.exitCode).toBe(500);
-    expect(result.stderr).toContain("database");
-  });
-
-  it("supports backward compatibility when stderr is undefined", () => {
-    const result: AgentResult = {
-      success: false,
-      exitCode: 1,
-      output: "output",
-      // stderr intentionally undefined for backward compat
-      rateLimited: false,
-      durationMs: 1000,
-      estimatedCost: 0.01,
-    };
-
-    expect(result.exitCode).toBe(1);
-    expect(result.stderr).toBeUndefined();
-  });
-
-  it("can serialize failure data to JSON for logging", () => {
-    const result = createFailedResult({
-      exitCode: 401,
-      stderr: "Authentication failed",
-    });
-
-    const logData = {
-      exitCode: result.exitCode,
-      stderr: result.stderr || "",
-      rateLimited: result.rateLimited,
-      storyId: "story-001",
-    };
-
-    const json = JSON.stringify(logData);
-    expect(json).toContain("401");
-    expect(json).toContain("Authentication");
-
-    const parsed = JSON.parse(json);
-    expect(parsed.exitCode).toBe(401);
-    expect(parsed.stderr).toBe("Authentication failed");
-  });
-
-  it("preserves special characters in stderr for JSONL format", () => {
-    const specialStderr = 'Error: "quoted" with\nnewline and \\backslash';
-    const result = createFailedResult({
-      stderr: specialStderr,
-    });
-
-    const logData = JSON.stringify({ stderr: result.stderr });
-    const parsed = JSON.parse(logData);
-    expect(parsed.stderr).toBe(specialStderr);
-  });
-
-  it("includes all critical fields for comprehensive failure logging", () => {
-    const result = createFailedResult({
-      success: false,
-      exitCode: 500,
-      output: "Last 5000 chars of stdout",
-      stderr: "Last 1000 chars of stderr",
-      rateLimited: false,
-      durationMs: 5000,
-      estimatedCost: 0.05,
-      pid: 12345,
-    });
-
-    // All fields should be available for logging
-    const logData = {
-      exitCode: result.exitCode,
-      stderr: result.stderr || "",
-      rateLimited: result.rateLimited,
-      storyId: "test",
-    };
-
-    expect(logData.exitCode).toBe(500);
-    expect(logData.stderr).toContain("stderr");
-    expect(logData.rateLimited).toBe(false);
-  });
-});

package/test/unit/execution-stage.test.ts

@@ -1,123 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for src/pipeline/stages/execution.ts
- *
- * Covers: routeTddFailure, execution stage critical paths
- */
-
-import { describe, expect, it } from "bun:test";
-import { routeTddFailure } from "../../src/pipeline/stages/execution";
-import type { FailureCategory } from "../../src/tdd";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test fixtures
-// ─────────────────────────────────────────────────────────────────────────────
-
-interface MockContext {
-  retryAsLite?: boolean;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// routeTddFailure
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("routeTddFailure", () => {
-  it("escalates on isolation-violation in strict mode", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure("isolation-violation", false, ctx);
-
-    expect(result.action).toBe("escalate");
-    expect(ctx.retryAsLite).toBe(true);
-  });
-
-  it("escalates on isolation-violation in lite mode without setting retryAsLite", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure("isolation-violation", true, ctx);
-
-    expect(result.action).toBe("escalate");
-    expect(ctx.retryAsLite).toBeUndefined();
-  });
-
-  it("escalates on session-failure", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure("session-failure", false, ctx);
-
-    expect(result.action).toBe("escalate");
-    expect(ctx.retryAsLite).toBeUndefined();
-  });
-
-  it("escalates on tests-failing", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure("tests-failing", false, ctx);
-
-    expect(result.action).toBe("escalate");
-    expect(ctx.retryAsLite).toBeUndefined();
-  });
-
-  it("escalates on verifier-rejected", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure("verifier-rejected", false, ctx);
-
-    expect(result.action).toBe("escalate");
-    expect(ctx.retryAsLite).toBeUndefined();
-  });
-
-  it("pauses on undefined failureCategory", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure(undefined, false, ctx, "Unknown failure");
-
-    expect(result.action).toBe("pause");
-    expect(result.reason).toBe("Unknown failure");
-    expect(ctx.retryAsLite).toBeUndefined();
-  });
-
-  it("pauses on unknown failureCategory", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure("unknown" as FailureCategory, false, ctx);
-
-    expect(result.action).toBe("pause");
-    expect(result.reason).toBe("Three-session TDD requires review");
-    expect(ctx.retryAsLite).toBeUndefined();
-  });
-
-  it("uses custom reviewReason when pausing", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure(undefined, false, ctx, "Custom reason for pause");
-
-    expect(result.action).toBe("pause");
-    expect(result.reason).toBe("Custom reason for pause");
-  });
-
-  it("defaults to generic pause message when no reviewReason provided", () => {
-    const ctx: MockContext = {};
-    const result = routeTddFailure(undefined, false, ctx);
-
-    expect(result.action).toBe("pause");
-    expect(result.reason).toBe("Three-session TDD requires review");
-  });
-
-  it("handles all known failure categories correctly", () => {
-    const categories: FailureCategory[] = [
-      "isolation-violation",
-      "session-failure",
-      "tests-failing",
-      "verifier-rejected",
-    ];
-
-    for (const category of categories) {
-      const ctx: MockContext = {};
-      const result = routeTddFailure(category, false, ctx);
-      expect(result.action).toBe("escalate");
-    }
-  });
-
-  it("only sets retryAsLite for isolation-violation in strict mode", () => {
-    const categories: FailureCategory[] = ["session-failure", "tests-failing", "verifier-rejected"];
-
-    for (const category of categories) {
-      const ctx: MockContext = {};
-      routeTddFailure(category, false, ctx);
-      expect(ctx.retryAsLite).toBeUndefined();
-    }
-  });
-});