@nathapp/nax 0.21.0 → 0.22.1

package/test/unit/context/context-story.test.ts

@@ -0,0 +1,108 @@
+// RE-ARCH: keep
+/**
+ * Tests for context builder module
+ */
+
+// RE-ARCH: keep
+/**
+ * Tests for context builder module
+ */
+
+import { describe, expect, test } from "bun:test";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  buildContext,
+  createDependencyContext,
+  createErrorContext,
+  createFileContext,
+  createProgressContext,
+  createStoryContext,
+  estimateTokens,
+  formatContextAsMarkdown,
+  sortContextElements,
+} from "../../../src/context/builder";
+import type { ContextBudget, ContextElement, StoryContext } from "../../../src/context/types";
+import type { PRD, UserStory } from "../../../src/prd";
+
+// Helper to create test PRD
+const createTestPRD = (stories: Partial<UserStory>[]): PRD => ({
+  project: "test-project",
+  feature: "test-feature",
+  branchName: "test-branch",
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+  userStories: stories.map((s, i) => ({
+    id: s.id || `US-${String(i + 1).padStart(3, "0")}`,
+    title: s.title || "Test Story",
+    description: s.description || "Test description",
+    acceptanceCriteria: s.acceptanceCriteria || ["AC1"],
+    dependencies: s.dependencies || [],
+    tags: s.tags || [],
+    status: s.status || "pending",
+    passes: s.passes ?? false,
+    escalations: s.escalations || [],
+    attempts: s.attempts || 0,
+    routing: s.routing,
+    priorErrors: s.priorErrors,
+    relevantFiles: s.relevantFiles,
+    contextFiles: s.contextFiles,
+    expectedFiles: s.expectedFiles,
+  })),
+});
+
+describe("Context Builder", () => {
+  describe("createStoryContext", () => {
+    test("should create story context element", () => {
+      const story: UserStory = {
+        id: "US-001",
+        title: "Test Story",
+        description: "Test description",
+        acceptanceCriteria: ["AC1", "AC2"],
+        dependencies: [],
+        tags: ["feature"],
+        status: "pending",
+        passes: false,
+        escalations: [],
+        attempts: 0,
+      };
+
+      const element = createStoryContext(story, 80);
+
+      expect(element.type).toBe("story");
+      expect(element.storyId).toBe("US-001");
+      expect(element.priority).toBe(80);
+      expect(element.content).toContain("US-001: Test Story");
+      expect(element.content).toContain("Test description");
+      expect(element.content).toContain("AC1");
+      expect(element.content).toContain("AC2");
+      expect(element.tokens).toBeGreaterThan(0);
+    });
+  });
+
+  describe("createDependencyContext", () => {
+    test("should create dependency context element", () => {
+      const story: UserStory = {
+        id: "US-002",
+        title: "Dependency Story",
+        description: "Dependency description",
+        acceptanceCriteria: ["AC1"],
+        dependencies: [],
+        tags: [],
+        status: "passed",
+        passes: true,
+        escalations: [],
+        attempts: 0,
+      };
+
+      const element = createDependencyContext(story, 50);
+
+      expect(element.type).toBe("dependency");
+      expect(element.storyId).toBe("US-002");
+      expect(element.priority).toBe(50);
+      expect(element.content).toContain("US-002: Dependency Story");
+      expect(element.tokens).toBeGreaterThan(0);
+    });
+  });
+});

package/test/{context → unit/context}/prior-failures.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Unit tests for priorFailures context formatting
  *
