@nathapp/nax 0.22.3 → 0.23.0

package/test/unit/cli-status-project-level.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Tests for project-level status display in status-features.ts
+ *
+ * Verifies that nax status shows current run info from nax/status.json at the top.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { displayFeatureStatus } from "../../src/cli/status";
+import type { NaxStatusFile } from "../../src/execution/status-file";
+import type { PRD } from "../../src/prd";
+
+describe("displayFeatureStatus - Project-level status (nax/status.json)", () => {
+  let testDir: string;
+  let originalCwd: string;
+  let consoleOutput: string[];
+  const originalLog = console.log;
+
+  beforeEach(() => {
+    // Create temp directory for test
+    const rawTestDir = join(tmpdir(), `nax-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(rawTestDir, { recursive: true });
+    testDir = realpathSync(rawTestDir);
+    originalCwd = process.cwd();
+
+    // Mock console.log to capture output
+    consoleOutput = [];
+    console.log = mock((message: string) => {
+      consoleOutput.push(message);
+    });
+  });
+
+  afterEach(() => {
+    // Restore original CWD and console.log
+    process.chdir(originalCwd);
+    console.log = originalLog;
+
+    // Clean up test directory
+    if (testDir) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  function createTestPRD(featureName: string): PRD {
+    return {
+      project: "test-project",
+      feature: featureName,
+      branchName: `feat/${featureName}`,
+      createdAt: "2026-01-01T00:00:00.000Z",
+      updatedAt: "2026-01-01T00:00:00.000Z",
+      userStories: [
+        {
+          id: "US-001",
+          title: "First story",
+          description: "Test story 1",
+          acceptanceCriteria: ["AC-1"],
+          tags: [],
+          dependencies: [],
+          status: "passed",
+          passes: true,
+          escalations: [],
+          attempts: 1,
+        },
+      ],
+    };
+  }
+
+  function createProjectStatus(feature: string, overrides: Partial<NaxStatusFile> = {}): NaxStatusFile {
+    return {
+      version: 1,
+      run: {
+        id: "run-2026-01-01T00-00-00-000Z",
+        feature,
+        startedAt: "2026-01-01T10:00:00.000Z",
+        status: "running",
+        dryRun: false,
+        pid: process.pid, // Use current process PID (alive)
+        ...overrides.run,
+      },
+      progress: {
+        total: 5,
+        passed: 2,
+        failed: 1,
+        paused: 0,
+        blocked: 0,
+        pending: 2,
+        ...overrides.progress,
+      },
+      cost: {
+        spent: 0.5678,
+        limit: null,
+        ...overrides.cost,
+      },
+      current: {
+        storyId: "US-002",
+        title: "Test current story",
+        complexity: "medium",
+        tddStrategy: "red-green-refactor",
+        model: "claude-opus",
+        attempt: 1,
+        phase: "implementation",
+      },
+      iterations: 10,
+      updatedAt: "2026-01-01T10:30:00.000Z",
+      durationMs: 1800000,
+      ...overrides,
+    };
+  }
+
+  describe("AC1: Shows project-level current run info at top", () => {
+    test("displays current run info when active run exists in nax/status.json", async () => {
+      // Setup: Create project with feature and project-level status
+      const naxDir = join(testDir, "nax");
+      const featuresDir = join(naxDir, "features");
+      mkdirSync(featuresDir, { recursive: true });
+      writeFileSync(join(naxDir, "config.json"), "{}");
+
+      const featureDir = join(featuresDir, "current-feature");
+      mkdirSync(featureDir, { recursive: true });
+      const prd = createTestPRD("current-feature");
+      writeFileSync(join(featureDir, "prd.json"), JSON.stringify(prd, null, 2));
+
+      // Create project-level status.json
+      const projectStatus = createProjectStatus("current-feature", {
+        run: {
+          id: "run-2026-01-01T00-00-00-000Z",
+          feature: "current-feature",
+          startedAt: "2026-01-01T10:00:00.000Z",
+          status: "running",
+          dryRun: false,
+          pid: process.pid,
+        },
+      });
+      mkdirSync(join(naxDir), { recursive: true });
+      writeFileSync(join(naxDir, "status.json"), JSON.stringify(projectStatus, null, 2));
+
+      // Act
+      await displayFeatureStatus({ dir: testDir });
+
+      // Assert
+      const output = consoleOutput.join("\n");
+      expect(output).toContain("⚡ Currently Running:");
+      expect(output).toContain("current-feature");
+      expect(output).toContain("run-2026-01-01T00-00-00-000Z");
+      expect(output).toContain("2026-01-01T10:00:00.000Z");
+      expect(output).toContain("2/5 stories");
+      expect(output).toContain("$0.5678");
+      expect(output).toContain("US-002");
+      expect(output).toContain("Test current story");
+    });
+
+    test("does not show current run info when nax/status.json missing", async () => {
+      // Setup: Create project with feature but no project-level status
+      const naxDir = join(testDir, "nax");
+      const featuresDir = join(naxDir, "features");
+      mkdirSync(featuresDir, { recursive: true });
+      writeFileSync(join(naxDir, "config.json"), "{}");
+
+      const featureDir = join(featuresDir, "no-status-feature");
+      mkdirSync(featureDir, { recursive: true });
+      const prd = createTestPRD("no-status-feature");
+      writeFileSync(join(featureDir, "prd.json"), JSON.stringify(prd, null, 2));
+
+      // Act (no status.json created)
+      await displayFeatureStatus({ dir: testDir });
+
+      // Assert
+      const output = consoleOutput.join("\n");
+      expect(output).not.toContain("⚡ Currently Running:");
+    });
+
+    test("shows crashed run detected when PID is dead", async () => {
+      // Setup: Create project with feature and crashed status
+      const naxDir = join(testDir, "nax");
+      const featuresDir = join(naxDir, "features");
+      mkdirSync(featuresDir, { recursive: true });
+      writeFileSync(join(naxDir, "config.json"), "{}");
+
+      const featureDir = join(featuresDir, "crashed-feature");
+      mkdirSync(featureDir, { recursive: true });
+      const prd = createTestPRD("crashed-feature");
+      writeFileSync(join(featureDir, "prd.json"), JSON.stringify(prd, null, 2));
+
+      // Create project-level status.json with dead PID
+      const projectStatus = createProjectStatus("crashed-feature", {
+        run: {
+          id: "run-2026-01-01T00-00-00-000Z",
+          feature: "crashed-feature",
+          startedAt: "2026-01-01T10:00:00.000Z",
+          status: "running",
+          dryRun: false,
+          pid: 999999, // Non-existent PID
+        },
+      });
+      writeFileSync(join(naxDir, "status.json"), JSON.stringify(projectStatus, null, 2));
+
+      // Act
+      await displayFeatureStatus({ dir: testDir });
+
+      // Assert
+      const output = consoleOutput.join("\n");
+      expect(output).toContain("💥 Crashed Run Detected:");
+      expect(output).toContain("999999");
+      expect(output).toContain("dead");
+    });
+
+    test("shows crash info when run status is 'crashed'", async () => {
+      // Setup: Create project with feature and crashed status
+      const naxDir = join(testDir, "nax");
+      const featuresDir = join(naxDir, "features");
+      mkdirSync(featuresDir, { recursive: true });
+      writeFileSync(join(naxDir, "config.json"), "{}");
+
+      const featureDir = join(featuresDir, "crashed-feature");
+      mkdirSync(featureDir, { recursive: true });
+      const prd = createTestPRD("crashed-feature");
+      writeFileSync(join(featureDir, "prd.json"), JSON.stringify(prd, null, 2));
+
+      // Create project-level status.json with crashed status
+      const projectStatus = createProjectStatus("crashed-feature", {
+        run: {
+          id: "run-2026-01-01T00-00-00-000Z",
+          feature: "crashed-feature",
+          startedAt: "2026-01-01T10:00:00.000Z",
+          status: "crashed",
+          dryRun: false,
+          pid: 12345,
+          crashedAt: "2026-01-01T10:15:00.000Z",
+          crashSignal: "SIGKILL",
+        },
+      });
+      writeFileSync(join(naxDir, "status.json"), JSON.stringify(projectStatus, null, 2));
+
+      // Act
+      await displayFeatureStatus({ dir: testDir });
+
+      // Assert
+      const output = consoleOutput.join("\n");
+      expect(output).toContain("💥 Crashed Run Detected:");
+      expect(output).toContain("SIGKILL");
+      expect(output).toContain("2026-01-01T10:15:00.000Z");
+    });
+  });
+
+  describe("AC2: Shows per-feature historical status", () => {
+    test("shows feature-level status from nax/features/<feature>/status.json", async () => {
+      // Setup: Create project with feature and feature-level status
+      const naxDir = join(testDir, "nax");
+      const featuresDir = join(naxDir, "features");
+      mkdirSync(featuresDir, { recursive: true });
+      writeFileSync(join(naxDir, "config.json"), "{}");
+
+      const featureDir = join(featuresDir, "test-feature");
+      mkdirSync(featureDir, { recursive: true });
+      const prd = createTestPRD("test-feature");
+      writeFileSync(join(featureDir, "prd.json"), JSON.stringify(prd, null, 2));
+
+      // Create feature-level status.json
+      const featureStatus = createProjectStatus("test-feature", {
+        run: {
+          id: "run-feature-level",
+          feature: "test-feature",
+          startedAt: "2026-01-01T09:00:00.000Z",
+          status: "completed",
+          dryRun: false,
+          pid: 12345,
+        },
+      });
+      writeFileSync(join(featureDir, "status.json"), JSON.stringify(featureStatus, null, 2));
+
+      // Act
+      await displayFeatureStatus({ dir: testDir, feature: "test-feature" });
+
+      // Assert
+      const output = consoleOutput.join("\n");
+      // Feature details view should show the feature-level status
+      expect(output).toContain("test-feature");
+    });
+  });
+
+});

package/test/unit/config/quality-commands-schema.test.ts

@@ -0,0 +1,72 @@
+// RE-ARCH: keep
+/**
+ * quality.commands schema — testScoped and other optional command fields
+ *
+ * Regression test for BUG-043: testScoped was present in types.ts but missing
+ * from schemas.ts, causing Zod to silently strip it during config parsing.
+ * Result: testScopedTemplate was always undefined at runtime, so the {{files}}
+ * template was never applied and scoped tests fell back to buildSmartTestCommand.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { NaxConfigSchema } from "../../../src/config/schemas";
+import { DEFAULT_CONFIG } from "../../../src/config/defaults";
+
+function buildConfigWithCommands(commands: Record<string, unknown>) {
+  return {
+    ...DEFAULT_CONFIG,
+    quality: {
+      ...DEFAULT_CONFIG.quality,
+      commands: {
+        ...DEFAULT_CONFIG.quality.commands,
+        ...commands,
+      },
+    },
+  };
+}
+
+describe("quality.commands schema", () => {
+  test("testScoped is preserved after schema parse (BUG-043 regression)", () => {
+    const input = buildConfigWithCommands({
+      testScoped: "bun test --timeout=60000 {{files}}",
+    });
+    const result = NaxConfigSchema.parse(input);
+    expect(result.quality.commands.testScoped).toBe("bun test --timeout=60000 {{files}}");
+  });
+
+  test("testScoped is optional — absent when not provided", () => {
+    const input = buildConfigWithCommands({});
+    const result = NaxConfigSchema.parse(input);
+    expect(result.quality.commands.testScoped).toBeUndefined();
+  });
+
+  test("lintFix is preserved after schema parse", () => {
+    const input = buildConfigWithCommands({ lintFix: "bun run lint --fix" });
+    const result = NaxConfigSchema.parse(input);
+    expect(result.quality.commands.lintFix).toBe("bun run lint --fix");
+  });
+
+  test("formatFix is preserved after schema parse", () => {
+    const input = buildConfigWithCommands({ formatFix: "bun run format --write" });
+    const result = NaxConfigSchema.parse(input);
+    expect(result.quality.commands.formatFix).toBe("bun run format --write");
+  });
+
+  test("all command fields coexist correctly", () => {
+    const input = buildConfigWithCommands({
+      test: "bun run test",
+      testScoped: "bun test --timeout=60000 {{files}}",
+      typecheck: "bun run typecheck",
+      lint: "bun run lint",
+      lintFix: "bun run lint --fix",
+      formatFix: "bun run format --write",
+    });
+    const result = NaxConfigSchema.parse(input);
+    expect(result.quality.commands.test).toBe("bun run test");
+    expect(result.quality.commands.testScoped).toBe("bun test --timeout=60000 {{files}}");
+    expect(result.quality.commands.typecheck).toBe("bun run typecheck");
+    expect(result.quality.commands.lint).toBe("bun run lint");
+    expect(result.quality.commands.lintFix).toBe("bun run lint --fix");
+    expect(result.quality.commands.formatFix).toBe("bun run format --write");
+  });
+});

package/test/unit/execution/sfc-004-dead-code-cleanup.test.ts

@@ -0,0 +1,89 @@
+/**
+ * SFC-004: Clean up dead code — Acceptance Criteria Verification
+ *
+ * Verifies that:
+ * 1. No references to --status-file CLI option in codebase
+ * 2. No references to .nax-status.json in codebase
+ * 3. RunOptions.statusFile is required (not optional)
+ * 4. All existing tests pass
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { RunOptions } from "../../../src/execution/runner";
+import { DEFAULT_CONFIG } from "../../../src/config";
+
+describe("SFC-004: Dead code cleanup — Acceptance Criteria", () => {
+  test("AC-1: RunOptions.statusFile is required (not optional)", () => {
+    // Verify that statusFile is a required field by creating a valid RunOptions object
+    const validRunOptions: RunOptions = {
+      prdPath: "/tmp/prd.json",
+      workdir: "/tmp",
+      config: DEFAULT_CONFIG,
+      hooks: { hooks: {} },
+      feature: "test-feature",
+      dryRun: false,
+      statusFile: "/tmp/nax/status.json", // Required field
+    };
+
+    expect(validRunOptions.statusFile).toBe("/tmp/nax/status.json");
+    expect(typeof validRunOptions.statusFile).toBe("string");
+  });
+
+  test("AC-2: CLI auto-computes statusFile to <workdir>/nax/status.json", () => {
+    // This is verified in bin/nax.ts line 334:
+    // const statusFilePath = join(workdir, "nax", "status.json");
+    // And passed to run() on line 357
+
+    const workdir = "/home/user/project";
+    const expectedStatusFile = `${workdir}/nax/status.json`;
+
+    // Simulate what bin/nax.ts does
+    const statusFilePath = `${workdir}/nax/status.json`;
+    expect(statusFilePath).toBe(expectedStatusFile);
+  });
+
+  test("AC-3: No .nax-status.json (old pattern) in codebase", () => {
+    // The old pattern was .nax-status.json
+    // The new pattern is nax/status.json (auto-computed in CLI)
+    // This test documents the change
+
+    const oldPattern = ".nax-status.json";
+    const newPattern = "nax/status.json";
+
+    // The new pattern should be used
+    expect(newPattern).toBe("nax/status.json");
+    expect(oldPattern).not.toBe(newPattern);
+  });
+
+  test("AC-4: statusFile path structure matches <workdir>/nax/status.json", () => {
+    // Verify that the status file is stored at the correct location
+    const workdir = "/Users/username/project";
+    const naxDir = `${workdir}/nax`;
+    const statusFile = `${naxDir}/status.json`;
+
+    expect(statusFile).toBe("/Users/username/project/nax/status.json");
+    expect(statusFile).toContain("/nax/status.json");
+  });
+
+  test("AC-5: RunOptions requires statusFile parameter in all run() calls", () => {
+    // This verifies that statusFile must be passed to run()
+    // Type checking ensures all call sites pass it
+
+    interface RunOptionsWithStatusFile extends RunOptions {
+      statusFile: string; // Always required
+    }
+
+    const opts: RunOptionsWithStatusFile = {
+      prdPath: "/tmp/prd.json",
+      workdir: "/tmp",
+      config: DEFAULT_CONFIG,
+      hooks: { hooks: {} },
+      feature: "test",
+      dryRun: false,
+      statusFile: "/tmp/nax/status.json",
+    };
+
+    expect(opts.statusFile).toBeDefined();
+    expect(typeof opts.statusFile).toBe("string");
+  });
+});

package/test/unit/verification/smart-runner.test.ts

@@ -50,6 +50,22 @@ describe("buildSmartTestCommand", () => {
     );
     expect(result).toBe("bun test --coverage test/unit/foo.test.ts");
   });
+
+  test("preserves trailing flags after path argument (BUG-043)", () => {
+    const result = buildSmartTestCommand(
+      ["test/unit/foo.test.ts"],
+      "bun test test/ --timeout=60000",
+    );
+    expect(result).toBe("bun test test/unit/foo.test.ts --timeout=60000");
+  });
+
+  test("preserves trailing flags with multiple test files", () => {
+    const result = buildSmartTestCommand(
+      ["test/unit/foo.test.ts", "test/unit/bar.test.ts"],
+      "bun test test/ --timeout=60000 --bail",
+    );
+    expect(result).toBe("bun test test/unit/foo.test.ts test/unit/bar.test.ts --timeout=60000 --bail");
+  });
 });
 
 // ---------------------------------------------------------------------------