@nathapp/nax 0.28.0 → 0.30.0

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

@@ -1,372 +0,0 @@
-// RE-ARCH: keep
-/**
- * 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/cli-run-headless.test.ts

@@ -1,174 +0,0 @@
-// RE-ARCH: keep
-/**
- * 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/cli.test.ts

@@ -1,76 +0,0 @@
-// RE-ARCH: keep
-/**
- * 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();
-  });
-});