vigiles 2.0.0

package/dist/cli.test.js

@@ -0,0 +1,650 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * CLI integration tests — spawn the actual vigiles CLI and verify output.
+ *
+ * These test the full flow: CLI → init/compile/audit → filesystem output.
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const CLI = (0, node_path_1.resolve)(__dirname, "..", "dist", "cli.js");
+function run(args, cwd) {
+    try {
+        const stdout = (0, node_child_process_1.execSync)(`node ${CLI} ${args}`, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 30000,
+        });
+        return { stdout, stderr: "", exitCode: 0 };
+    }
+    catch (e) {
+        const err = e;
+        return {
+            stdout: err.stdout ?? "",
+            stderr: err.stderr ?? "",
+            exitCode: err.status ?? 1,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// vigiles init
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("CLI: vigiles init", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-cli-init-"));
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should create CLAUDE.md.spec.ts by default", () => {
+        const { stdout, exitCode } = run("init", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("Created CLAUDE.md.spec.ts"));
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md.spec.ts")));
+    });
+    (0, node_test_1.it)("should not overwrite existing spec", () => {
+        // Already created in previous test
+        const { stdout } = run("init", tmpDir);
+        strict_1.default.ok(stdout.includes("already exists"));
+    });
+    (0, node_test_1.it)("should create AGENTS.md.spec.ts with --target flag", () => {
+        const { stdout, exitCode } = run("init --target=AGENTS.md", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("Created AGENTS.md.spec.ts"));
+        const content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(tmpDir, "AGENTS.md.spec.ts"), "utf-8");
+        strict_1.default.ok(content.includes('target: "AGENTS.md"'));
+    });
+    (0, node_test_1.it)("should create custom target spec", () => {
+        const { exitCode } = run("init --target=CODEX.md", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "CODEX.md.spec.ts")));
+        const content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(tmpDir, "CODEX.md.spec.ts"), "utf-8");
+        strict_1.default.ok(content.includes('target: "CODEX.md"'));
+    });
+});
+// ---------------------------------------------------------------------------
+// vigiles compile
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("CLI: vigiles compile", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-cli-compile-"));
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should report when no specs are found", () => {
+        const { stdout, exitCode } = run("compile", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("No .spec.ts files found"));
+    });
+    (0, node_test_1.it)("should compile a spec", () => {
+        const tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-compile-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { test: "echo ok" } }));
+        const specSrc = (0, node_path_1.resolve)(process.cwd(), "dist", "spec.js");
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${specSrc}";\nexport default claude({ rules: { r: guidance("test") } });\n`);
+        const { stdout, exitCode } = run("compile CLAUDE.md.spec.ts", tmpDir);
+        strict_1.default.equal(exitCode, 0, stdout);
+        strict_1.default.ok(stdout.includes("CLAUDE.md.spec.ts"));
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should compile subdirectory spec to same directory", () => {
+        const tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-compile-subdir-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { test: "echo ok" } }));
+        const subDir = (0, node_path_1.join)(tmpDir, "examples");
+        (0, node_fs_1.mkdirSync)(subDir);
+        const specSrc = (0, node_path_1.resolve)(process.cwd(), "dist", "spec.js");
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(subDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${specSrc}";\nexport default claude({ rules: { r: guidance("test") } });\n`);
+        const { stdout, exitCode } = run("compile examples/CLAUDE.md.spec.ts", tmpDir);
+        strict_1.default.equal(exitCode, 0, stdout);
+        // Output should be in examples/, not root
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(subDir, "CLAUDE.md")), "Expected examples/CLAUDE.md to exist");
+        strict_1.default.ok(!(0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md")), "Root CLAUDE.md should NOT exist — spec in subdirectory must write to same directory");
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should not clobber root spec output when compiling all specs", () => {
+        const tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-compile-noclobber-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { test: "echo ok" } }));
+        const specSrc = (0, node_path_1.resolve)(process.cwd(), "dist", "spec.js");
+        // Root spec
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${specSrc}";\nexport default claude({ rules: { "root-rule": guidance("from root") } });\n`);
+        // Subdirectory spec
+        const subDir = (0, node_path_1.join)(tmpDir, "examples");
+        (0, node_fs_1.mkdirSync)(subDir);
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(subDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${specSrc}";\nexport default claude({ rules: { "sub-rule": guidance("from subdir") } });\n`);
+        const { stdout, exitCode } = run("compile", tmpDir);
+        strict_1.default.equal(exitCode, 0, stdout);
+        // Root CLAUDE.md should come from root spec
+        const rootMd = (0, node_fs_1.readFileSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md"), "utf-8");
+        strict_1.default.ok(rootMd.includes("from root"), "Root CLAUDE.md should contain root spec content");
+        strict_1.default.ok(!rootMd.includes("from subdir"), "Root CLAUDE.md must not be overwritten by subdirectory spec");
+        // Subdirectory CLAUDE.md should come from subdirectory spec
+        const subMd = (0, node_fs_1.readFileSync)((0, node_path_1.join)(subDir, "CLAUDE.md"), "utf-8");
+        strict_1.default.ok(subMd.includes("from subdir"), "examples/CLAUDE.md should contain subdirectory spec content");
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+});
+// ---------------------------------------------------------------------------
+// vigiles audit
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("CLI: vigiles audit", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-cli-audit-"));
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should report when no instruction files are found", () => {
+        const { stdout, exitCode } = run("audit", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("No compiled instruction files found"));
+    });
+    (0, node_test_1.it)("should include coverage and strengthen output", () => {
+        const { stdout } = run("audit", tmpDir);
+        // audit runs discover + strengthen in addition to verification
+        strict_1.default.ok(stdout.includes("coverage") ||
+            stdout.includes("Linter") ||
+            stdout.includes("No .spec.ts"));
+    });
+    (0, node_test_1.it)("should detect duplicate rules via NCD", () => {
+        const dupDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-audit-dup-"));
+        try {
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dupDir, "package.json"), JSON.stringify({ name: "test", scripts: {} }));
+            const specSrc = (0, node_path_1.resolve)(process.cwd(), "dist", "spec.js");
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dupDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${specSrc}";
+export default claude({
+  rules: {
+    "use-logger": guidance("Always use the structured logger instead of console.log for production output."),
+    "logger-over-console": guidance("Use the structured logger instead of console.log in production code."),
+    "unrelated": guidance("Prefer composition over inheritance in class hierarchies."),
+  },
+});
+`);
+            const { stdout } = run("audit", dupDir);
+            // Should detect the two logger rules as near-duplicates
+            strict_1.default.ok(stdout.includes("near-duplicate") || stdout.includes("duplicate"), `Expected duplicate detection, got: ${stdout.slice(0, 500)}`);
+        }
+        finally {
+            (0, node_fs_1.rmSync)(dupDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)("should skip inline verification for spec-managed files", () => {
+        // A file with a sibling .spec.ts (and compiled-from header) must
+        // not run inline verification, so literal vigiles:enforce snippets
+        // in prose cannot trip audit when the file is spec-managed.
+        // We use a sibling-.spec.ts with the spec snippet embedded as a
+        // prose section — compile generates the valid hash, then audit
+        // must ignore the inline marker in the output.
+        const specDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-audit-spec-skip-"));
+        try {
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(specDir, "package.json"), JSON.stringify({ name: "test", scripts: {} }));
+            const specSrc = (0, node_path_1.resolve)(process.cwd(), "dist", "spec.js");
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(specDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${specSrc}";
+export default claude({
+  sections: {
+    // A literal enforce marker embedded in prose — would be picked
+    // up as an inline rule if audit didn't skip spec-managed files.
+    example: 'Example: <!-- vigiles:enforce eslint/total-nonsense "prose" -->',
+  },
+  rules: {
+    "some-rule": guidance("Something."),
+  },
+});
+`);
+            // Compile first so CLAUDE.md has a valid hash.
+            const compileResult = run("compile", specDir);
+            strict_1.default.equal(compileResult.exitCode, 0, `compile failed: ${compileResult.stdout}`);
+            const { stdout, exitCode } = run("audit CLAUDE.md", specDir);
+            // Should NOT surface the bogus rule as an inline error.
+            strict_1.default.ok(!stdout.includes("total-nonsense"), `Spec-managed file should skip inline verification, got: ${stdout.slice(0, 800)}`);
+            // And should not have exited with the hard-error code.
+            strict_1.default.notEqual(exitCode, 2, `Expected no inline errors, got exit ${String(exitCode)}: ${stdout.slice(0, 600)}`);
+        }
+        finally {
+            (0, node_fs_1.rmSync)(specDir, { recursive: true, force: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Inline mode E2E
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("E2E: inline enforcement", () => {
+    let inlineDir;
+    (0, node_test_1.before)(() => {
+        inlineDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-inline-e2e-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "package.json"), JSON.stringify({ name: "test-inline", scripts: {} }));
+        // Symlink node_modules so checkLinterRule can find ESLint
+        // when the spawned CLI runs with cwd=inlineDir.
+        (0, node_fs_1.symlinkSync)((0, node_path_1.resolve)(process.cwd(), "node_modules"), (0, node_path_1.join)(inlineDir, "node_modules"));
+        // Also copy eslint config so the config checker can resolve rules
+        const eslintConfig = (0, node_path_1.resolve)(process.cwd(), "eslint.config.ts");
+        if ((0, node_fs_1.existsSync)(eslintConfig)) {
+            (0, node_fs_1.copyFileSync)(eslintConfig, (0, node_path_1.join)(inlineDir, "eslint.config.ts"));
+        }
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(inlineDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("verifies valid inline enforce rules and exits clean", () => {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "CLAUDE.md"), `# Project
+
+<!-- vigiles:enforce eslint/no-console "Use structured logger" -->
+
+All output goes through logger.ts.
+`);
+        const { stdout, exitCode } = run("audit CLAUDE.md", inlineDir);
+        strict_1.default.ok(stdout.includes("eslint/no-console"), `Expected rule in output, got: ${stdout.slice(0, 600)}`);
+        // Exit code 0 means no hard errors (inline rule is valid)
+        strict_1.default.equal(exitCode, 0, `Expected clean exit, got ${String(exitCode)}`);
+    });
+    (0, node_test_1.it)("flags a typo'd inline rule with a closest-match suggestion", () => {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "CLAUDE.md"), `# Project
+
+<!-- vigiles:enforce eslint/no-consol "Typo check" -->
+
+Some prose.
+`);
+        const { stdout, exitCode } = run("audit CLAUDE.md", inlineDir);
+        strict_1.default.ok(stdout.includes("no-consol"), `Expected typo'd rule in output, got: ${stdout.slice(0, 600)}`);
+        strict_1.default.ok(stdout.includes("Did you mean"), `Expected closest-match suggestion, got: ${stdout.slice(0, 600)}`);
+        strict_1.default.equal(exitCode, 2, `Expected exit 2 on inline error`);
+    });
+    (0, node_test_1.it)("ignores inline markers inside fenced code blocks", () => {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "CLAUDE.md"), `# Docs
+
+Example usage:
+
+\`\`\`md
+<!-- vigiles:enforce eslint/totally-bogus "inside fence" -->
+\`\`\`
+
+Real rule:
+
+<!-- vigiles:enforce eslint/no-console "outside fence" -->
+`);
+        const { stdout, exitCode } = run("audit CLAUDE.md", inlineDir);
+        // The bogus rule inside the fence must NOT appear as an error
+        strict_1.default.ok(!stdout.includes("totally-bogus"), `Fenced marker should be skipped, got: ${stdout.slice(0, 600)}`);
+        strict_1.default.ok(stdout.includes("no-console"), `Real rule should be verified, got: ${stdout.slice(0, 600)}`);
+        strict_1.default.equal(exitCode, 0);
+    });
+    (0, node_test_1.it)("reports inline errors in --json output", () => {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "CLAUDE.md"), `<!-- vigiles:enforce eslint/fake-rule-xyz "bad" -->`);
+        const { stdout, exitCode } = run("audit --json CLAUDE.md", inlineDir);
+        const report = JSON.parse(stdout);
+        strict_1.default.ok(report.inlineErrors > 0, "Expected inlineErrors > 0");
+        strict_1.default.ok(report.inlineRules > 0, "Expected inlineRules > 0");
+        strict_1.default.equal(exitCode, 2);
+    });
+    (0, node_test_1.it)("reports inline rules in --summary output", () => {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "CLAUDE.md"), `<!-- vigiles:enforce eslint/fake-rule-xyz "bad" -->`);
+        const { stdout, exitCode } = run("audit --summary CLAUDE.md", inlineDir);
+        strict_1.default.ok(stdout.includes("inline"), `Expected 'inline' in summary, got: ${stdout}`);
+        strict_1.default.equal(exitCode, 2);
+    });
+    (0, node_test_1.it)("satisfies require-spec when inline rules are present", () => {
+        // A file with inline rules but no .spec.ts should NOT trigger
+        // the require-spec validation warning.
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(inlineDir, "CLAUDE.md"), `<!-- vigiles:enforce eslint/no-console "valid" -->
+
+# Project
+`);
+        const { stdout } = run("audit CLAUDE.md", inlineDir);
+        strict_1.default.ok(!stdout.includes("require-spec"), `require-spec should be satisfied by inline rules, got: ${stdout.slice(0, 600)}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// vigiles generate-types
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("CLI: vigiles generate-types", () => {
+    (0, node_test_1.it)("should generate types", () => {
+        const tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-gen-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { build: "echo ok" } }));
+        const { stdout, exitCode } = run("generate-types", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("Generated"));
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should verify freshness with --check", () => {
+        // Use a temp dir so we don't modify the project's generated types
+        const tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-types-check-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { test: "echo ok" } }));
+        // Generate types in temp dir
+        run("generate-types", tmpDir);
+        // Then check — should pass
+        const { exitCode } = run("generate-types --check", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+});
+// ---------------------------------------------------------------------------
+// Multi-target compilation
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("CLI: multi-target compile", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-cli-multi-"));
+        // Create a spec with multiple targets
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md.spec.ts"), `import { claude, guidance } from "${(0, node_path_1.resolve)(process.cwd(), "src/spec.js")}";
+export default claude({
+  target: ["CLAUDE.md", "AGENTS.md"],
+  rules: {
+    "test-rule": guidance("Test guidance."),
+  },
+});
+`);
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should compile to multiple targets", () => {
+        const { stdout, exitCode } = run("compile CLAUDE.md.spec.ts", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("CLAUDE.md"));
+        strict_1.default.ok(stdout.includes("AGENTS.md"));
+        // Both files should exist
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md")));
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "AGENTS.md")));
+        // Primary has CLAUDE.md heading
+        const claude = (0, node_fs_1.readFileSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md"), "utf-8");
+        strict_1.default.ok(claude.includes("# CLAUDE.md"));
+        // Secondary has AGENTS.md heading
+        const agents = (0, node_fs_1.readFileSync)((0, node_path_1.join)(tmpDir, "AGENTS.md"), "utf-8");
+        strict_1.default.ok(agents.includes("# AGENTS.md"));
+    });
+});
+// ---------------------------------------------------------------------------
+// vigiles strengthen
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// vigiles init (was: vigiles setup)
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("CLI: vigiles init (full setup)", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-cli-setup-"));
+        // Need a package.json for generate-types
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { test: "echo ok" } }));
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should create spec, generate types, and compile", () => {
+        const { stdout, exitCode } = run("init", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("Created CLAUDE.md.spec.ts"));
+        strict_1.default.ok(stdout.includes("Setup complete"));
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md.spec.ts")));
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, ".vigiles/generated.d.ts")));
+    });
+    (0, node_test_1.it)("should support --target flag", () => {
+        const { stdout, exitCode } = run("init --target=AGENTS.md", tmpDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok(stdout.includes("AGENTS.md.spec.ts"));
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(tmpDir, "AGENTS.md.spec.ts")));
+    });
+});
+(0, node_test_1.describe)("CLI: vigiles init auto-detection", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-cli-detect-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "package.json"), JSON.stringify({ name: "test", scripts: { test: "echo ok" } }));
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should detect existing CLAUDE.md and suggest migration", () => {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(tmpDir, "CLAUDE.md"), "# Hand-written\n");
+        const { stdout } = run("init", tmpDir);
+        strict_1.default.ok(stdout.includes("without a spec") || stdout.includes("migrate"));
+    });
+    (0, node_test_1.it)("should detect .cursorrules and suggest sync tool", () => {
+        const dir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-detect-cursor-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "package.json"), JSON.stringify({ name: "test", scripts: {} }));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, ".cursorrules"), "Use TypeScript.\n");
+        const { stdout } = run("init", dir);
+        strict_1.default.ok(stdout.includes("Cursor") || stdout.includes("Non-markdown"));
+        (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should detect .claude directory as Claude Code project", () => {
+        const dir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-detect-claude-"));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "package.json"), JSON.stringify({ name: "test", scripts: {} }));
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, ".claude"), { recursive: true });
+        const { stdout } = run("init", dir);
+        strict_1.default.ok(stdout.includes("Claude Code"));
+        (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    });
+});
+// ---------------------------------------------------------------------------
+// Pre-edit hook (blocks compiled file edits)
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("plugin hook: pre-edit.sh", () => {
+    let tmpDir;
+    (0, node_test_1.before)(() => {
+        tmpDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-pre-edit-"));
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("should be executable with valid bash syntax", () => {
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/pre-edit.sh");
+        strict_1.default.ok((0, node_fs_1.existsSync)(hookPath));
+        (0, node_child_process_1.execSync)(`bash -n ${hookPath}`, { stdio: "pipe" });
+    });
+    (0, node_test_1.it)("should exit 0 for non-md files", () => {
+        const input = JSON.stringify({
+            tool_input: { file_path: (0, node_path_1.join)(tmpDir, "src/app.ts") },
+        });
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/pre-edit.sh");
+        (0, node_child_process_1.execSync)(`echo '${input}' | bash ${hookPath}`, {
+            cwd: tmpDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Should exit 0 (no block)
+        strict_1.default.ok(true);
+    });
+    (0, node_test_1.it)("should exit 2 for compiled md files", () => {
+        // Create a compiled .md file with vigiles hash
+        const mdPath = (0, node_path_1.join)(tmpDir, "CLAUDE.md");
+        (0, node_fs_1.writeFileSync)(mdPath, "<!-- vigiles:sha256:abc123 compiled from CLAUDE.md.spec.ts -->\n# CLAUDE.md\n");
+        const input = JSON.stringify({ tool_input: { file_path: mdPath } });
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/pre-edit.sh");
+        try {
+            (0, node_child_process_1.execSync)(`echo '${input}' | bash ${hookPath}`, {
+                cwd: tmpDir,
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            strict_1.default.fail("Should have exited with code 2");
+        }
+        catch (e) {
+            const err = e;
+            strict_1.default.equal(err.status, 2);
+            const stderr = err.stderr ?? "";
+            strict_1.default.ok(stderr.includes("CLAUDE.md.spec.ts"), "Should mention the spec file");
+            strict_1.default.ok(stderr.includes("BLOCKED"), "Should clearly indicate the action was blocked");
+            strict_1.default.ok(stderr.includes("edit-spec"), "Should reference the edit-spec skill");
+        }
+    });
+    (0, node_test_1.it)("should exit 0 for non-compiled md files", () => {
+        const mdPath = (0, node_path_1.join)(tmpDir, "HANDWRITTEN.md");
+        (0, node_fs_1.writeFileSync)(mdPath, "# Hand-written\n\nNo vigiles hash.\n");
+        const input = JSON.stringify({ tool_input: { file_path: mdPath } });
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/pre-edit.sh");
+        (0, node_child_process_1.execSync)(`echo '${input}' | bash ${hookPath}`, {
+            cwd: tmpDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Should exit 0 (no block)
+        strict_1.default.ok(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Plugin hook: post-edit
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("plugin hook: post-edit.sh", () => {
+    (0, node_test_1.it)("should be executable", () => {
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/post-edit.sh");
+        strict_1.default.ok((0, node_fs_1.existsSync)(hookPath));
+        // Check it's parseable bash
+        try {
+            (0, node_child_process_1.execSync)(`bash -n ${hookPath}`, { stdio: "pipe" });
+        }
+        catch {
+            strict_1.default.fail("post-edit.sh has syntax errors");
+        }
+    });
+    (0, node_test_1.it)("should exit cleanly with empty input", () => {
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/post-edit.sh");
+        try {
+            (0, node_child_process_1.execSync)(`echo '{}' | bash ${hookPath}`, {
+                cwd: process.cwd(),
+                stdio: "pipe",
+                timeout: 5000,
+            });
+        }
+        catch {
+            // Non-zero exit is ok — jq might fail on empty. Just shouldn't hang.
+        }
+    });
+    (0, node_test_1.it)("should match linter config files for type regeneration", () => {
+        // Test the case pattern matching by running a dry-run variant:
+        // Override npx to just echo, check the routing logic works.
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/post-edit.sh");
+        const configFiles = [
+            "eslint.config.mjs",
+            ".eslintrc.json",
+            "pyproject.toml",
+            "Cargo.toml",
+            "package.json",
+            ".stylelintrc.json",
+            ".rubocop.yml",
+        ];
+        for (const filename of configFiles) {
+            const input = JSON.stringify({
+                tool_input: { file_path: `/tmp/${filename}` },
+            });
+            // The hook should match these files — we can't easily verify it runs
+            // generate-types without mocking npx, but we can verify it doesn't crash.
+            try {
+                (0, node_child_process_1.execSync)(`echo '${input}' | bash ${hookPath}`, {
+                    cwd: process.cwd(),
+                    encoding: "utf-8",
+                    stdio: ["pipe", "pipe", "pipe"],
+                    timeout: 5000,
+                    env: { ...process.env, PATH: "/nonexistent" }, // npx won't be found, but routing still works
+                });
+            }
+            catch {
+                // Expected: npx not in PATH or vigiles not available in /tmp.
+                // The important thing is the script didn't error on the case match.
+            }
+        }
+        strict_1.default.ok(true, "All config files processed without crash");
+    });
+    (0, node_test_1.it)("should match .spec.ts files for compilation", () => {
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/post-edit.sh");
+        const input = JSON.stringify({
+            tool_input: { file_path: "/tmp/CLAUDE.md.spec.ts" },
+        });
+        try {
+            (0, node_child_process_1.execSync)(`echo '${input}' | bash ${hookPath}`, {
+                cwd: process.cwd(),
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 5000,
+                env: { ...process.env, PATH: "/nonexistent" },
+            });
+        }
+        catch {
+            // Expected: npx not found. Routing logic still works.
+        }
+        strict_1.default.ok(true, ".spec.ts file processed without crash");
+    });
+    (0, node_test_1.it)("should not trigger for unrelated files", () => {
+        const hookPath = (0, node_path_1.resolve)(process.cwd(), ".claude-plugin/hooks/post-edit.sh");
+        const input = JSON.stringify({
+            tool_input: { file_path: "/tmp/src/app.ts" },
+        });
+        // Should exit 0 quickly — no case match, no npx call.
+        (0, node_child_process_1.execSync)(`echo '${input}' | bash ${hookPath}`, {
+            cwd: process.cwd(),
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 5000,
+        });
+        strict_1.default.ok(true, "Unrelated file skipped without triggering any action");
+    });
+});
+// ---------------------------------------------------------------------------
+// E2E: fixture project — full adoption flow
+// ---------------------------------------------------------------------------
+(0, node_test_1.describe)("E2E: fixture project adoption", () => {
+    const FIXTURE = (0, node_path_1.resolve)(__dirname, "..", "fixtures", "example-project");
+    let workDir;
+    (0, node_test_1.before)(() => {
+        // Copy fixture to a temp dir so tests don't pollute it
+        workDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-e2e-"));
+        (0, node_child_process_1.execSync)(`cp -r ${FIXTURE}/* ${workDir}/`, { stdio: "pipe" });
+    });
+    (0, node_test_1.after)(() => {
+        (0, node_fs_1.rmSync)(workDir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("setup detects existing hand-written CLAUDE.md", () => {
+        const { stdout } = run("init", workDir);
+        // Should detect CLAUDE.md without spec and suggest migration
+        strict_1.default.ok(stdout.includes("without a spec") || stdout.includes("migrate"), "Should detect hand-written CLAUDE.md");
+    });
+    (0, node_test_1.it)("audit detects CLAUDE.md has no vigiles hash", () => {
+        const { stdout } = run("audit", workDir);
+        // Hand-written CLAUDE.md has no hash — should report it
+        strict_1.default.ok(stdout.includes("no vigiles hash") ||
+            stdout.includes("require-spec") ||
+            stdout.includes("Verifying"));
+    });
+    (0, node_test_1.it)("generate-types works in fixture project", () => {
+        const { exitCode } = run("generate-types", workDir);
+        strict_1.default.equal(exitCode, 0);
+        strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.join)(workDir, ".vigiles/generated.d.ts")));
+    });
+    (0, node_test_1.it)("full flow: write spec → compile → audit passes", () => {
+        // Clean slate: remove any existing CLAUDE.md and spec
+        const mdPath = (0, node_path_1.join)(workDir, "CLAUDE.md");
+        const specPath = (0, node_path_1.join)(workDir, "CLAUDE.md.spec.ts");
+        if ((0, node_fs_1.existsSync)(mdPath))
+            (0, node_fs_1.rmSync)(mdPath);
+        if ((0, node_fs_1.existsSync)(specPath))
+            (0, node_fs_1.rmSync)(specPath);
+        // Write a spec that imports from vigiles dist (not node_modules)
+        const specSrc = (0, node_path_1.resolve)(process.cwd(), "dist", "spec.js");
+        (0, node_fs_1.writeFileSync)(specPath, `import { claude, guidance } from "${specSrc}";
+export default claude({
+  commands: { "npm test": "Run tests" },
+  rules: { "be-nice": guidance("Be nice.") },
+});
+`);
+        // Compile
+        const compileResult = run("compile CLAUDE.md.spec.ts", workDir);
+        strict_1.default.equal(compileResult.exitCode, 0, compileResult.stdout);
+        strict_1.default.ok((0, node_fs_1.existsSync)(mdPath));
+        // Compiled file should have vigiles hash
+        const content = (0, node_fs_1.readFileSync)(mdPath, "utf-8");
+        strict_1.default.ok(content.includes("<!-- vigiles:sha256:"));
+        // Audit should pass (hash valid, spec exists)
+        const auditResult = run("audit", workDir);
+        strict_1.default.ok(auditResult.stdout.includes("hash valid") || auditResult.exitCode === 0);
+    });
+});
+//# sourceMappingURL=cli.test.js.map