@nathapp/nax 0.28.0 → 0.30.0

package/test/unit/prompts/loader.test.ts

@@ -1,355 +0,0 @@
-/**
- * loadOverride unit tests — PB-003
- *
- * Tests are expected to FAIL until src/prompts/loader.ts is implemented.
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { chmodSync, mkdirSync, mkdtempSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import type { NaxConfig } from "../../../src/config/types";
-import { loadOverride } from "../../../src/prompts/loader";
-import type { PromptRole } from "../../../src/prompts/types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Minimal NaxConfig with only required fields (omit optional ones) */
-function makeConfig(overrides: Partial<NaxConfig> = {}): NaxConfig {
-  return {
-    version: 1,
-    models: {
-      fast: { provider: "anthropic", model: "haiku" },
-      balanced: { provider: "anthropic", model: "sonnet" },
-      powerful: { provider: "anthropic", model: "opus" },
-    },
-    autoMode: {
-      enabled: true,
-      defaultAgent: "claude",
-      fallbackOrder: ["claude"],
-      complexityRouting: { simple: "fast", medium: "balanced", complex: "powerful", expert: "powerful" },
-      escalation: { enabled: true, tierOrder: [{ tier: "fast", attempts: 3 }] },
-    },
-    routing: { strategy: "keyword" },
-    execution: {
-      maxIterations: 10,
-      iterationDelayMs: 2000,
-      costLimit: 5,
-      sessionTimeoutSeconds: 600,
-      verificationTimeoutSeconds: 300,
-      maxStoriesPerFeature: 500,
-      rectification: {
-        enabled: true,
-        maxRetries: 2,
-        fullSuiteTimeoutSeconds: 120,
-        maxFailureSummaryChars: 2000,
-        abortOnIncreasingFailures: true,
-      },
-      regressionGate: { enabled: true, timeoutSeconds: 120 },
-      contextProviderTokenBudget: 2000,
-    },
-    quality: {
-      requireTypecheck: true,
-      requireLint: true,
-      requireTests: true,
-      commands: {},
-      forceExit: false,
-      detectOpenHandles: true,
-      detectOpenHandlesRetries: 1,
-      gracePeriodMs: 5000,
-      dangerouslySkipPermissions: true,
-      drainTimeoutMs: 2000,
-      shell: "/bin/sh",
-      stripEnvVars: [],
-      environmentalEscalationDivisor: 2,
-    },
-    tdd: {
-      maxRetries: 2,
-      autoVerifyIsolation: true,
-      strategy: "auto",
-      autoApproveVerifier: true,
-    },
-    constitution: { enabled: false, path: "constitution.md", maxTokens: 2000 },
-    analyze: { llmEnhanced: false, model: "balanced", fallbackToKeywords: true, maxCodebaseSummaryTokens: 5000 },
-    review: { enabled: false, checks: [], commands: {} },
-    plan: { model: "balanced", outputPath: "spec.md" },
-    acceptance: { enabled: false, maxRetries: 2, generateTests: false, testPath: "acceptance.test.ts" },
-    context: {
-      testCoverage: {
-        enabled: false,
-        detail: "names-only",
-        maxTokens: 500,
-        testPattern: "**/*.test.ts",
-        scopeToStory: false,
-      },
-      autoDetect: { enabled: false, maxFiles: 5, traceImports: false },
-    },
-    ...overrides,
-  } as NaxConfig;
-}
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-let tmpDir: string;
-let createdFiles: string[] = [];
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "nax-loader-test-"));
-  createdFiles = [];
-});
-
-afterEach(() => {
-  // Clean up any chmod'd files by restoring permissions first
-  for (const f of createdFiles) {
-    try {
-      chmodSync(f, 0o644);
-      unlinkSync(f);
-    } catch {
-      // best-effort
-    }
-  }
-  try {
-    rmdirSync(tmpDir, { recursive: true });
-  } catch {
-    // best-effort
-  }
-});
-
-function writeOverrideFile(relPath: string, content: string): string {
-  const abs = join(tmpDir, relPath);
-  mkdirSync(dirname(abs), { recursive: true });
-  writeFileSync(abs, content, "utf8");
-  createdFiles.push(abs);
-  return relPath; // return relative path for use in config
-}
-
-// ---------------------------------------------------------------------------
-// 1. Returns null when config.prompts is undefined
-// ---------------------------------------------------------------------------
-
-describe("loadOverride — config.prompts absent", () => {
-  test("returns null when config has no prompts block", async () => {
-    const config = makeConfig(); // no prompts field
-    const result = await loadOverride("test-writer", tmpDir, config);
-    expect(result).toBeNull();
-  });
-
-  test("returns null for every role when config.prompts is absent", async () => {
-    const config = makeConfig();
-    const roles: PromptRole[] = ["test-writer", "implementer", "verifier", "single-session"];
-    for (const role of roles) {
-      const result = await loadOverride(role, tmpDir, config);
-      expect(result).toBeNull();
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. Returns null when prompts.overrides has no key for the role
-// ---------------------------------------------------------------------------
-
-describe("loadOverride — role key absent in overrides", () => {
-  test("returns null when overrides map is empty", async () => {
-    const config = makeConfig({ prompts: { overrides: {} } });
-    const result = await loadOverride("implementer", tmpDir, config);
-    expect(result).toBeNull();
-  });
-
-  test("returns null when only other roles are configured", async () => {
-    const relPath = writeOverrideFile(".nax/prompts/implementer.md", "# Implementer");
-    const config = makeConfig({
-      prompts: { overrides: { implementer: relPath } },
-    });
-    // ask for test-writer — not configured
-    const result = await loadOverride("test-writer", tmpDir, config);
-    expect(result).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. Returns null when file path is set but file does not exist
-// ---------------------------------------------------------------------------
-
-describe("loadOverride — file missing", () => {
-  test("returns null when file at configured path does not exist", async () => {
-    const config = makeConfig({
-      prompts: { overrides: { "test-writer": ".nax/prompts/missing.md" } },
-    });
-    const result = await loadOverride("test-writer", tmpDir, config);
-    expect(result).toBeNull();
-  });
-
-  test("returns null for a deeply nested nonexistent path", async () => {
-    const config = makeConfig({
-      prompts: { overrides: { verifier: "deeply/nested/nonexistent/path/verifier.md" } },
-    });
-    const result = await loadOverride("verifier", tmpDir, config);
-    expect(result).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. Returns file content when file exists
-// ---------------------------------------------------------------------------
-
-describe("loadOverride — file exists", () => {
-  test("returns file content for test-writer", async () => {
-    const content = "# Test Writer Override\nWrite tests first.";
-    const relPath = writeOverrideFile(".nax/prompts/test-writer.md", content);
-    const config = makeConfig({ prompts: { overrides: { "test-writer": relPath } } });
-
-    const result = await loadOverride("test-writer", tmpDir, config);
-    expect(result).toBe(content);
-  });
-
-  test("returns file content for implementer", async () => {
-    const content = "# Implementer Override\nImplement the feature.";
-    const relPath = writeOverrideFile(".nax/prompts/implementer.md", content);
-    const config = makeConfig({ prompts: { overrides: { implementer: relPath } } });
-
-    const result = await loadOverride("implementer", tmpDir, config);
-    expect(result).toBe(content);
-  });
-
-  test("returns file content for verifier", async () => {
-    const content = "# Verifier Override\nVerify correctness.";
-    const relPath = writeOverrideFile(".nax/prompts/verifier.md", content);
-    const config = makeConfig({ prompts: { overrides: { verifier: relPath } } });
-
-    const result = await loadOverride("verifier", tmpDir, config);
-    expect(result).toBe(content);
-  });
-
-  test("returns file content for single-session", async () => {
-    const content = "# Single Session Override\nDo everything in one session.";
-    const relPath = writeOverrideFile(".nax/prompts/single-session.md", content);
-    const config = makeConfig({ prompts: { overrides: { "single-session": relPath } } });
-
-    const result = await loadOverride("single-session", tmpDir, config);
-    expect(result).toBe(content);
-  });
-
-  test("resolves path relative to workdir, not process.cwd()", async () => {
-    const content = "RELATIVE_PATH_CONTENT";
-    const relPath = writeOverrideFile("custom-override.md", content);
-    const config = makeConfig({ prompts: { overrides: { implementer: relPath } } });
-
-    // tmpDir is the workdir — file lives at join(tmpDir, relPath)
-    const result = await loadOverride("implementer", tmpDir, config);
-    expect(result).toBe(content);
-  });
-
-  test("reads multiline markdown correctly", async () => {
-    const content = "# Title\n\n## Section\n\nSome content here.\n\n- item 1\n- item 2\n";
-    const relPath = writeOverrideFile("multiline.md", content);
-    const config = makeConfig({ prompts: { overrides: { verifier: relPath } } });
-
-    const result = await loadOverride("verifier", tmpDir, config);
-    expect(result).toBe(content);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 5. Throws on unreadable file (permissions error)
-// ---------------------------------------------------------------------------
-
-describe("loadOverride — permission error", () => {
-  const skipOnCI = process.env.CI ? test.skip : test;
-
-  skipOnCI("throws a descriptive error when file is not readable", async () => {
-    const content = "SECRET";
-    const relPath = writeOverrideFile(".nax/prompts/locked.md", content);
-    const absPath = join(tmpDir, relPath);
-
-    // Remove read permission
-    chmodSync(absPath, 0o000);
-
-    const config = makeConfig({ prompts: { overrides: { "test-writer": relPath } } });
-
-    await expect(loadOverride("test-writer", tmpDir, config)).rejects.toThrow();
-  });
-
-  skipOnCI("error message mentions the role or path when unreadable", async () => {
-    const content = "SECRET";
-    const relPath = writeOverrideFile(".nax/prompts/locked2.md", content);
-    const absPath = join(tmpDir, relPath);
-
-    chmodSync(absPath, 0o000);
-
-    const config = makeConfig({ prompts: { overrides: { implementer: relPath } } });
-
-    let errorMessage = "";
-    try {
-      await loadOverride("implementer", tmpDir, config);
-    } catch (err) {
-      errorMessage = err instanceof Error ? err.message : String(err);
-    }
-
-    // Error should mention something meaningful (path or role)
-    expect(errorMessage.length).toBeGreaterThan(0);
-    const lowerMsg = errorMessage.toLowerCase();
-    const mentionsSomethingUseful =
-      lowerMsg.includes("locked2") ||
-      lowerMsg.includes("implementer") ||
-      lowerMsg.includes("unreadable") ||
-      lowerMsg.includes("permission") ||
-      lowerMsg.includes("cannot read") ||
-      lowerMsg.includes("eacces");
-    expect(mentionsSomethingUseful).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 6. Template stubs export defaultTemplate
-// ---------------------------------------------------------------------------
-
-describe("src/prompts/templates — default exports exist", () => {
-  test("test-writer template exports a string", async () => {
-    const mod = await import("../../../src/prompts/templates/test-writer");
-    expect(typeof mod.defaultTemplate).toBe("string");
-  });
-
-  test("implementer template exports a string", async () => {
-    const mod = await import("../../../src/prompts/templates/implementer");
-    expect(typeof mod.defaultTemplate).toBe("string");
-  });
-
-  test("verifier template exports a string", async () => {
-    const mod = await import("../../../src/prompts/templates/verifier");
-    expect(typeof mod.defaultTemplate).toBe("string");
-  });
-
-  test("single-session template exports a string", async () => {
-    const mod = await import("../../../src/prompts/templates/single-session");
-    expect(typeof mod.defaultTemplate).toBe("string");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 7. NaxConfig accepts prompts field
-// ---------------------------------------------------------------------------
-
-describe("NaxConfig.prompts type shape", () => {
-  test("config with prompts.overrides is accepted by makeConfig", () => {
-    // If TypeScript compiles this without error, the type is correct
-    const config = makeConfig({
-      prompts: {
-        overrides: {
-          "test-writer": ".nax/prompts/tw.md",
-          implementer: ".nax/prompts/impl.md",
-        },
-      },
-    });
-    expect(config.prompts?.overrides?.["test-writer"]).toBe(".nax/prompts/tw.md");
-    expect(config.prompts?.overrides?.implementer).toBe(".nax/prompts/impl.md");
-  });
-
-  test("config without prompts block compiles fine", () => {
-    const config = makeConfig();
-    expect(config.prompts).toBeUndefined();
-  });
-});

package/test/unit/prompts/sections/conventions.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildConventionsSection } from "../../../../src/prompts/sections/conventions";
-
-describe("buildConventionsSection", () => {
-  test("includes bun test scoping warning", () => {
-    const result = buildConventionsSection();
-    expect(result).toContain("bun test");
-  });
-
-  test("includes commit message instruction", () => {
-    const result = buildConventionsSection();
-    expect(result).toContain("commit");
-  });
-
-  test("includes context about test filtering", () => {
-    const result = buildConventionsSection();
-    expect(result).toContain("specific");
-  });
-
-  test("returns non-empty string", () => {
-    const result = buildConventionsSection();
-    expect(result.length).toBeGreaterThan(0);
-  });
-
-  test("is a pure function", () => {
-    const result1 = buildConventionsSection();
-    const result2 = buildConventionsSection();
-    expect(result1).toEqual(result2);
-  });
-});

package/test/unit/prompts/sections/isolation.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildIsolationSection } from "../../../../src/prompts/sections/isolation";
-
-describe("buildIsolationSection", () => {
-  test("strict mode forbids src/ modification", () => {
-    const result = buildIsolationSection("strict");
-    expect(result).toContain("Do NOT modify");
-    expect(result).toContain("src/");
-    expect(result).not.toContain("MAY read src/");
-  });
-
-  test("lite mode allows reading src/", () => {
-    const result = buildIsolationSection("lite");
-    expect(result).toContain("MAY read src/");
-  });
-
-  test("lite mode mentions stubs", () => {
-    const result = buildIsolationSection("lite");
-    expect(result).toContain("stub");
-  });
-
-  test("both modes include test filtering rule", () => {
-    const strictResult = buildIsolationSection("strict");
-    const liteResult = buildIsolationSection("lite");
-    expect(strictResult).toContain("bun test");
-    expect(liteResult).toContain("bun test");
-  });
-
-  test("returns non-empty string", () => {
-    const strict = buildIsolationSection("strict");
-    const lite = buildIsolationSection("lite");
-    expect(strict.length).toBeGreaterThan(0);
-    expect(lite.length).toBeGreaterThan(0);
-  });
-});

package/test/unit/prompts/sections/role-task.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildRoleTaskSection } from "../../../../src/prompts/sections/role-task";
-
-describe("buildRoleTaskSection", () => {
-  test("standard variant says 'make failing tests pass'", () => {
-    const result = buildRoleTaskSection("standard");
-    expect(result).toContain("make failing tests pass");
-  });
-
-  test("standard variant says 'Do NOT modify test files'", () => {
-    const result = buildRoleTaskSection("standard");
-    expect(result).toContain("Do NOT modify test files");
-  });
-
-  test("lite variant says 'Write tests first'", () => {
-    const result = buildRoleTaskSection("lite");
-    expect(result).toContain("Write tests first");
-  });
-
-  test("lite variant says 'implement'", () => {
-    const result = buildRoleTaskSection("lite");
-    expect(result).toContain("implement");
-  });
-
-  test("returns non-empty string for standard", () => {
-    const result = buildRoleTaskSection("standard");
-    expect(result.length).toBeGreaterThan(0);
-  });
-
-  test("returns non-empty string for lite", () => {
-    const result = buildRoleTaskSection("lite");
-    expect(result.length).toBeGreaterThan(0);
-  });
-
-  test("standard and lite have different content", () => {
-    const standard = buildRoleTaskSection("standard");
-    const lite = buildRoleTaskSection("lite");
-    expect(standard).not.toEqual(lite);
-  });
-});