@nathapp/nax 0.18.1

package/test/integration/cli-precheck.test.ts

@@ -0,0 +1,371 @@
+/**
+ * Integration tests for CLI precheck command
+ *
+ * Tests:
+ * - Command registration and flag parsing
+ * - Directory resolution via resolveProject()
+ * - Human and JSON output formats
+ * - Exit codes (0=pass, 1=blocker, 2=invalid PRD)
+ * - Error handling for missing feature/prd.json
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { precheckCommand } from "../../src/commands/precheck";
+import type { PRD } from "../../src/prd/types";
+import { EXIT_CODES } from "../../src/precheck";
+
+const TEMP_DIR = join(import.meta.dir, "tmp-precheck-cli");
+
+/**
+ * Helper to create a test project structure
+ */
+function setupTestProject(name: string): {
+  projectDir: string;
+  naxDir: string;
+  featureDir: string;
+  prdPath: string;
+} {
+  const projectDir = join(TEMP_DIR, name);
+  const naxDir = join(projectDir, "nax");
+  const featureDir = join(naxDir, "features", "test-feature");
+  const prdPath = join(featureDir, "prd.json");
+
+  mkdirSync(featureDir, { recursive: true });
+
+  // Write minimal config.json
+  Bun.write(
+    join(naxDir, "config.json"),
+    JSON.stringify(
+      {
+        feature: "test-feature",
+        routing: { enabled: true, tierLabels: { fast: 1, balanced: 2, powerful: 3 } },
+        quality: { test: { enabled: true, command: "echo test" } },
+      },
+      null,
+      2,
+    ),
+  );
+
+  // Initialize git repo to satisfy checks
+  Bun.spawnSync(["git", "init", "-q"], { cwd: projectDir });
+  Bun.spawnSync(["git", "config", "user.name", "Test"], { cwd: projectDir });
+  Bun.spawnSync(["git", "config", "user.email", "test@example.com"], { cwd: projectDir });
+
+  // Create node_modules to satisfy dependencies check
+  mkdirSync(join(projectDir, "node_modules"), { recursive: true });
+
+  return { projectDir, naxDir, featureDir, prdPath };
+}
+
+/**
+ * Helper to create a valid PRD
+ */
+function createValidPRD(): PRD {
+  return {
+    version: "0.1.0",
+    project: "test-project",
+    feature: "test-feature",
+    branch: "feat/test-feature",
+    branchName: "feat/test-feature",
+    userStories: [
+      {
+        id: "US-001",
+        title: "Test Story",
+        description: "Test description",
+        acceptanceCriteria: [{ id: "AC-1", criterion: "Test criterion", testStrategy: "integration" }],
+        tags: [],
+        routing: {
+          tier: "fast",
+          complexity: "simple",
+          estimatedCost: 0.01,
+          security: false,
+          thinkingBudget: 1000,
+        },
+        dependencies: [],
+      },
+    ],
+    totalStories: 1,
+    completedStories: 0,
+    progress: 0,
+  };
+}
+
+describe("CLI precheck command", () => {
+  beforeEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+    mkdirSync(TEMP_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should resolve project directory with -d flag", async () => {
+    const { projectDir, prdPath } = setupTestProject("test-d-flag");
+
+    // Write valid PRD
+    await Bun.write(prdPath, JSON.stringify(createValidPRD()));
+
+    // Commit everything to satisfy working-tree-clean check
+    Bun.spawnSync(["git", "add", "."], { cwd: projectDir });
+    Bun.spawnSync(["git", "commit", "-m", "init", "-q"], { cwd: projectDir });
+
+    // Mock process.exit to capture exit code
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    process.exit = ((code?: number) => {
+      exitCode = code;
+      // Don't actually exit in tests
+    }) as never;
+
+    try {
+      await precheckCommand({
+        feature: "test-feature",
+        dir: projectDir,
+        json: false,
+      });
+    } catch (err) {
+      // Expected - command calls process.exit
+    } finally {
+      process.exit = originalExit;
+    }
+
+    // Should exit with code 0 (success) or 1 (warning)
+    expect(exitCode).toBeDefined();
+    expect([EXIT_CODES.SUCCESS, EXIT_CODES.BLOCKER]).toContain(exitCode);
+  });
+
+  test("should accept -f flag for feature name", async () => {
+    const { projectDir, prdPath } = setupTestProject("test-f-flag");
+
+    // Write valid PRD
+    await Bun.write(prdPath, JSON.stringify(createValidPRD()));
+
+    // Commit to satisfy checks
+    Bun.spawnSync(["git", "add", "."], { cwd: projectDir });
+    Bun.spawnSync(["git", "commit", "-m", "init", "-q"], { cwd: projectDir });
+
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    process.exit = ((code?: number) => {
+      exitCode = code;
+    }) as never;
+
+    try {
+      await precheckCommand({
+        feature: "test-feature",
+        dir: projectDir,
+        json: false,
+      });
+    } catch (err) {
+      // Expected
+    } finally {
+      process.exit = originalExit;
+    }
+
+    expect(exitCode).toBeDefined();
+  });
+
+  test("should output JSON format with --json flag", async () => {
+    const { projectDir, prdPath } = setupTestProject("test-json-flag");
+
+    // Write valid PRD
+    await Bun.write(prdPath, JSON.stringify(createValidPRD()));
+
+    // Commit to satisfy checks
+    Bun.spawnSync(["git", "add", "."], { cwd: projectDir });
+    Bun.spawnSync(["git", "commit", "-m", "init", "-q"], { cwd: projectDir });
+
+    // Capture console.log output
+    const logs: string[] = [];
+    const originalLog = console.log;
+    console.log = (msg: string) => {
+      logs.push(msg);
+    };
+
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    process.exit = ((code?: number) => {
+      exitCode = code;
+    }) as never;
+
+    try {
+      await precheckCommand({
+        feature: "test-feature",
+        dir: projectDir,
+        json: true,
+      });
+    } catch (err) {
+      // Expected
+    } finally {
+      console.log = originalLog;
+      process.exit = originalExit;
+    }
+
+    // Should have JSON output
+    expect(logs.length).toBeGreaterThan(0);
+
+    // Try to parse first log as JSON
+    const jsonOutput = JSON.parse(logs[0]);
+    expect(jsonOutput).toHaveProperty("passed");
+    expect(jsonOutput).toHaveProperty("blockers");
+    expect(jsonOutput).toHaveProperty("warnings");
+    expect(jsonOutput).toHaveProperty("summary");
+    expect(jsonOutput).toHaveProperty("feature");
+    expect(jsonOutput.feature).toBe("test-feature");
+  });
+
+  test("should exit with code 2 for invalid PRD", async () => {
+    const { projectDir, prdPath } = setupTestProject("test-invalid-prd");
+
+    // Write PRD that will pass loading but fail validation
+    await Bun.write(
+      prdPath,
+      JSON.stringify({
+        version: "0.1.0",
+        // Missing required fields: project, feature, branchName
+        userStories: [],
+        totalStories: 0,
+        completedStories: 0,
+        progress: 0,
+      }),
+    );
+
+    // Commit to satisfy git checks
+    Bun.spawnSync(["git", "add", "."], { cwd: projectDir });
+    Bun.spawnSync(["git", "commit", "-m", "init", "-q"], { cwd: projectDir });
+
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    const originalError = console.error;
+    const originalLog = console.log;
+    console.error = () => {}; // Suppress error output
+    console.log = () => {}; // Suppress check output
+
+    process.exit = ((code?: number) => {
+      exitCode = code;
+    }) as never;
+
+    try {
+      await precheckCommand({
+        feature: "test-feature",
+        dir: projectDir,
+        json: false,
+      });
+    } catch (err) {
+      // Expected
+    } finally {
+      process.exit = originalExit;
+      console.error = originalError;
+      console.log = originalLog;
+    }
+
+    expect(exitCode).toBe(EXIT_CODES.INVALID_PRD);
+  });
+
+  test("should exit with code 2 when prd.json is missing", async () => {
+    const { projectDir } = setupTestProject("test-missing-prd");
+
+    // Don't create prd.json
+
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    const originalError = console.error;
+    console.error = () => {}; // Suppress error output
+
+    process.exit = ((code?: number) => {
+      exitCode = code;
+    }) as never;
+
+    try {
+      await precheckCommand({
+        feature: "test-feature",
+        dir: projectDir,
+        json: false,
+      });
+    } catch (err) {
+      // Expected
+    } finally {
+      process.exit = originalExit;
+      console.error = originalError;
+    }
+
+    expect(exitCode).toBe(EXIT_CODES.INVALID_PRD);
+  });
+
+  test("should handle missing feature flag with error", async () => {
+    const { projectDir, naxDir } = setupTestProject("test-no-feature");
+
+    // Remove feature from config
+    await Bun.write(
+      join(naxDir, "config.json"),
+      JSON.stringify(
+        {
+          routing: { enabled: true },
+          quality: { test: { enabled: true } },
+        },
+        null,
+        2,
+      ),
+    );
+
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    const originalError = console.error;
+    console.error = () => {}; // Suppress error output
+
+    process.exit = ((code?: number) => {
+      exitCode = code;
+    }) as never;
+
+    try {
+      await precheckCommand({
+        dir: projectDir,
+        json: false,
+      });
+    } catch (err) {
+      // Expected
+    } finally {
+      process.exit = originalExit;
+      console.error = originalError;
+    }
+
+    expect(exitCode).toBe(1);
+  });
+
+  test("should use resolveProject() for directory resolution", async () => {
+    const { projectDir, prdPath } = setupTestProject("test-resolve-project");
+
+    // Write valid PRD
+    await Bun.write(prdPath, JSON.stringify(createValidPRD()));
+
+    // Commit to satisfy checks
+    Bun.spawnSync(["git", "add", "."], { cwd: projectDir });
+    Bun.spawnSync(["git", "commit", "-m", "init", "-q"], { cwd: projectDir });
+
+    let exitCode: number | undefined;
+    const originalExit = process.exit;
+    process.exit = ((code?: number) => {
+      exitCode = code;
+    }) as never;
+
+    try {
+      // Should resolve project from explicit -d flag
+      await precheckCommand({
+        feature: "test-feature",
+        dir: projectDir,
+        json: false,
+      });
+    } catch (err) {
+      // Expected
+    } finally {
+      process.exit = originalExit;
+    }
+
+    // Should succeed (or have blockers, but not fail to resolve)
+    expect(exitCode).toBeDefined();
+    expect(exitCode).not.toBe(undefined);
+  });
+});

