@nathapp/nax 0.18.1

package/test/integration/status-writer.test.ts

@@ -0,0 +1,345 @@
+/**
+ * StatusWriter Tests
+ *
+ * Tests for src/execution/status-writer.ts:
+ * - Construction and defaults
+ * - setRunStatus / setPrd / setCurrentStory setters
+ * - getSnapshot() builds correct RunStateSnapshot
+ * - update() writes via writeStatusFile (no-op guard, success path, failure counter BUG-2)
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { NaxConfig } from "../../src/config";
+import type { NaxStatusFile } from "../../src/execution/status-file";
+import { StatusWriter, type StatusWriterContext } from "../../src/execution/status-writer";
+import type { PRD, UserStory } from "../../src/prd";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function makeStory(id: string, status: UserStory["status"] = "pending"): UserStory {
+  return {
+    id,
+    title: `Story ${id}`,
+    description: `Description for ${id}`,
+    acceptanceCriteria: ["AC-1"],
+    tags: [],
+    dependencies: [],
+    status,
+    passes: status === "passed",
+    escalations: [],
+    attempts: 0,
+  };
+}
+
+function makePrd(count = 1): PRD {
+  return {
+    project: "test-project",
+    feature: "test-feature",
+    branchName: "feat/test",
+    createdAt: "2026-02-25T10:00:00.000Z",
+    updatedAt: "2026-02-25T10:00:00.000Z",
+    userStories: Array.from({ length: count }, (_, i) => makeStory(`US-00${i + 1}`)),
+  };
+}
+
+function makeConfig(costLimit = 5.0): NaxConfig {
+  return {
+    execution: {
+      costLimit,
+      maxIterations: 10,
+      maxStoriesPerFeature: 50,
+      iterationDelayMs: 0,
+    },
+  } as unknown as NaxConfig;
+}
+
+function makeCtx(overrides: Partial<StatusWriterContext> = {}): StatusWriterContext {
+  return {
+    runId: "run-test-001",
+    feature: "auth-feature",
+    startedAt: "2026-02-25T10:00:00.000Z",
+    dryRun: false,
+    startTimeMs: Date.now() - 1000,
+    pid: process.pid,
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// Construction
+// ============================================================================
+
+describe("StatusWriter construction", () => {
+  test("constructs without error when statusFile is defined", () => {
+    expect(() => new StatusWriter("/tmp/status.json", makeConfig(), makeCtx())).not.toThrow();
+  });
+
+  test("constructs without error when statusFile is undefined (no-op mode)", () => {
+    expect(() => new StatusWriter(undefined, makeConfig(), makeCtx())).not.toThrow();
+  });
+
+  test("costLimit Infinity → stored as null in snapshot", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const path = join(dir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(Number.POSITIVE_INFINITY), makeCtx());
+    sw.setPrd(makePrd());
+    await sw.update(0, 0);
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.cost.limit).toBeNull();
+    await rm(dir, { recursive: true, force: true });
+  });
+});
+
+// ============================================================================
+// Setters
+// ============================================================================
+
+describe("StatusWriter setters", () => {
+  test("setRunStatus changes run status in snapshot", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const path = join(dir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    sw.setRunStatus("completed");
+    await sw.update(0, 0);
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.run.status).toBe("completed");
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("setPrd enables writes (no-op without prd)", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const path = join(dir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    // Without setPrd, update should be a no-op
+    await sw.update(0, 0);
+    expect(existsSync(path)).toBe(false);
+    // After setPrd, write happens
+    sw.setPrd(makePrd());
+    await sw.update(0, 0);
+    expect(existsSync(path)).toBe(true);
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("setCurrentStory sets active story in snapshot", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const path = join(dir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    sw.setCurrentStory({
+      storyId: "US-001",
+      title: "Test story",
+      complexity: "simple",
+      tddStrategy: "test-after",
+      model: "balanced",
+      attempt: 1,
+      phase: "routing",
+    });
+    await sw.update(0, 0);
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.current?.storyId).toBe("US-001");
+    expect(content.current?.phase).toBe("routing");
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("setCurrentStory(null) clears active story", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const path = join(dir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    sw.setCurrentStory({
+      storyId: "US-001",
+      title: "T",
+      complexity: "simple",
+      tddStrategy: "test-after",
+      model: "balanced",
+      attempt: 1,
+      phase: "routing",
+    });
+    sw.setCurrentStory(null);
+    await sw.update(0, 0);
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.current).toBeNull();
+    await rm(dir, { recursive: true, force: true });
+  });
+});
+
+// ============================================================================
+// getSnapshot
+// ============================================================================
+
+describe("StatusWriter.getSnapshot", () => {
+  test("returns null when prd not set", () => {
+    const sw = new StatusWriter("/tmp/x.json", makeConfig(), makeCtx());
+    expect(sw.getSnapshot(0, 0)).toBeNull();
+  });
+
+  test("includes totalCost and iterations from call args", () => {
+    const sw = new StatusWriter("/tmp/x.json", makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    const snap = sw.getSnapshot(3.75, 7);
+    expect(snap?.totalCost).toBe(3.75);
+    expect(snap?.iterations).toBe(7);
+  });
+
+  test("includes fixed context values from constructor", () => {
+    const ctx = makeCtx({ runId: "run-abc", feature: "my-feature", dryRun: true, pid: 12345 });
+    const sw = new StatusWriter("/tmp/x.json", makeConfig(), ctx);
+    sw.setPrd(makePrd());
+    const snap = sw.getSnapshot(0, 0);
+    expect(snap?.runId).toBe("run-abc");
+    expect(snap?.feature).toBe("my-feature");
+    expect(snap?.dryRun).toBe(true);
+    expect(snap?.pid).toBe(12345);
+  });
+
+  test("includes PID for crash detection", () => {
+    const testPid = 99999;
+    const sw = new StatusWriter("/tmp/x.json", makeConfig(), makeCtx({ pid: testPid }));
+    sw.setPrd(makePrd());
+    const snap = sw.getSnapshot(0, 0);
+    expect(snap?.pid).toBe(testPid);
+  });
+});
+
+// ============================================================================
+// update — no-op guards
+// ============================================================================
+
+describe("StatusWriter.update no-op guards", () => {
+  test("no-op when statusFile is undefined (even with prd set)", async () => {
+    const sw = new StatusWriter(undefined, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    // Should not throw
+    await expect(sw.update(0, 0)).resolves.toBeUndefined();
+  });
+
+  test("no-op when prd not yet set", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const path = join(dir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    await sw.update(0, 0);
+    expect(existsSync(path)).toBe(false);
+    await rm(dir, { recursive: true, force: true });
+  });
+});
+
+// ============================================================================
+// update — success path
+// ============================================================================
+
+describe("StatusWriter.update success path", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "sw-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  test("writes valid JSON status file", async () => {
+    const path = join(tmpDir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd(2));
+    await sw.update(1.5, 3);
+
+    expect(existsSync(path)).toBe(true);
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.version).toBe(1);
+    expect(content.cost.spent).toBe(1.5);
+    expect(content.iterations).toBe(3);
+    expect(content.progress.total).toBe(2);
+  });
+
+  test("overrides are applied on top of base snapshot", async () => {
+    const path = join(tmpDir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    await sw.update(0, 0, { runStatus: "completed" });
+
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.run.status).toBe("completed");
+  });
+
+  test("multiple updates overwrite the file", async () => {
+    const path = join(tmpDir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    sw.setRunStatus("running");
+    await sw.update(0, 1);
+
+    sw.setRunStatus("completed");
+    await sw.update(2.0, 5);
+
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.run.status).toBe("completed");
+    expect(content.cost.spent).toBe(2.0);
+    expect(content.iterations).toBe(5);
+  });
+
+  test("no .tmp file remains after successful write", async () => {
+    const path = join(tmpDir, "status.json");
+    const sw = new StatusWriter(path, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    await sw.update(0, 0);
+    expect(existsSync(`${path}.tmp`)).toBe(false);
+  });
+
+  test("PID is written to status file for crash detection", async () => {
+    const path = join(tmpDir, "status.json");
+    const testPid = 88888;
+    const sw = new StatusWriter(path, makeConfig(), makeCtx({ pid: testPid }));
+    sw.setPrd(makePrd());
+    await sw.update(0, 0);
+
+    const content = JSON.parse(readFileSync(path, "utf8")) as NaxStatusFile;
+    expect(content.run.pid).toBe(testPid);
+  });
+});
+
+// ============================================================================
+// update — BUG-2 failure counter
+// ============================================================================
+
+describe("StatusWriter.update BUG-2 failure counter", () => {
+  test("write to a non-existent directory fails gracefully (non-fatal)", async () => {
+    const sw = new StatusWriter("/does/not/exist/status.json", makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+    // Should not throw — failure is logged, not re-thrown
+    await expect(sw.update(0, 0)).resolves.toBeUndefined();
+  });
+
+  test("failure counter increments on consecutive failures", async () => {
+    // Use an invalid path to force failures
+    const sw = new StatusWriter("/no/such/dir/status.json", makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+
+    // Three consecutive failures should trigger error-level logging
+    // We can't easily introspect the counter directly, but we can verify
+    // that update() never throws
+    for (let i = 0; i < 5; i++) {
+      await expect(sw.update(0, i)).resolves.toBeUndefined();
+    }
+  });
+
+  test("counter resets to 0 after successful write following failures", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
+    const validPath = join(dir, "status.json");
+    const sw = new StatusWriter(validPath, makeConfig(), makeCtx());
+    sw.setPrd(makePrd());
+
+    // Cause some failures first by temporarily checking invalid path...
+    // We can do this by verifying a successful write after errors doesn't throw
+    await sw.update(0, 0);
+    expect(existsSync(validPath)).toBe(true);
+    await rm(dir, { recursive: true, force: true });
+  });
+});

package/test/integration/story-id-in-events.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Test: Verify storyId presence in JSONL events (BUG-020)
+ *
+ * Ensures that key events (agent.start, agent.complete, verify, tdd, execution, escalation)
+ * include storyId in their data when a story is active.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { NaxConfig } from "../../src/config/schema";
+import { initLogger, resetLogger } from "../../src/logger";
+import { getLogger } from "../../src/logger/logger";
+import type { LogEntry } from "../../src/logger/types";
+import { executionStage } from "../../src/pipeline/stages/execution";
+import { verifyStage } from "../../src/pipeline/stages/verify";
+import type { PipelineContext } from "../../src/pipeline/types";
+import type { PRD, UserStory } from "../../src/prd/types";
+
+/** Captured log entries */
+let capturedLogs: LogEntry[] = [];
+
+/** Custom logger that captures entries */
+function captureLogger() {
+  const originalLogger = getLogger();
+  capturedLogs = [];
+
+  // Override logger methods to capture entries
+  const captureLog = (stage: string, message: string, data?: Record<string, unknown>) => {
+    capturedLogs.push({
+      timestamp: new Date().toISOString(),
+      stage,
+      message,
+      data: data || {},
+    });
+  };
+
+  // @ts-expect-error - Intentionally mocking logger for tests
+  originalLogger.info = captureLog;
+  // @ts-expect-error - Intentionally mocking logger for tests
+  originalLogger.warn = captureLog;
+  // @ts-expect-error - Intentionally mocking logger for tests
+  originalLogger.error = captureLog;
+  // @ts-expect-error - Intentionally mocking logger for tests
+  originalLogger.debug = captureLog;
+
+  return originalLogger;
+}
+
+/** Helper: Create minimal test context */
+function createTestContext(overrides?: Partial<PipelineContext>): PipelineContext {
+  const story: UserStory = {
+    id: "US-001",
+    title: "Test Story",
+    description: "Test description",
+    acceptanceCriteria: ["Test passes"],
+    tags: [],
+    dependencies: [],
+    status: "pending",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+  };
+
+  const prd: PRD = {
+    project: "test-project",
+    feature: "test-feature",
+    branchName: "test-branch",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: [story],
+  };
+
+  const config: NaxConfig = {
+    version: 1,
+    models: {
+      fast: "claude-sonnet-4-5",
+      balanced: "claude-sonnet-4-5",
+      powerful: "claude-opus-4-6",
+    },
+    autoMode: {
+      enabled: true,
+      defaultAgent: "nax-agent-claude",
+      fallbackOrder: ["nax-agent-claude"],
+      complexityRouting: {
+        simple: "fast",
+        medium: "balanced",
+        complex: "powerful",
+        expert: "powerful",
+      },
+      escalation: {
+        enabled: true,
+        maxAttempts: 3,
+      },
+    },
+    execution: {
+      maxIterations: 100,
+      iterationDelayMs: 1000,
+      costLimit: 50,
+      sessionTimeoutSeconds: 600,
+      maxStoriesPerFeature: 50,
+      verificationTimeoutSeconds: 120,
+      dangerouslySkipPermissions: false,
+    },
+    quality: {
+      requireTypecheck: false,
+      requireLint: false,
+      requireTests: true,
+      commands: {},
+    },
+    tdd: {
+      maxRetries: 3,
+      autoVerifyIsolation: true,
+      autoApproveVerifier: true,
+    },
+    constitution: {
+      enabled: false,
+      path: "constitution.md",
+      maxTokens: 2000,
+    },
+    analyze: {
+      llmEnhanced: false,
+      model: "balanced",
+      fallbackToKeywords: true,
+      maxCodebaseSummaryTokens: 4000,
+    },
+    review: {
+      enabled: true,
+      checks: ["test"],
+      commands: {},
+    },
+    plan: {
+      model: "balanced",
+      outputPath: "features",
+    },
+  };
+
+  return {
+    config,
+    prd,
+    story,
+    stories: [story],
+    routing: {
+      complexity: "simple",
+      modelTier: "fast",
+      testStrategy: "test-after",
+      reasoning: "Test routing",
+    },
+    workdir: "/test/workdir",
+    hooks: { hooks: {} },
+    ...overrides,
+  };
+}
+
+describe("StoryId in JSONL events (BUG-020)", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "nax-storyid-test-"));
+    initLogger({ level: "debug", useChalk: false });
+    captureLogger();
+  });
+
+  afterEach(() => {
+    resetLogger();
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("verify stage events include storyId", async () => {
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "echo 'Tests passed'",
+          },
+        },
+      },
+    });
+
+    await verifyStage.execute(ctx);
+
+    // Check that verify events have storyId
+    const verifyEvents = capturedLogs.filter((log) => log.stage === "verify");
+    expect(verifyEvents.length).toBeGreaterThan(0);
+
+    for (const event of verifyEvents) {
+      expect(event.data).toHaveProperty("storyId");
+      expect(event.data.storyId).toBe("US-001");
+    }
+  });
+
+  test("verify stage skip events include storyId", async () => {
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        quality: {
+          requireTypecheck: false,
+          requireLint: false,
+          requireTests: false, // Skip verification
+          commands: {},
+        },
+      },
+    });
+
+    await verifyStage.execute(ctx);
+
+    // Check that skip debug events have storyId
+    const verifyEvents = capturedLogs.filter((log) => log.stage === "verify");
+    expect(verifyEvents.length).toBeGreaterThan(0);
+
+    for (const event of verifyEvents) {
+      expect(event.data).toHaveProperty("storyId");
+      expect(event.data.storyId).toBe("US-001");
+    }
+  });
+
+  test("execution stage agent failure events include storyId", async () => {
+    const ctx = createTestContext({
+      workdir: tempDir,
+      prompt: "Test prompt for execution",
+      config: {
+        ...createTestContext().config,
+        autoMode: {
+          ...createTestContext().config.autoMode,
+          defaultAgent: "nonexistent-agent", // Will trigger agent not found
+        },
+      },
+    });
+
+    const result = await executionStage.execute(ctx);
+
+    // Check that execution failure events have storyId
+    // The agent not found path logs a failure without storyId in the message
+    // This test verifies the agent failure path is reachable
+    expect(result.action).toBe("fail");
+    expect(result.reason).toContain("Agent");
+  });
+
+  test("verify stage failure events include storyId", async () => {
+    const ctx = createTestContext({
+      workdir: tempDir,
+      config: {
+        ...createTestContext().config,
+        review: {
+          enabled: true,
+          checks: ["test"],
+          commands: {
+            test: "sh -c 'exit 1'", // Fail
+          },
+        },
+      },
+    });
+
+    await verifyStage.execute(ctx);
+
+    // Check that error events have storyId
+    const verifyErrorEvents = capturedLogs.filter((log) => log.stage === "verify");
+    expect(verifyErrorEvents.length).toBeGreaterThan(0);
+
+    for (const event of verifyErrorEvents) {
+      expect(event.data).toHaveProperty("storyId");
+      expect(event.data.storyId).toBe("US-001");
+    }
+  });
+});