@nathapp/nax 0.23.0 → 0.25.0

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

@@ -0,0 +1,201 @@
+/**
+ * Unit tests for security-review trigger wiring in review stage (TC-003)
+ *
+ * Covers:
+ * - Plugin reviewer failure with no trigger → always fail
+ * - Plugin reviewer failure + trigger abort → fail
+ * - Plugin reviewer failure + trigger non-abort → escalate
+ * - Built-in check failure → escalate (unchanged)
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import type { NaxConfig } from "../../../../src/config";
+import { InteractionChain } from "../../../../src/interaction/chain";
+import type { InteractionPlugin, InteractionResponse } from "../../../../src/interaction/types";
+import { _reviewDeps, reviewStage } from "../../../../src/pipeline/stages/review";
+import type { PipelineContext } from "../../../../src/pipeline/types";
+import type { PRD, UserStory } from "../../../../src/prd";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+const originalCheckSecurityReview = _reviewDeps.checkSecurityReview;
+
+function makeChain(action: InteractionResponse["action"]): InteractionChain {
+  const chain = new InteractionChain({ defaultTimeout: 5000, defaultFallback: "abort" });
+  const plugin: InteractionPlugin = {
+    name: "test",
+    send: mock(async () => {}),
+    receive: mock(async (id: string): Promise<InteractionResponse> => ({
+      requestId: id,
+      action,
+      respondedBy: "user",
+      respondedAt: Date.now(),
+    })),
+  };
+  chain.register(plugin);
+  return chain;
+}
+
+function makeConfig(triggers: Record<string, unknown>): NaxConfig {
+  return {
+    review: { enabled: true },
+    interaction: {
+      plugin: "cli",
+      defaults: { timeout: 30000, fallback: "abort" as const },
+      triggers,
+    },
+  } as unknown as NaxConfig;
+}
+
+function makeStory(overrides?: Partial<UserStory>): UserStory {
+  return {
+    id: "US-001",
+    title: "Test Story",
+    description: "Test",
+    acceptanceCriteria: [],
+    tags: [],
+    dependencies: [],
+    status: "in-progress",
+    passes: false,
+    escalations: [],
+    attempts: 1,
+    ...overrides,
+  };
+}
+
+function makePRD(): PRD {
+  return {
+    project: "test",
+    feature: "my-feature",
+    branchName: "test-branch",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: [makeStory()],
+  };
+}
+
+function makeCtx(overrides: Partial<PipelineContext>): PipelineContext {
+  return {
+    config: makeConfig({}),
+    prd: makePRD(),
+    story: makeStory(),
+    stories: [makeStory()],
+    routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
+    workdir: "/tmp/test",
+    hooks: {} as PipelineContext["hooks"],
+    ...overrides,
+  } as unknown as PipelineContext;
+}
+
+afterEach(() => {
+  mock.restore();
+  _reviewDeps.checkSecurityReview = originalCheckSecurityReview;
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Plugin reviewer failure — no trigger configured (today behavior)
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("reviewStage — plugin failure, no trigger", () => {
+  test("returns fail when plugin reviewer fails and trigger not enabled", async () => {
+    const reviewResult = { success: false, pluginFailed: true, failureReason: "semgrep found issues", builtIn: { totalDurationMs: 0 } };
+    const orchestratorMock = mock(async () => reviewResult);
+    // biome-ignore lint/suspicious/noExplicitAny: test-only import override
+    const { reviewOrchestrator } = await import("../../../../src/review/orchestrator");
+    const original = reviewOrchestrator.review;
+    reviewOrchestrator.review = orchestratorMock as typeof reviewOrchestrator.review;
+
+    const ctx = makeCtx({ config: makeConfig({}) });
+    const result = await reviewStage.execute(ctx);
+
+    expect(result.action).toBe("fail");
+    reviewOrchestrator.review = original;
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Plugin reviewer failure — trigger wired via _reviewDeps
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("reviewStage — security-review trigger via _reviewDeps", () => {
+  test("returns fail when trigger responds abort (checkSecurityReview returns false)", async () => {
+    _reviewDeps.checkSecurityReview = mock(async () => false);
+
+    const reviewResult = { success: false, pluginFailed: true, failureReason: "semgrep critical", builtIn: { totalDurationMs: 0 } };
+    const { reviewOrchestrator } = await import("../../../../src/review/orchestrator");
+    const original = reviewOrchestrator.review;
+    reviewOrchestrator.review = mock(async () => reviewResult) as typeof reviewOrchestrator.review;
+
+    const chain = makeChain("abort");
+    const ctx = makeCtx({
+      config: makeConfig({ "security-review": { enabled: true } }),
+      interaction: chain,
+    });
+    const result = await reviewStage.execute(ctx);
+
+    expect(result.action).toBe("fail");
+    expect(_reviewDeps.checkSecurityReview).toHaveBeenCalledTimes(1);
+    reviewOrchestrator.review = original;
+  });
+
+  test("returns escalate when trigger responds non-abort (checkSecurityReview returns true)", async () => {
+    _reviewDeps.checkSecurityReview = mock(async () => true);
+
+    const reviewResult = { success: false, pluginFailed: true, failureReason: "semgrep warning", builtIn: { totalDurationMs: 0 } };
+    const { reviewOrchestrator } = await import("../../../../src/review/orchestrator");
+    const original = reviewOrchestrator.review;
+    reviewOrchestrator.review = mock(async () => reviewResult) as typeof reviewOrchestrator.review;
+
+    const chain = makeChain("approve");
+    const ctx = makeCtx({
+      config: makeConfig({ "security-review": { enabled: true } }),
+      interaction: chain,
+    });
+    const result = await reviewStage.execute(ctx);
+
+    expect(result.action).toBe("escalate");
+    expect(_reviewDeps.checkSecurityReview).toHaveBeenCalledTimes(1);
+    reviewOrchestrator.review = original;
+  });
+
+  test("does not call trigger when no interaction chain present", async () => {
+    _reviewDeps.checkSecurityReview = mock(async () => true);
+
+    const reviewResult = { success: false, pluginFailed: true, failureReason: "semgrep error", builtIn: { totalDurationMs: 0 } };
+    const { reviewOrchestrator } = await import("../../../../src/review/orchestrator");
+    const original = reviewOrchestrator.review;
+    reviewOrchestrator.review = mock(async () => reviewResult) as typeof reviewOrchestrator.review;
+
+    const ctx = makeCtx({
+      config: makeConfig({ "security-review": { enabled: true } }),
+      // no interaction
+    });
+    const result = await reviewStage.execute(ctx);
+
+    expect(result.action).toBe("fail");
+    expect(_reviewDeps.checkSecurityReview).not.toHaveBeenCalled();
+    reviewOrchestrator.review = original;
+  });
+
+  test("built-in check failure still returns escalate (unchanged behavior)", async () => {
+    _reviewDeps.checkSecurityReview = mock(async () => false);
+
+    const reviewResult = { success: false, pluginFailed: false, failureReason: "lint failed", builtIn: { totalDurationMs: 0 } };
+    const { reviewOrchestrator } = await import("../../../../src/review/orchestrator");
+    const original = reviewOrchestrator.review;
+    reviewOrchestrator.review = mock(async () => reviewResult) as typeof reviewOrchestrator.review;
+
+    const ctx = makeCtx({
+      config: makeConfig({ "security-review": { enabled: true } }),
+      interaction: makeChain("abort"),
+    });
+    const result = await reviewStage.execute(ctx);
+
+    expect(result.action).toBe("escalate");
+    // security-review trigger should NOT fire for built-in check failures
+    expect(_reviewDeps.checkSecurityReview).not.toHaveBeenCalled();
+    reviewOrchestrator.review = original;
+  });
+});

package/test/unit/pipeline/subscribers/events-writer.test.ts

@@ -0,0 +1,227 @@
+import { readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { PipelineEventBus } from "../../../../src/pipeline/event-bus";
+import { wireEventsWriter } from "../../../../src/pipeline/subscribers/events-writer";
+
+// Minimal UserStory stub for event payloads
+const stubStory = { id: "US-001", title: "Test story" } as never;
+
+describe("wireEventsWriter", () => {
+  let workdir: string;
+  let eventsFile: string;
+
+  beforeEach(() => {
+    // Use a temp workdir with a known basename so we can locate the events file
+    workdir = join(tmpdir(), `nax-evtest-${Date.now()}`);
+    const project = workdir.split("/").pop()!;
+    eventsFile = join(process.env.HOME ?? tmpdir(), ".nax", "events", project, "events.jsonl");
+  });
+
+  afterEach(async () => {
+    // Clean up the events file written under ~/.nax/events/<project>/
+    const project = workdir.split("/").pop()!;
+    const dir = join(process.env.HOME ?? tmpdir(), ".nax", "events", project);
+    await rm(dir, { recursive: true, force: true });
+    mock.restore();
+  });
+
+  async function readLines(): Promise<object[]> {
+    // Small delay to let async fire-and-forget writes finish
+    await Bun.sleep(50);
+    const text = await readFile(eventsFile, "utf8");
+    return text
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((l) => JSON.parse(l));
+  }
+
+  test("returns an UnsubscribeFn", () => {
+    const bus = new PipelineEventBus();
+    const unsub = wireEventsWriter(bus, "my-feature", "run-001", workdir);
+    expect(typeof unsub).toBe("function");
+    unsub();
+  });
+
+  test("creates events.jsonl and writes run:started line", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-a", "run-abc", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-a", totalStories: 3, workdir });
+
+    const lines = await readLines();
+    expect(lines.length).toBe(1);
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("run:started");
+    expect(line.runId).toBe("run-abc");
+    expect(line.feature).toBe("feat-a");
+    expect(typeof line.project).toBe("string");
+    expect(typeof line.ts).toBe("string");
+    // ts must be valid ISO8601
+    expect(() => new Date(line.ts as string).toISOString()).not.toThrow();
+  });
+
+  test("each line has required fields: ts, event, runId, feature, project", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-b", "run-xyz", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-b", totalStories: 1, workdir });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    for (const field of ["ts", "event", "runId", "feature", "project"]) {
+      expect(line[field]).toBeDefined();
+    }
+  });
+
+  test("run:completed writes event=on-complete", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-c", "run-001", workdir);
+
+    bus.emit({
+      type: "run:completed",
+      totalStories: 1,
+      passedStories: 1,
+      failedStories: 0,
+      durationMs: 100,
+      totalCost: 0.01,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("on-complete");
+  });
+
+  test("story:started includes storyId", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-d", "run-001", workdir);
+
+    bus.emit({
+      type: "story:started",
+      storyId: "US-042",
+      story: stubStory,
+      workdir,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("story:started");
+    expect(line.storyId).toBe("US-042");
+  });
+
+  test("story:completed includes storyId", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-d", "run-001", workdir);
+
+    bus.emit({
+      type: "story:completed",
+      storyId: "US-042",
+      story: stubStory,
+      passed: true,
+      durationMs: 500,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("story:completed");
+    expect(line.storyId).toBe("US-042");
+  });
+
+  test("story:failed includes storyId", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-d", "run-001", workdir);
+
+    bus.emit({
+      type: "story:failed",
+      storyId: "US-042",
+      story: stubStory,
+      reason: "tests failed",
+      countsTowardEscalation: true,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("story:failed");
+    expect(line.storyId).toBe("US-042");
+  });
+
+  test("run:paused is written", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-e", "run-001", workdir);
+
+    bus.emit({ type: "run:paused", reason: "cost limit", cost: 5.0 });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("run:paused");
+  });
+
+  test("multiple events produce multiple JSONL lines", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-f", "run-multi", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-f", totalStories: 2, workdir });
+    bus.emit({ type: "story:started", storyId: "US-001", story: stubStory, workdir });
+    bus.emit({ type: "story:completed", storyId: "US-001", story: stubStory, passed: true, durationMs: 100 });
+    bus.emit({
+      type: "run:completed",
+      totalStories: 1,
+      passedStories: 1,
+      failedStories: 0,
+      durationMs: 200,
+    });
+
+    const lines = await readLines();
+    expect(lines.length).toBe(4);
+  });
+
+  test("write failure does not throw or crash", async () => {
+    const bus = new PipelineEventBus();
+    // Use a workdir whose project name would conflict with a file (simulate write error)
+    // by pointing to an invalid path — we patch mkdir to throw
+    const originalMkdir = (await import("node:fs/promises")).mkdir;
+
+    let callCount = 0;
+    const _fsMod = await import("node:fs/promises");
+    // Inject a failing write by pointing to a path that won't be writable
+    // We rely on the subscriber catching the error gracefully
+    const badWorkdir = "/dev/null/nonexistent-project";
+    const badBus = new PipelineEventBus();
+    wireEventsWriter(badBus, "feat-err", "run-err", badWorkdir);
+
+    // Should not throw
+    expect(() => {
+      badBus.emit({ type: "run:started", feature: "feat-err", totalStories: 0, workdir: badWorkdir });
+    }).not.toThrow();
+
+    // Give async time to attempt write and swallow error
+    await Bun.sleep(50);
+    // No assertion on file existence — the point is no crash/throw
+  });
+
+  test("unsubscribe stops further writes", async () => {
+    const bus = new PipelineEventBus();
+    const unsub = wireEventsWriter(bus, "feat-g", "run-unsub", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-g", totalStories: 1, workdir });
+    await Bun.sleep(50);
+
+    unsub();
+
+    bus.emit({
+      type: "run:completed",
+      totalStories: 1,
+      passedStories: 1,
+      failedStories: 0,
+      durationMs: 100,
+    });
+
+    await Bun.sleep(50);
+    const lines = await readLines();
+    // Only the first event should be written
+    expect(lines.length).toBe(1);
+    expect((lines[0] as Record<string, unknown>).event).toBe("run:started");
+  });
+});

package/test/unit/pipeline/subscribers/hooks.test.ts

@@ -11,11 +11,14 @@ describe("wireHooks", () => {
     const bus = new PipelineEventBus();
     wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
 
-    // Check subscriptions are registered
-    const events = ["run:started", "story:started", "story:completed", "story:failed", "story:paused", "run:paused", "run:completed"] as const;
-    for (const ev of events) {
+    // Single-subscriber events
+    const singleSubEvents = ["run:started", "story:started", "story:paused", "run:paused", "run:completed", "run:resumed", "run:errored"] as const;
+    for (const ev of singleSubEvents) {
       expect(bus.subscriberCount(ev)).toBe(1);
     }
+    // story:completed and story:failed each have 2: on-story-complete/fail + on-session-end
+    expect(bus.subscriberCount("story:completed")).toBe(2);
+    expect(bus.subscriberCount("story:failed")).toBe(2);
   });
 
   test("returns unsubscribe function that removes all subscriptions", () => {
@@ -24,7 +27,7 @@ describe("wireHooks", () => {
 
     unsub();
 
-    const events = ["run:started", "story:started", "story:completed"] as const;
+    const events = ["run:started", "story:started", "story:completed", "run:resumed", "run:errored"] as const;
     for (const ev of events) {
       expect(bus.subscriberCount(ev)).toBe(0);
     }
@@ -42,4 +45,40 @@ describe("wireHooks", () => {
       bus.emit({ type: "story:completed", storyId: "US-001", story: { id: "US-001" } as any, passed: true, durationMs: 100 }),
     ).not.toThrow();
   });
+
+  test("on-resume: run:resumed event triggers on-resume hook (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "run:resumed", feature: "test-feature" }),
+    ).not.toThrow();
+  });
+
+  test("on-session-end: story:completed triggers on-session-end with status passed (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "story:completed", storyId: "US-001", story: { id: "US-001" } as any, passed: true, durationMs: 100 }),
+    ).not.toThrow();
+  });
+
+  test("on-session-end: story:failed triggers on-session-end with status failed (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "story:failed", storyId: "US-001", story: { id: "US-001" } as any, reason: "test failure", countsTowardEscalation: true }),
+    ).not.toThrow();
+  });
+
+  test("on-error: run:errored event triggers on-error hook (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "run:errored", reason: "SIGTERM", feature: "test-feature" }),
+    ).not.toThrow();
+  });
 });