@nathapp/nax 0.18.1

package/test/unit/commands/unlock.test.ts

@@ -0,0 +1,319 @@
+/**
+ * Unit tests for the nax unlock command
+ *
+ * Covers all acceptance criteria:
+ * AC1: No lock file -> prints 'No lock file found', exits 0
+ * AC2: Lock PID alive -> prints error, exits 1, lock untouched
+ * AC3: Lock PID dead -> prints lock info (PID, age), removes lock, exits 0
+ * AC4: --force -> removes lock unconditionally, exits 0
+ * AC5: -d <path> -> targets specified directory (not cwd)
+ * AC6: Unit coverage of all four scenarios
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { unlockCommand } from "../../../src/commands/unlock";
+
+// ---------------------------------------------------------------------------
+// Custom error to intercept process.exit without terminating the test runner
+// ---------------------------------------------------------------------------
+
+class ExitError extends Error {
+  constructor(public readonly code: number) {
+    super(`process.exit(${code})`);
+    this.name = "ExitError";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+async function writeLock(dir: string, pid: number, ageMs = 0): Promise<void> {
+  const lockData = { pid, timestamp: Date.now() - ageMs };
+  await Bun.write(join(dir, "nax.lock"), JSON.stringify(lockData));
+}
+
+// ---------------------------------------------------------------------------
+// Test suite
+// ---------------------------------------------------------------------------
+
+describe("unlockCommand", () => {
+  let testDir: string;
+  let capturedOutput: string[];
+  let capturedErrors: string[];
+  let exitCode: number | null;
+
+  const originalLog = console.log;
+  const originalError = console.error;
+  const originalExit = process.exit;
+
+  beforeEach(() => {
+    const raw = join(tmpdir(), `nax-unlock-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(raw, { recursive: true });
+    testDir = realpathSync(raw);
+
+    capturedOutput = [];
+    capturedErrors = [];
+    exitCode = null;
+
+    console.log = (...args: unknown[]) => {
+      capturedOutput.push(args.join(" "));
+    };
+    console.error = (...args: unknown[]) => {
+      capturedErrors.push(args.join(" "));
+    };
+
+    // Intercept process.exit: record the code and throw so the command stops.
+    process.exit = ((code?: number) => {
+      exitCode = code ?? 0;
+      throw new ExitError(exitCode);
+    }) as never;
+  });
+
+  afterEach(() => {
+    console.log = originalLog;
+    console.error = originalError;
+    process.exit = originalExit;
+
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  // Helper: run unlockCommand, absorbing ExitError but re-throwing other errors.
+  async function run(options: Parameters<typeof unlockCommand>[0]): Promise<void> {
+    try {
+      await unlockCommand(options);
+    } catch (err) {
+      if (!(err instanceof ExitError)) {
+        throw err;
+      }
+    }
+  }
+
+  function allOutput(): string {
+    return [...capturedOutput, ...capturedErrors].join("\n");
+  }
+
+  // =========================================================================
+  // AC1: No lock file present
+  // =========================================================================
+
+  describe("AC1: no lock file", () => {
+    test("prints 'No lock file found' and exits 0", async () => {
+      await run({ dir: testDir });
+
+      expect(allOutput()).toContain("No lock file found");
+      // exit 0 means either natural return (exitCode null) or explicit exit(0)
+      expect(exitCode === null || exitCode === 0).toBe(true);
+    });
+
+    test("does not create a lock file", async () => {
+      await run({ dir: testDir });
+
+      expect(existsSync(join(testDir, "nax.lock"))).toBe(false);
+    });
+  });
+
+  // =========================================================================
+  // AC2: Lock PID is alive — refuse to unlock
+  // =========================================================================
+
+  describe("AC2: lock PID is alive", () => {
+    test("prints 'nax is still running (PID <n>). Use --force to override.'", async () => {
+      // process.pid is the current test-runner process — always alive.
+      await writeLock(testDir, process.pid);
+
+      await run({ dir: testDir });
+
+      expect(allOutput()).toContain(`nax is still running (PID ${process.pid})`);
+      expect(allOutput()).toContain("--force");
+    });
+
+    test("exits with code 1", async () => {
+      await writeLock(testDir, process.pid);
+
+      await run({ dir: testDir });
+
+      expect(exitCode).toBe(1);
+    });
+
+    test("does NOT delete the lock file", async () => {
+      const lockPath = join(testDir, "nax.lock");
+      await writeLock(testDir, process.pid);
+
+      await run({ dir: testDir });
+
+      expect(existsSync(lockPath)).toBe(true);
+    });
+  });
+
+  // =========================================================================
+  // AC3: Lock PID is dead — unlock and clean up
+  // =========================================================================
+
+  describe("AC3: lock PID is dead", () => {
+    // PID 999999 is astronomically unlikely to exist on any real system.
+    const DEAD_PID = 999999;
+
+    test("prints lock info including PID before removing", async () => {
+      await writeLock(testDir, DEAD_PID, 5 * 60 * 1000); // 5 minutes old
+
+      await run({ dir: testDir });
+
+      expect(allOutput()).toContain(String(DEAD_PID));
+    });
+
+    test("prints lock age in minutes", async () => {
+      await writeLock(testDir, DEAD_PID, 5 * 60 * 1000); // 5 minutes old
+
+      await run({ dir: testDir });
+
+      // Output should mention age in minutes (e.g. "5 min" or "5 minutes")
+      expect(allOutput()).toMatch(/\d+\s*min/i);
+    });
+
+    test("removes nax.lock", async () => {
+      const lockPath = join(testDir, "nax.lock");
+      await writeLock(testDir, DEAD_PID);
+
+      await run({ dir: testDir });
+
+      expect(existsSync(lockPath)).toBe(false);
+    });
+
+    test("exits 0", async () => {
+      await writeLock(testDir, DEAD_PID);
+
+      await run({ dir: testDir });
+
+      expect(exitCode === null || exitCode === 0).toBe(true);
+    });
+  });
+
+  // =========================================================================
+  // AC4: --force flag — unconditional removal
+  // =========================================================================
+
+  describe("AC4: --force flag", () => {
+    test("removes lock even when PID is alive", async () => {
+      const lockPath = join(testDir, "nax.lock");
+      // process.pid is alive
+      await writeLock(testDir, process.pid);
+
+      await run({ dir: testDir, force: true });
+
+      expect(existsSync(lockPath)).toBe(false);
+    });
+
+    test("exits 0 when lock was held by a live PID", async () => {
+      await writeLock(testDir, process.pid);
+
+      await run({ dir: testDir, force: true });
+
+      expect(exitCode === null || exitCode === 0).toBe(true);
+    });
+
+    test("exits 0 when there is no lock file at all", async () => {
+      // No lock written — --force should still succeed gracefully
+      await run({ dir: testDir, force: true });
+
+      expect(exitCode === null || exitCode === 0).toBe(true);
+    });
+
+    test("does not print the 'still running' refusal message", async () => {
+      await writeLock(testDir, process.pid);
+
+      await run({ dir: testDir, force: true });
+
+      expect(allOutput()).not.toContain("nax is still running");
+    });
+  });
+
+  // =========================================================================
+  // AC5: -d <path> flag — target a specific directory
+  // =========================================================================
+
+  describe("AC5: -d <path> targets the specified directory", () => {
+    test("reads lock from the specified directory, not cwd", async () => {
+      const altDir = realpathSync(
+        (() => {
+          const d = join(tmpdir(), `nax-unlock-alt-${Date.now()}`);
+          mkdirSync(d, { recursive: true });
+          return d;
+        })(),
+      );
+
+      const DEAD_PID = 999999;
+      await writeLock(altDir, DEAD_PID);
+
+      const altLockPath = join(altDir, "nax.lock");
+      const testDirLockPath = join(testDir, "nax.lock");
+
+      await run({ dir: altDir });
+
+      // The lock in altDir must be removed
+      expect(existsSync(altLockPath)).toBe(false);
+      // The (absent) lock in testDir must remain absent
+      expect(existsSync(testDirLockPath)).toBe(false);
+
+      rmSync(altDir, { recursive: true, force: true });
+    });
+
+    test("ignores cwd when -d is provided and cwd has no lock", async () => {
+      // Put a lock ONLY in altDir; cwd (testDir) has no lock
+      const altDir = realpathSync(
+        (() => {
+          const d = join(tmpdir(), `nax-unlock-alt2-${Date.now()}`);
+          mkdirSync(d, { recursive: true });
+          return d;
+        })(),
+      );
+
+      // No lock in altDir either — just confirming it reads from altDir
+      await run({ dir: altDir });
+
+      // AC1 behaviour applies for the targeted dir (no lock file)
+      expect(allOutput()).toContain("No lock file found");
+
+      rmSync(altDir, { recursive: true, force: true });
+    });
+  });
+
+  // =========================================================================
+  // AC6: Scenario matrix — all four core cases covered by unit tests
+  //
+  // (Verified by the tests above; this block provides explicit proof that
+  // each scenario class is addressed.)
+  // =========================================================================
+
+  describe("AC6: all four scenario classes covered", () => {
+    const DEAD_PID = 999999;
+
+    test("scenario: no lock", async () => {
+      await run({ dir: testDir });
+      expect(allOutput()).toContain("No lock file found");
+    });
+
+    test("scenario: alive PID without --force", async () => {
+      await writeLock(testDir, process.pid);
+      await run({ dir: testDir });
+      expect(exitCode).toBe(1);
+    });
+
+    test("scenario: dead PID without --force", async () => {
+      await writeLock(testDir, DEAD_PID);
+      await run({ dir: testDir });
+      expect(existsSync(join(testDir, "nax.lock"))).toBe(false);
+    });
+
+    test("scenario: --force removes lock regardless of PID state", async () => {
+      await writeLock(testDir, process.pid);
+      await run({ dir: testDir, force: true });
+      expect(existsSync(join(testDir, "nax.lock"))).toBe(false);
+    });
+  });
+});

package/test/unit/constitution-generators.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Constitution Generators Tests
+ *
+ * Tests for generating agent-specific config files from constitution.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { aiderGenerator } from "../../src/constitution/generators/aider";
+import { claudeGenerator } from "../../src/constitution/generators/claude";
+import { cursorGenerator } from "../../src/constitution/generators/cursor";
+import { opencodeGenerator } from "../../src/constitution/generators/opencode";
+import type { ConstitutionContent } from "../../src/constitution/generators/types";
+import { windsurfGenerator } from "../../src/constitution/generators/windsurf";
+
+const sampleConstitution: ConstitutionContent = {
+	markdown: `# Project Constitution
+
+## Coding Standards
+- Follow TypeScript best practices
+- Use strict typing
+
+## Testing Requirements
+- 80% minimum coverage
+- Write tests first (TDD)
+
+## Architecture Rules
+- Single responsibility principle
+- Dependency injection
+`,
+	sections: {},
+};
+
+describe("Constitution Generators", () => {
+	describe("Claude Generator", () => {
+		test("should generate CLAUDE.md with correct format", () => {
+			const result = claudeGenerator.generate(sampleConstitution);
+
+			expect(result).toContain("# Project Constitution");
+			expect(result).toContain("auto-generated from `nax/constitution.md`");
+			expect(result).toContain("DO NOT EDIT MANUALLY");
+			expect(result).toContain("## Coding Standards");
+			expect(result).toContain("Follow TypeScript best practices");
+		});
+
+		test("should have correct output filename", () => {
+			expect(claudeGenerator.outputFile).toBe("CLAUDE.md");
+		});
+
+		test("should have correct generator name", () => {
+			expect(claudeGenerator.name).toBe("claude");
+		});
+	});
+
+	describe("OpenCode Generator", () => {
+		test("should generate AGENTS.md with correct format", () => {
+			const result = opencodeGenerator.generate(sampleConstitution);
+
+			expect(result).toContain("# Agent Instructions");
+			expect(result).toContain("auto-generated from `nax/constitution.md`");
+			expect(result).toContain("DO NOT EDIT MANUALLY");
+			expect(result).toContain("## Coding Standards");
+		});
+
+		test("should have correct output filename", () => {
+			expect(opencodeGenerator.outputFile).toBe("AGENTS.md");
+		});
+
+		test("should have correct generator name", () => {
+			expect(opencodeGenerator.name).toBe("opencode");
+		});
+	});
+
+	describe("Cursor Generator", () => {
+		test("should generate .cursorrules with correct format", () => {
+			const result = cursorGenerator.generate(sampleConstitution);
+
+			expect(result).toContain("# Project Rules");
+			expect(result).toContain("Auto-generated from nax/constitution.md");
+			expect(result).toContain("DO NOT EDIT MANUALLY");
+			expect(result).toContain("## Coding Standards");
+		});
+
+		test("should have correct output filename", () => {
+			expect(cursorGenerator.outputFile).toBe(".cursorrules");
+		});
+
+		test("should have correct generator name", () => {
+			expect(cursorGenerator.name).toBe("cursor");
+		});
+	});
+
+	describe("Windsurf Generator", () => {
+		test("should generate .windsurfrules with correct format", () => {
+			const result = windsurfGenerator.generate(sampleConstitution);
+
+			expect(result).toContain("# Windsurf Project Rules");
+			expect(result).toContain("Auto-generated from nax/constitution.md");
+			expect(result).toContain("DO NOT EDIT MANUALLY");
+			expect(result).toContain("## Coding Standards");
+		});
+
+		test("should have correct output filename", () => {
+			expect(windsurfGenerator.outputFile).toBe(".windsurfrules");
+		});
+
+		test("should have correct generator name", () => {
+			expect(windsurfGenerator.name).toBe("windsurf");
+		});
+	});
+
+	describe("Aider Generator", () => {
+		test("should generate .aider.conf.yml with correct YAML format", () => {
+			const result = aiderGenerator.generate(sampleConstitution);
+
+			expect(result).toContain("# Aider Configuration");
+			expect(result).toContain("# Auto-generated from nax/constitution.md");
+			expect(result).toContain("# DO NOT EDIT MANUALLY");
+			expect(result).toContain("instructions: |");
+			// Check YAML indentation
+			expect(result).toContain("  # Project Constitution");
+			expect(result).toContain("  ## Coding Standards");
+		});
+
+		test("should have correct output filename", () => {
+			expect(aiderGenerator.outputFile).toBe(".aider.conf.yml");
+		});
+
+		test("should have correct generator name", () => {
+			expect(aiderGenerator.name).toBe("aider");
+		});
+	});
+
+	describe("All Generators", () => {
+		test("should preserve original constitution content", () => {
+			const generators = [claudeGenerator, opencodeGenerator, cursorGenerator, windsurfGenerator, aiderGenerator];
+
+			for (const generator of generators) {
+				const result = generator.generate(sampleConstitution);
+				expect(result).toContain("Follow TypeScript best practices");
+				expect(result).toContain("80% minimum coverage");
+				expect(result).toContain("Single responsibility principle");
+			}
+		});
+
+		test("should handle empty constitution", () => {
+			const emptyConstitution: ConstitutionContent = {
+				markdown: "",
+				sections: {},
+			};
+
+			const generators = [claudeGenerator, opencodeGenerator, cursorGenerator, windsurfGenerator, aiderGenerator];
+
+			for (const generator of generators) {
+				const result = generator.generate(emptyConstitution);
+				// Should still have header
+				expect(result.length).toBeGreaterThan(0);
+			}
+		});
+	});
+});

package/test/unit/constitution.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Constitution system tests
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { estimateTokens, loadConstitution, truncateToTokens } from "../../src/constitution";
+import type { ConstitutionConfig } from "../../src/constitution";
+
+const TEST_DIR = join(import.meta.dir, ".tmp-constitution-test");
+
+beforeEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+  mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe("estimateTokens", () => {
+  test("estimates tokens using 1 token ≈ 3 chars", () => {
+    expect(estimateTokens("abc")).toBe(1); // 3 chars = 1 token
+    expect(estimateTokens("abcdef")).toBe(2); // 6 chars = 2 tokens
+    expect(estimateTokens("a".repeat(100))).toBe(34); // 100 chars = 34 tokens (rounded up)
+  });
+
+  test("handles empty string", () => {
+    expect(estimateTokens("")).toBe(0);
+  });
+
+  test("rounds up fractional tokens", () => {
+    expect(estimateTokens("ab")).toBe(1); // 2 chars = 0.67 tokens → rounds up to 1
+  });
+});
+
+describe("truncateToTokens", () => {
+  test("returns full text if within token limit", () => {
+    const text = "Hello world";
+    const result = truncateToTokens(text, 100);
+    expect(result).toBe(text);
+  });
+
+  test("truncates at word boundary", () => {
+    const text = "The quick brown fox jumps over the lazy dog";
+    const result = truncateToTokens(text, 5); // 5 tokens ≈ 15 chars
+    expect(result.length).toBeLessThanOrEqual(15);
+    expect(result).not.toContain("fox"); // Should stop before "fox"
+    // Result should be "The quick" which ends with a word character
+    expect(result.trim()).toBe("The quick");
+  });
+
+  test("truncates at newline boundary", () => {
+    const text = "Line 1\nLine 2\nLine 3\nLine 4";
+    const result = truncateToTokens(text, 3); // 3 tokens ≈ 9 chars
+    expect(result).toContain("Line 1");
+    expect(result).not.toContain("Line 3");
+  });
+
+  test("hard cuts if no word boundary found", () => {
+    const text = "a".repeat(100);
+    const result = truncateToTokens(text, 5); // 5 tokens ≈ 15 chars
+    expect(result.length).toBe(15);
+  });
+});
+
+describe("loadConstitution", () => {
+  test("returns null if disabled", async () => {
+    const config: ConstitutionConfig = {
+      enabled: false,
+      path: "constitution.md",
+      maxTokens: 2000,
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).toBeNull();
+  });
+
+  test("returns null if file doesn't exist", async () => {
+    const config: ConstitutionConfig = {
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 2000,
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).toBeNull();
+  });
+
+  test("returns null if file is empty", async () => {
+    const constitutionPath = join(TEST_DIR, "constitution.md");
+    await Bun.write(constitutionPath, "   \n\n  "); // Only whitespace
+
+    const config: ConstitutionConfig = {
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 2000,
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).toBeNull();
+  });
+
+  test("loads constitution without truncation", async () => {
+    const content = "# Project Constitution\n\nFollow these rules.";
+    const constitutionPath = join(TEST_DIR, "constitution.md");
+    await Bun.write(constitutionPath, content);
+
+    const config: ConstitutionConfig = {
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 2000,
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).not.toBeNull();
+    expect(result?.content).toBe(content);
+    expect(result?.tokens).toBe(estimateTokens(content));
+    expect(result?.truncated).toBe(false);
+    expect(result?.originalTokens).toBeUndefined();
+  });
+
+  test("truncates constitution if exceeds maxTokens", async () => {
+    const content = "A".repeat(300); // 300 chars = 100 tokens
+    const constitutionPath = join(TEST_DIR, "constitution.md");
+    await Bun.write(constitutionPath, content);
+
+    const config: ConstitutionConfig = {
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 50, // Only allow 50 tokens
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).not.toBeNull();
+    expect(result?.truncated).toBe(true);
+    expect(result?.tokens).toBeLessThanOrEqual(50);
+    expect(result?.originalTokens).toBe(100);
+    expect(result?.content.length).toBeLessThan(content.length);
+  });
+
+  test("loads from custom path", async () => {
+    const content = "# Custom Constitution";
+    const customPath = join(TEST_DIR, "custom-rules.md");
+    await Bun.write(customPath, content);
+
+    const config: ConstitutionConfig = {
+      enabled: true,
+      path: "custom-rules.md",
+      maxTokens: 2000,
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).not.toBeNull();
+    expect(result?.content).toBe(content);
+  });
+
+  test("handles large constitution with meaningful content", async () => {
+    const content = `# Project Constitution
+
+## Coding Standards
+- Use TypeScript strict mode
+- Follow ESLint rules
+- Write clear variable names
+
+## Testing
+- Write unit tests for all functions
+- Aim for 80%+ coverage
+- Use describe/test/expect pattern
+
+## Architecture
+- Keep functions small (<50 lines)
+- Use dependency injection
+- Follow SOLID principles
+
+## Forbidden Patterns
+- No any types
+- No console.log
+- No hardcoded secrets
+`;
+
+    const constitutionPath = join(TEST_DIR, "constitution.md");
+    await Bun.write(constitutionPath, content);
+
+    const config: ConstitutionConfig = {
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 2000,
+      skipGlobal: true,
+    };
+
+    const result = await loadConstitution(TEST_DIR, config);
+    expect(result).not.toBeNull();
+    expect(result?.content).toBe(content);
+    expect(result?.truncated).toBe(false);
+    expect(result?.tokens).toBeGreaterThan(0);
+  });
+});