package/test/integration/cli-run-headless.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Integration test for headless mode with formatter
+ *
+ * Verifies that `nax run` uses formatted output in headless mode
+ * instead of raw JSONL, while still writing JSONL to disk.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { initLogger, resetLogger } from "../../src/logger";
+
+describe("Headless mode formatter integration", () => {
+  const testDir = join(import.meta.dir, "..", "tmp", "headless-test");
+  const logFile = join(testDir, "test.jsonl");
+
+  beforeEach(() => {
+    // Clean up any existing logger
+    resetLogger();
+
+    // Create test directory
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    resetLogger();
+  });
+
+  test("logger uses formatter in headless mode with normal verbosity", async () => {
+    // Initialize logger in headless mode with normal verbosity
+    const logger = initLogger({
+      level: "info",
+      filePath: logFile,
+      useChalk: false, // Disable colors for test output
+      formatterMode: "normal",
+      headless: true,
+    });
+
+    // Capture console output
+    const originalLog = console.log;
+    const outputs: string[] = [];
+    console.log = (msg: string) => {
+      outputs.push(msg);
+    };
+
+    try {
+      // Log a test message
+      logger.info("test.stage", "Test message", { foo: "bar" });
+
+      // Verify console output uses formatter (not raw JSONL)
+      expect(outputs.length).toBeGreaterThan(0);
+      const output = outputs[0];
+
+      // Should NOT be raw JSON
+      expect(output.startsWith("{")).toBe(false);
+
+      // Should contain formatted elements
+      expect(output).toContain("test.stage");
+      expect(output).toContain("Test message");
+    } finally {
+      console.log = originalLog;
+    }
+
+    // Verify JSONL file was written
+    expect(existsSync(logFile)).toBe(true);
+    const fileContent = await Bun.file(logFile).text();
+    expect(fileContent).toContain('"stage":"test.stage"');
+    expect(fileContent).toContain('"message":"Test message"');
+  });
+
+  test("logger outputs raw JSONL in json mode", () => {
+    // Initialize logger in headless mode with json verbosity
+    const logger = initLogger({
+      level: "info",
+      filePath: logFile,
+      useChalk: false,
+      formatterMode: "json",
+      headless: true,
+    });
+
+    // Capture console output
+    const originalLog = console.log;
+    const outputs: string[] = [];
+    console.log = (msg: string) => {
+      outputs.push(msg);
+    };
+
+    try {
+      // Log a test message
+      logger.info("test.stage", "Test message", { foo: "bar" });
+
+      // Verify console output is raw JSONL
+      expect(outputs.length).toBe(1);
+      const output = outputs[0];
+
+      // Should be valid JSON
+      const parsed = JSON.parse(output);
+      expect(parsed.stage).toBe("test.stage");
+      expect(parsed.message).toBe("Test message");
+      expect(parsed.data.foo).toBe("bar");
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test("logger suppresses debug logs in quiet mode", () => {
+    // Initialize logger in quiet mode
+    const logger = initLogger({
+      level: "debug", // Log level allows everything through
+      filePath: logFile,
+      useChalk: false,
+      formatterMode: "quiet", // Formatter filters what's displayed
+      headless: true,
+    });
+
+    // Capture console output
+    const originalLog = console.log;
+    const outputs: string[] = [];
+    console.log = (msg: string) => {
+      outputs.push(msg);
+    };
+
+    try {
+      // Log debug and info messages
+      logger.debug("test.stage", "Debug message");
+      logger.info("test.stage", "Info message");
+
+      // In quiet mode, info logs should be filtered out
+      // (unless they're critical events like run.start/run.end)
+      expect(outputs.length).toBe(0);
+
+      // But errors should still show (reset outputs first)
+      outputs.length = 0;
+      logger.error("test.stage", "Error message");
+      expect(outputs.length).toBe(1);
+      expect(outputs[0]).toContain("Error message");
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  test("logger uses default console formatter when not in headless mode", () => {
+    // Initialize logger WITHOUT headless mode
+    const logger = initLogger({
+      level: "info",
+      filePath: logFile,
+      useChalk: false,
+      headless: false, // Not headless
+    });
+
+    // Capture console output
+    const originalLog = console.log;
+    const outputs: string[] = [];
+    console.log = (msg: string) => {
+      outputs.push(msg);
+    };
+
+    try {
+      // Log a test message
+      logger.info("test.stage", "Test message", { foo: "bar" });
+
+      // Verify console output uses default console formatter (not formatter)
+      expect(outputs.length).toBeGreaterThan(0);
+      const output = outputs[0];
+
+      // Default console format includes [timestamp] [stage] message
+      expect(output).toContain("[test.stage]");
+      expect(output).toContain("Test message");
+    } finally {
+      console.log = originalLog;
+    }
+  });
+});

package/test/integration/cli.test.ts

@@ -0,0 +1,75 @@
+/**
+ * CLI --parallel flag tests
+ *
+ * Validates that the --parallel flag is correctly parsed and passed to RunOptions.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { RunOptions } from "../../src/execution/runner";
+
+describe("CLI --parallel flag parsing", () => {
+  test("parses --parallel 4 correctly", () => {
+    // Simulate parsing --parallel 4
+    const parallelArg = "4";
+    const parallel = Number.parseInt(parallelArg, 10);
+
+    expect(parallel).toBe(4);
+    expect(Number.isNaN(parallel)).toBe(false);
+    expect(parallel).toBeGreaterThanOrEqual(0);
+  });
+
+  test("parses --parallel 0 (auto-detect mode) correctly", () => {
+    const parallelArg = "0";
+    const parallel = Number.parseInt(parallelArg, 10);
+
+    expect(parallel).toBe(0);
+    expect(Number.isNaN(parallel)).toBe(false);
+  });
+
+  test("omitted --parallel defaults to undefined (sequential)", () => {
+    // When flag is not provided, parallel should be undefined
+    const parallel: number | undefined = undefined;
+
+    expect(parallel).toBeUndefined();
+  });
+
+  test("rejects negative --parallel values", () => {
+    const parallelArg = "-1";
+    const parallel = Number.parseInt(parallelArg, 10);
+
+    expect(parallel).toBe(-1);
+    expect(parallel).toBeLessThan(0);
+  });
+
+  test("rejects non-numeric --parallel values", () => {
+    const parallelArg = "abc";
+    const parallel = Number.parseInt(parallelArg, 10);
+
+    expect(Number.isNaN(parallel)).toBe(true);
+  });
+
+  test("RunOptions accepts parallel field", () => {
+    // Type-check that RunOptions accepts parallel field
+    const options: Partial<RunOptions> = {
+      parallel: 4,
+    };
+
+    expect(options.parallel).toBe(4);
+  });
+
+  test("RunOptions accepts parallel=0 (auto-detect)", () => {
+    const options: Partial<RunOptions> = {
+      parallel: 0,
+    };
+
+    expect(options.parallel).toBe(0);
+  });
+
+  test("RunOptions accepts parallel=undefined (sequential)", () => {
+    const options: Partial<RunOptions> = {
+      parallel: undefined,
+    };
+
+    expect(options.parallel).toBeUndefined();
+  });
+});