@@ -5,10 +6,10 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { createPriorFailuresContext, formatPriorFailures } from "../../src/context/elements";
-import { buildContext, sortContextElements } from "../../src/context/builder";
-import type { StructuredFailure, UserStory } from "../../src/prd";
-import type { StoryContext } from "../../src/context/types";
+import { createPriorFailuresContext, formatPriorFailures } from "../../../src/context/elements";
+import { buildContext, sortContextElements } from "../../../src/context/builder";
+import type { StructuredFailure, UserStory } from "../../../src/prd";
+import type { StoryContext } from "../../../src/context/types";
 
 describe("formatPriorFailures", () => {
   test("should format a single prior failure correctly", () => {

package/test/unit/context.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for context builder module
  */

package/test/unit/crash-recovery.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Unit tests for crash recovery module (US-007)
  */

package/test/unit/escalation.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/execution/escalation.ts
  *

package/test/unit/execution/lifecycle/run-completion.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * run-completion.ts — Deferred regression gate invocation (US-003)
  *

package/test/unit/execution/lifecycle/run-regression.test.ts

@@ -1,3 +1,5 @@
+// RE-ARCH: delete-with-source
+
 /**
  * Smart Runner Reverse Mapping Tests + Deferred Regression Gate Tests
  *

package/test/{execution → unit/execution}/pid-registry.test.ts

@@ -1,10 +1,11 @@
+// RE-ARCH: keep
 /**
  * PID Registry Tests
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { PidRegistry } from "../../src/execution/pid-registry";
+import { PidRegistry } from "../../../src/execution/pid-registry";
 
 const TEST_WORKDIR = "/tmp/nax-pid-registry-test";
 const PID_FILE = `${TEST_WORKDIR}/.nax-pids`;

package/test/{execution → unit/execution}/structured-failure.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Unit tests for StructuredFailure and priorFailures tracking
  *
@@ -5,8 +6,8 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { loadPRD } from "../../src/prd";
-import type { StructuredFailure, TestFailureContext, UserStory } from "../../src/prd";
+import { loadPRD } from "../../../src/prd";
+import type { StructuredFailure, TestFailureContext, UserStory } from "../../../src/prd";
 
 describe("StructuredFailure Type", () => {
   test("should have all required fields", () => {

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

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for exitCode and stderr in agent error scenarios
  *

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

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/pipeline/stages/execution.ts
  *

package/test/unit/fix-generator.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Fix Generator Tests
  */

package/test/unit/greenfield.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/context/greenfield.ts
  *

package/test/unit/interaction/human-review-trigger.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Unit Tests: human-review trigger (BUG-025)
  *

package/test/unit/interaction-network-failures.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Interaction Plugins Network Failure Tests (v0.15.1)
  *

package/test/unit/interaction-plugins.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Interaction Plugins Unit Tests (v0.15.0 Phase 2)
  *

package/test/unit/logging/formatter.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for human-friendly logging formatter
  */

package/test/unit/merge.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/worktree/merge.ts
  *

package/test/unit/pipeline/event-bus.test.ts

@@ -0,0 +1,105 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { PipelineEventBus } from "../../../src/pipeline/event-bus";
+import type { PipelineEvent } from "../../../src/pipeline/event-bus";
+
+function makeStoryCompletedEvent(): PipelineEvent {
+  return {
+    type: "story:completed",
+    storyId: "US-001",
+    story: { id: "US-001", title: "Test story", status: "passed", acceptanceCriteria: [] } as any,
+    passed: true,
+    durationMs: 1000,
+  };
+}
+
+describe("PipelineEventBus", () => {
+  test("subscribes and receives event", () => {
+    const bus = new PipelineEventBus();
+    const received: PipelineEvent[] = [];
+    bus.on("story:completed", (e) => received.push(e));
+
+    const evt = makeStoryCompletedEvent();
+    bus.emit(evt);
+
+    expect(received).toHaveLength(1);
+    expect(received[0]).toBe(evt);
+  });
+
+  test("onAll receives all event types", () => {
+    const bus = new PipelineEventBus();
+    const received: string[] = [];
+    bus.onAll((e) => received.push(e.type));
+
+    bus.emit(makeStoryCompletedEvent());
+    bus.emit({ type: "run:completed", totalStories: 1, passedStories: 1, failedStories: 0, durationMs: 5000 });
+
+    expect(received).toEqual(["story:completed", "run:completed"]);
+  });
+
+  test("unsubscribe stops receiving events", () => {
+    const bus = new PipelineEventBus();
+    const received: PipelineEvent[] = [];
+    const unsub = bus.on("story:completed", (e) => received.push(e));
+
+    bus.emit(makeStoryCompletedEvent());
+    unsub();
+    bus.emit(makeStoryCompletedEvent());
+
+    expect(received).toHaveLength(1);
+  });
+
+  test("subscriber error does not prevent other subscribers from running", () => {
+    const bus = new PipelineEventBus();
+    const results: string[] = [];
+
+    bus.on("story:completed", () => { throw new Error("boom"); });
+    bus.on("story:completed", () => results.push("second"));
+
+    bus.emit(makeStoryCompletedEvent());
+
+    expect(results).toEqual(["second"]);
+  });
+
+  test("subscriberCount returns correct count", () => {
+    const bus = new PipelineEventBus();
+    expect(bus.subscriberCount("story:completed")).toBe(0);
+
+    bus.on("story:completed", () => {});
+    bus.on("story:completed", () => {});
+    expect(bus.subscriberCount("story:completed")).toBe(2);
+  });
+
+  test("clear removes all subscribers", () => {
+    const bus = new PipelineEventBus();
+    const received: PipelineEvent[] = [];
+    bus.on("story:completed", (e) => received.push(e));
+    bus.clear();
+    bus.emit(makeStoryCompletedEvent());
+
+    expect(received).toHaveLength(0);
+  });
+
+  test("emitAsync awaits all async subscribers", async () => {
+    const bus = new PipelineEventBus();
+    let resolved = false;
+
+    bus.on("story:completed", async () => {
+      await new Promise((r) => setTimeout(r, 10));
+      resolved = true;
+    });
+
+    await bus.emitAsync(makeStoryCompletedEvent());
+    expect(resolved).toBe(true);
+  });
+
+  test("does not deliver typed events to wrong subscriber", () => {
+    const bus = new PipelineEventBus();
+    const received: PipelineEvent[] = [];
+
+    bus.on("run:completed", (e) => received.push(e));
+    bus.emit(makeStoryCompletedEvent());
+
+    expect(received).toHaveLength(0);
+  });
+});

package/test/unit/pipeline/routing-partial-override.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for partial routing override in routing stage (FIX-001)
  *

package/test/unit/pipeline/runner-retry.test.ts

@@ -0,0 +1,89 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { MAX_STAGE_RETRIES, runPipeline } from "../../../src/pipeline/runner";
+import type { PipelineContext, PipelineStage } from "../../../src/pipeline/types";
+import { DEFAULT_CONFIG } from "../../../src/config";
+
+function makeCtx(): PipelineContext {
+  return {
+    config: DEFAULT_CONFIG,
+    prd: { stories: [], acceptanceOverrides: {} } as any,
+    story: { id: "US-001", title: "t", status: "pending", acceptanceCriteria: [] } as any,
+    stories: [],
+    routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
+    workdir: "/tmp",
+    hooks: {},
+  };
+}
+
+function stage(name: string, action: () => import("../../../src/pipeline/types").StageResult | Promise<import("../../../src/pipeline/types").StageResult>): PipelineStage {
+  return { name, enabled: () => true, execute: async () => action() };
+}
+
+describe("runPipeline retry action", () => {
+  test("retry jumps back to named stage", async () => {
+    const order: string[] = [];
+    let attempt = 0;
+
+    const stages = [
+      stage("a", () => { order.push("a"); return { action: "continue" }; }),
+      stage("b", () => { order.push("b"); return { action: "continue" }; }),
+      stage("c", () => {
+        order.push("c");
+        attempt++;
+        if (attempt < 2) return { action: "retry", fromStage: "b" };
+        return { action: "continue" };
+      }),
+      stage("d", () => { order.push("d"); return { action: "continue" }; }),
+    ];
+
+    const result = await runPipeline(stages, makeCtx());
+
+    expect(result.finalAction).toBe("complete");
+    expect(order).toEqual(["a", "b", "c", "b", "c", "d"]);
+  });
+
+  test("retry fails after MAX_STAGE_RETRIES exceeded", async () => {
+    let calls = 0;
+    const stages = [
+      stage("verify", () => { return { action: "continue" }; }),
+      stage("rectify", () => { calls++; return { action: "retry", fromStage: "verify" }; }),
+    ];
+
+    const result = await runPipeline(stages, makeCtx());
+
+    expect(result.finalAction).toBe("fail");
+    expect(calls).toBe(MAX_STAGE_RETRIES + 1);
+    expect(result.reason).toContain("exceeded max retries");
+  });
+
+  test("retry to unknown stage escalates", async () => {
+    const stages = [
+      stage("a", () => ({ action: "retry", fromStage: "nonexistent" })),
+    ];
+
+    const result = await runPipeline(stages, makeCtx());
+    expect(result.finalAction).toBe("escalate");
+    expect(result.reason).toContain("not found");
+  });
+
+  test("disabled stages are skipped during retry", async () => {
+    const order: string[] = [];
+    let attempt = 0;
+
+    const stages = [
+      stage("verify", () => { order.push("verify"); return { action: "continue" }; }),
+      { name: "disabled", enabled: () => false, execute: async () => { order.push("disabled"); return { action: "continue" as const }; } },
+      stage("rectify", () => {
+        order.push("rectify");
+        attempt++;
+        if (attempt < 2) return { action: "retry", fromStage: "verify" };
+        return { action: "continue" };
+      }),
+    ];
+
+    await runPipeline(stages, makeCtx());
+    expect(order).not.toContain("disabled");
+    expect(order).toEqual(["verify", "rectify", "verify", "rectify"]);
+  });
+});

package/test/unit/pipeline/stages/autofix.test.ts

@@ -0,0 +1,97 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { autofixStage, _autofixDeps } from "../../../../src/pipeline/stages/autofix";
+import type { PipelineContext } from "../../../../src/pipeline/types";
+import { DEFAULT_CONFIG } from "../../../../src/config";
+
+function makeReviewResult(success: boolean) {
+  return { success, checks: [], summary: "" } as any;
+}
+
+function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
+  return {
+    config: {
+      ...DEFAULT_CONFIG,
+      quality: {
+        ...DEFAULT_CONFIG.quality,
+        commands: {
+          ...DEFAULT_CONFIG.quality.commands,
+          lintFix: "biome check --fix",
+          formatFix: "biome format --write",
+        },
+        autofix: { enabled: true, maxAttempts: 2 },
+      },
+    } as any,
+    prd: { stories: [] } as any,
+    story: { id: "US-001", title: "t", status: "in-progress", acceptanceCriteria: [] } as any,
+    stories: [],
+    routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
+    workdir: "/tmp",
+    hooks: {},
+    ...overrides,
+  };
+}
+
+describe("autofixStage", () => {
+  test("disabled when reviewResult is undefined", () => {
+    expect(autofixStage.enabled(makeCtx())).toBe(false);
+  });
+
+  test("disabled when review passed", () => {
+    expect(autofixStage.enabled(makeCtx({ reviewResult: makeReviewResult(true) }))).toBe(false);
+  });
+
+  test("disabled when autofix.enabled = false", () => {
+    const ctx = makeCtx({
+      reviewResult: makeReviewResult(false),
+      config: {
+        ...DEFAULT_CONFIG,
+        quality: { ...DEFAULT_CONFIG.quality, autofix: { enabled: false } },
+      } as any,
+    });
+    expect(autofixStage.enabled(ctx)).toBe(false);
+  });
+
+  test("escalates when no fix commands configured", async () => {
+    const ctx = makeCtx({
+      reviewResult: makeReviewResult(false),
+      config: {
+        ...DEFAULT_CONFIG,
+        quality: {
+          ...DEFAULT_CONFIG.quality,
+          commands: { test: "bun test" },
+          autofix: { enabled: true },
+        },
+      } as any,
+    });
+    const result = await autofixStage.execute(ctx);
+    expect(result.action).toBe("escalate");
+  });
+
+  test("returns retry when recheck passes", async () => {
+    const saved = { ..._autofixDeps };
+    _autofixDeps.runCommand = async () => ({ exitCode: 0, output: "" });
+    _autofixDeps.recheckReview = async () => true;
+
+    const ctx = makeCtx({ reviewResult: makeReviewResult(false) });
+    const result = await autofixStage.execute(ctx);
+
+    Object.assign(_autofixDeps, saved);
+
+    expect(result.action).toBe("retry");
+    if (result.action === "retry") expect(result.fromStage).toBe("review");
+  });
+
+  test("escalates when recheck still fails after max attempts", async () => {
+    const saved = { ..._autofixDeps };
+    _autofixDeps.runCommand = async () => ({ exitCode: 1, output: "lint error" });
+    _autofixDeps.recheckReview = async () => false;
+
+    const ctx = makeCtx({ reviewResult: makeReviewResult(false) });
+    const result = await autofixStage.execute(ctx);
+
+    Object.assign(_autofixDeps, saved);
+
+    expect(result.action).toBe("escalate");
+  });
+});

package/test/unit/pipeline/stages/rectify.test.ts

@@ -0,0 +1,101 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { rectifyStage, _rectifyDeps } from "../../../../src/pipeline/stages/rectify";
+import type { PipelineContext } from "../../../../src/pipeline/types";
+import { DEFAULT_CONFIG } from "../../../../src/config";
+
+function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
+  return {
+    config: {
+      ...DEFAULT_CONFIG,
+      execution: {
+        ...DEFAULT_CONFIG.execution,
+        rectification: { enabled: true, maxRetries: 3, abortOnIncreasingFailures: true, maxFailureSummaryChars: 2000 },
+      },
+      quality: {
+        ...DEFAULT_CONFIG.quality,
+        commands: { ...DEFAULT_CONFIG.quality.commands, test: "bun test" },
+      },
+    },
+    prd: { stories: [] } as any,
+    story: { id: "US-001", title: "t", status: "in-progress", acceptanceCriteria: [] } as any,
+    stories: [],
+    routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
+    workdir: "/tmp",
+    hooks: {},
+    ...overrides,
+  };
+}
+
+function makeVerifyResult(success: boolean) {
+  return {
+    success,
+    status: success ? ("PASS" as const) : ("TEST_FAILURE" as const),
+    storyId: "US-001",
+    strategy: "scoped" as const,
+    passCount: success ? 10 : 8,
+    failCount: success ? 0 : 2,
+    totalCount: 10,
+    failures: [],
+    rawOutput: "(fail) foo > bar",
+    durationMs: 100,
+    countsTowardEscalation: !success,
+  };
+}
+
+describe("rectifyStage", () => {
+  test("disabled when verifyResult is undefined", () => {
+    expect(rectifyStage.enabled(makeCtx())).toBe(false);
+  });
+
+  test("disabled when verify passed", () => {
+    const ctx = makeCtx({ verifyResult: makeVerifyResult(true) });
+    expect(rectifyStage.enabled(ctx)).toBe(false);
+  });
+
+  test("disabled when rectification config disabled", () => {
+    const ctx = makeCtx({
+      verifyResult: makeVerifyResult(false),
+      config: {
+        ...DEFAULT_CONFIG,
+        execution: {
+          ...DEFAULT_CONFIG.execution,
+          rectification: { enabled: false, maxRetries: 3, abortOnIncreasingFailures: true, maxFailureSummaryChars: 2000 },
+        },
+      } as any,
+    });
+    expect(rectifyStage.enabled(ctx)).toBe(false);
+  });
+
+  test("enabled when verify failed and rectification enabled", () => {
+    const ctx = makeCtx({ verifyResult: makeVerifyResult(false) });
+    expect(rectifyStage.enabled(ctx)).toBe(true);
+  });
+
+  test("returns retry when rectification succeeds", async () => {
+    const saved = { ..._rectifyDeps };
+    _rectifyDeps.runRectificationLoop = async () => true;
+
+    const ctx = makeCtx({ verifyResult: makeVerifyResult(false) });
+    const result = await rectifyStage.execute(ctx);
+
+    Object.assign(_rectifyDeps, saved);
+
+    expect(result.action).toBe("retry");
+    if (result.action === "retry") expect(result.fromStage).toBe("verify");
+    // verifyResult should be cleared so verify re-runs fresh
+    expect(ctx.verifyResult).toBeUndefined();
+  });
+
+  test("returns escalate when rectification exhausted", async () => {
+    const saved = { ..._rectifyDeps };
+    _rectifyDeps.runRectificationLoop = async () => false;
+
+    const ctx = makeCtx({ verifyResult: makeVerifyResult(false) });
+    const result = await rectifyStage.execute(ctx);
+
+    Object.assign(_rectifyDeps, saved);
+
+    expect(result.action).toBe("escalate");
+  });
+});