@rigour-labs/cli 6.7.10 → 6.8.1-rc.1

package/dist/commands/hooks.test.js

@@ -1,247 +0,0 @@
-/**
- * Tests for hooks init command.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { hooksInitCommand, hooksCheckCommand, parseStdinFiles } from './hooks.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import yaml from 'yaml';
-vi.mock('@rigour-labs/core', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        recordInteractionEvidence: vi.fn().mockResolvedValue(undefined),
-        updateAutomaticIndexForFiles: vi.fn().mockResolvedValue(undefined),
-    };
-});
-describe('hooksInitCommand', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
-        // Write minimal rigour.yml
-        fs.writeFileSync(path.join(testDir, 'rigour.yml'), yaml.stringify({
-            version: 1,
-            gates: { max_file_lines: 500 },
-        }));
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('should generate Claude hooks', async () => {
-        await hooksInitCommand(testDir, { tool: 'claude' });
-        const settingsPath = path.join(testDir, '.claude', 'settings.json');
-        expect(fs.existsSync(settingsPath)).toBe(true);
-        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        expect(settings.hooks).toBeDefined();
-        expect(settings.hooks.PostToolUse).toBeDefined();
-        expect(settings.hooks.PostToolUse[0].hooks[0].command).toContain('hooks check');
-        // Claude Code sends the edited path as JSON on stdin; it exports no TOOL_INPUT_* variable.
-        expect(settings.hooks.PostToolUse[0].hooks[0].command).toContain('--stdin');
-        expect(settings.hooks.PostToolUse[0].hooks[0].command).not.toContain('TOOL_INPUT');
-    });
-    it('reads the edited file from the JSON Claude Code sends on stdin', () => {
-        expect(parseStdinFiles(JSON.stringify({ hook_event_name: 'PostToolUse', tool_name: 'Write', tool_input: { file_path: 'src/a.ts', content: 'x' } }))).toEqual(['src/a.ts']);
-    });
-    it('should generate Cursor hooks', async () => {
-        await hooksInitCommand(testDir, { tool: 'cursor' });
-        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
-        expect(fs.existsSync(hooksPath)).toBe(true);
-        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
-        expect(hooks.hooks).toBeDefined();
-    });
-    it('should generate Cline hooks', async () => {
-        await hooksInitCommand(testDir, { tool: 'cline' });
-        const hookPath = path.join(testDir, '.clinerules', 'hooks', 'PostToolUse');
-        expect(fs.existsSync(hookPath)).toBe(true);
-    });
-    it('should skip a legacy .clinerules file and continue other tools', async () => {
-        fs.writeFileSync(path.join(testDir, '.clinerules'), 'legacy Cline rules');
-        await expect(hooksInitCommand(testDir, {
-            tool: 'cline,windsurf',
-        })).resolves.toBeUndefined();
-        expect(fs.readFileSync(path.join(testDir, '.clinerules'), 'utf-8'))
-            .toBe('legacy Cline rules');
-        expect(fs.existsSync(path.join(testDir, '.windsurf', 'hooks.json'))).toBe(true);
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('SKIP .clinerules/hooks/PostToolUse'));
-        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Cline: Not configured'));
-    });
-    it('should generate Windsurf hooks', async () => {
-        await hooksInitCommand(testDir, { tool: 'windsurf' });
-        const hooksPath = path.join(testDir, '.windsurf', 'hooks.json');
-        expect(fs.existsSync(hooksPath)).toBe(true);
-    });
-    it('should support dry-run mode', async () => {
-        await hooksInitCommand(testDir, { tool: 'claude', dryRun: true });
-        // Dry run should NOT create files
-        const settingsPath = path.join(testDir, '.claude', 'settings.json');
-        expect(fs.existsSync(settingsPath)).toBe(false);
-    });
-    it('merges into a settings file the person already has, keeping their settings and hooks, and stays idempotent', async () => {
-        const claudeDir = path.join(testDir, '.claude');
-        fs.mkdirSync(claudeDir, { recursive: true });
-        const own = { permissions: { allow: ['Bash(ls)'] }, hooks: { PostToolUse: [{ matcher: 'Write', hooks: [{ type: 'command', command: 'npm run format' }] }] } };
-        fs.writeFileSync(path.join(claudeDir, 'settings.json'), JSON.stringify(own));
-        for (const force of [false, true, true])
-            await hooksInitCommand(testDir, { tool: 'claude', force });
-        const merged = JSON.parse(fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8'));
-        expect(merged.permissions).toEqual(own.permissions);
-        const postToolUse = merged.hooks.PostToolUse.flatMap((group) => group.hooks.map((h) => h.command));
-        expect(postToolUse[0]).toBe('npm run format');
-        expect(postToolUse.filter((c) => /hooks check/.test(c))).toHaveLength(1); // three runs, one Rigour entry
-        expect(merged.hooks.Stop).toHaveLength(1);
-    });
-    it('leaves a settings file that is not valid JSON alone', async () => {
-        const claudeDir = path.join(testDir, '.claude');
-        fs.mkdirSync(claudeDir, { recursive: true });
-        fs.writeFileSync(path.join(claudeDir, 'settings.json'), '{ not json');
-        await hooksInitCommand(testDir, { tool: 'claude', force: true });
-        expect(fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf-8')).toBe('{ not json');
-    });
-    it('should propagate --block to generated hook commands', async () => {
-        await hooksInitCommand(testDir, { tool: 'all', force: true, block: true });
-        const claude = JSON.parse(fs.readFileSync(path.join(testDir, '.claude', 'settings.json'), 'utf-8'));
-        const cursor = JSON.parse(fs.readFileSync(path.join(testDir, '.cursor', 'hooks.json'), 'utf-8'));
-        const windsurf = JSON.parse(fs.readFileSync(path.join(testDir, '.windsurf', 'hooks.json'), 'utf-8'));
-        const clineScript = fs.readFileSync(path.join(testDir, '.clinerules', 'hooks', 'PostToolUse'), 'utf-8');
-        expect(claude.hooks.PostToolUse[0].hooks[0].command).toContain('--block');
-        expect(cursor.hooks.afterFileEdit[0].command).toContain('--block');
-        expect(windsurf.hooks.post_write_code[0].command).toContain('--block');
-        expect(clineScript).toContain('--block');
-    });
-});
-describe('hooksInitCommand — DLP integration', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-dlp-test-'));
-        fs.writeFileSync(path.join(testDir, 'rigour.yml'), yaml.stringify({
-            version: 1,
-            gates: { max_file_lines: 500 },
-        }));
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('should generate Claude hooks with DLP (PreToolUse) by default', async () => {
-        await hooksInitCommand(testDir, { tool: 'claude', force: true });
-        const settingsPath = path.join(testDir, '.claude', 'settings.json');
-        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        expect(settings.hooks.PostToolUse).toBeDefined();
-        const dlp = settings.hooks.PreToolUse.find((h) => h.matcher === '.*');
-        expect(dlp.hooks[0].command).toContain('--mode dlp');
-        expect(dlp.hooks[0].command).toMatch(/npx --yes @rigour-labs\/cli@\d+\.\d+\.\d+/);
-        const push = settings.hooks.PreToolUse.find((h) => h.matcher === 'Bash');
-        expect(push.hooks[0]).toMatchObject({ command: expect.stringContaining('hooks push --stdin'), timeout: 1800 });
-        expect(push.hooks[0].command).toContain('case "$payload" in *git*push*)'); // other commands never start Rigour
-    });
-    it('should generate Cursor hooks with DLP (beforeFileEdit) by default', async () => {
-        await hooksInitCommand(testDir, { tool: 'cursor', force: true });
-        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
-        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
-        expect(hooks.hooks.afterFileEdit).toBeDefined();
-        expect(hooks.hooks.beforeSubmitPrompt).toBeDefined();
-    });
-    it('should generate Windsurf hooks with DLP by default', async () => {
-        await hooksInitCommand(testDir, { tool: 'windsurf', force: true });
-        const hooksPath = path.join(testDir, '.windsurf', 'hooks.json');
-        const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
-        expect(hooks.hooks.post_write_code).toBeDefined();
-        expect(hooks.hooks.pre_write_code).toBeDefined();
-    });
-    it('should skip DLP hooks when dlp: false', async () => {
-        await hooksInitCommand(testDir, { tool: 'claude', force: true, dlp: false });
-        const settingsPath = path.join(testDir, '.claude', 'settings.json');
-        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        expect(settings.hooks.PostToolUse).toBeDefined();
-        expect(settings.hooks.PreToolUse.map((h) => h.matcher)).toEqual(['Bash']); // the push gate stays
-    });
-    it('should generate Cline DLP warnings without default blocking', async () => {
-        await hooksInitCommand(testDir, { tool: 'cline', force: true });
-        const script = fs.readFileSync(path.join(testDir, '.clinerules', 'hooks', 'PreToolUse'), 'utf-8');
-        expect(script).toContain("result.status !== 'clean'");
-        expect(script).toContain("if (result.status === 'blocked') process.exit(2)");
-    });
-    it('should not route DLP hooks through the file-only core checker', async () => {
-        const coreChecker = path.join(testDir, 'node_modules/@rigour-labs/core/dist/hooks/standalone-checker.js');
-        fs.mkdirSync(path.dirname(coreChecker), { recursive: true });
-        fs.writeFileSync(coreChecker, '');
-        await hooksInitCommand(testDir, { tool: 'cursor', force: true });
-        const hooks = JSON.parse(fs.readFileSync(path.join(testDir, '.cursor', 'hooks.json'), 'utf-8'));
-        const command = hooks.hooks.beforeSubmitPrompt[0].command;
-        expect(command).toMatch(/npx --yes @rigour-labs\/cli@\d+\.\d+\.\d+/);
-        expect(command).not.toContain('standalone-checker');
-    });
-});
-describe('hooksCheckCommand', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-check-test-'));
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('should return pass JSON when file is clean', async () => {
-        const filePath = path.join(testDir, 'ok.ts');
-        fs.writeFileSync(filePath, 'export const x = 1;\n');
-        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await hooksCheckCommand(testDir, { files: 'ok.ts' });
-        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
-        expect(output).toContain('"status":"pass"');
-    });
-    it('reports skipped, not pass, when the hook named no file', async () => {
-        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        await hooksCheckCommand(testDir, { files: '' });
-        expect(stdoutSpy.mock.calls.map(call => String(call[0])).join('')).toContain('"status":"skipped"');
-    });
-    it('should return fail JSON and set exit code 2 in block mode', async () => {
-        const filePath = path.join(testDir, 'bad.ts');
-        fs.writeFileSync(filePath, "const password = 'abcdefghijklmnopqrstuvwxyz12345';\n");
-        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const originalExitCode = process.exitCode;
-        await hooksCheckCommand(testDir, { files: 'bad.ts', block: true });
-        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
-        expect(output).toContain('"status":"fail"');
-        expect(stderrSpy).toHaveBeenCalled();
-        expect(process.exitCode).toBe(2);
-        process.exitCode = originalExitCode;
-    });
-    it('should warn and continue for DLP detections by default', async () => {
-        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const originalExitCode = process.exitCode;
-        await hooksCheckCommand(testDir, {
-            mode: 'dlp',
-            files: 'AKIAZ9Y8X7W6V5U4T3Q2',
-        });
-        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
-        expect(output).toContain('"status":"warning"');
-        expect(output).not.toContain('AKIAZ9Y8X7W6V5U4T3Q2');
-        expect(stderrSpy).toHaveBeenCalled();
-        expect(process.exitCode).toBe(originalExitCode);
-    });
-    it('should block DLP detections only with --block', async () => {
-        const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const originalExitCode = process.exitCode;
-        await hooksCheckCommand(testDir, {
-            mode: 'dlp',
-            files: 'AKIAZ9Y8X7W6V5U4T3Q2',
-            block: true,
-        });
-        const output = stdoutSpy.mock.calls.map(call => String(call[0])).join('');
-        expect(output).toContain('"status":"blocked"');
-        expect(process.exitCode).toBe(2);
-        process.exitCode = originalExitCode;
-    });
-});

package/dist/commands/init-mcp-spec.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/init-mcp-spec.test.js

@@ -1,10 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { mcpPackageSpec } from './init.js';
-describe('mcpPackageSpec', () => {
-    it("pins the MCP server to this CLI's major, never a bare or stale exact version", () => {
-        expect(mcpPackageSpec('6.5.2')).toBe('@rigour-labs/mcp@6');
-        expect(mcpPackageSpec('7.0.0-beta.1')).toBe('@rigour-labs/mcp@7');
-        expect(mcpPackageSpec('0.0.0')).toBe('@rigour-labs/mcp@latest');
-        expect(mcpPackageSpec('unknown')).toBe('@rigour-labs/mcp@latest');
-    });
-});

package/dist/commands/init.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/init.test.js

@@ -1,107 +0,0 @@
-/**
- * Tests for init command — IDE detection, config generation, auto-hook integration.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { initCommand } from './init.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-describe('initCommand', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'init-test-'));
-        // Minimal package.json for discovery
-        fs.writeFileSync(path.join(testDir, 'package.json'), JSON.stringify({
-            name: 'test-project',
-            dependencies: { express: '^4.0.0' },
-        }));
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('should create rigour.yml', async () => {
-        await initCommand(testDir);
-        const configPath = path.join(testDir, 'rigour.yml');
-        expect(fs.existsSync(configPath)).toBe(true);
-        const content = fs.readFileSync(configPath, 'utf-8');
-        expect(content).toContain('gates:');
-        expect(content).not.toMatch(/^version:|fast_gates|^planned:|input_validation|adaptive:/m); // settings nothing reads are not written
-    });
-    it('writes no instruction files or empty documents unless asked', async () => {
-        await initCommand(testDir);
-        for (const rel of ['docs/AGENT_INSTRUCTIONS.md', 'CLAUDE.md', 'AGENTS.md', '.windsurfrules', 'docs/SPEC.md', 'docs/ARCH.md']) {
-            expect(fs.existsSync(path.join(testDir, rel))).toBe(false);
-        }
-    });
-    it('should support dry-run mode', async () => {
-        await initCommand(testDir, { dryRun: true });
-        // Dry run should NOT create rigour.yml
-        expect(fs.existsSync(path.join(testDir, 'rigour.yml'))).toBe(false);
-    });
-    it('should not overwrite without --force', async () => {
-        // Create existing rigour.yml
-        fs.writeFileSync(path.join(testDir, 'rigour.yml'), 'version: 1\nexisting: true\n');
-        await initCommand(testDir);
-        const content = fs.readFileSync(path.join(testDir, 'rigour.yml'), 'utf-8');
-        expect(content).toContain('existing');
-    });
-    it('should overwrite with --force', async () => {
-        // Create existing rigour.yml
-        fs.writeFileSync(path.join(testDir, 'rigour.yml'), 'version: 1\nexisting: true\n');
-        await initCommand(testDir, { force: true });
-        // Should create backup
-        expect(fs.existsSync(path.join(testDir, 'rigour.yml.bak'))).toBe(true);
-        // New config should not contain 'existing'
-        const content = fs.readFileSync(path.join(testDir, 'rigour.yml'), 'utf-8');
-        expect(content).not.toContain('existing: true');
-    });
-    it('should detect Claude IDE and create hooks', async () => {
-        // Create Claude marker
-        fs.mkdirSync(path.join(testDir, '.claude'), { recursive: true });
-        await initCommand(testDir);
-        // Should have created .claude/settings.json (hooks)
-        const settingsPath = path.join(testDir, '.claude', 'settings.json');
-        expect(fs.existsSync(settingsPath)).toBe(true);
-    });
-    it('should detect Cursor IDE and create hooks', async () => {
-        // Create Cursor marker
-        fs.mkdirSync(path.join(testDir, '.cursor'), { recursive: true });
-        await initCommand(testDir);
-        // Should have created .cursor/hooks.json
-        const hooksPath = path.join(testDir, '.cursor', 'hooks.json');
-        expect(fs.existsSync(hooksPath)).toBe(true);
-    });
-    it('should update .gitignore with rigour patterns', async () => {
-        await initCommand(testDir);
-        const gitignorePath = path.join(testDir, '.gitignore');
-        expect(fs.existsSync(gitignorePath)).toBe(true);
-        const content = fs.readFileSync(gitignorePath, 'utf-8');
-        expect(content).toContain('rigour-report.json');
-        expect(content).toContain('.rigour/*');
-        expect(content).toContain('!.rigour/dismissed.json');
-        expect(content).toContain('!.rigour/backtest.json');
-    });
-    it('turns an older whole-directory `.rigour/` ignore into one the shared files can escape', async () => {
-        fs.writeFileSync(path.join(testDir, '.gitignore'), 'node_modules\n.rigour/\n');
-        await initCommand(testDir);
-        const lines = fs.readFileSync(path.join(testDir, '.gitignore'), 'utf-8').split('\n');
-        expect(lines).not.toContain('.rigour/');
-        expect(lines.filter(l => l === '.rigour/*')).toHaveLength(1);
-        expect(lines).toContain('!.rigour/dismissed.json');
-    });
-    it('should create .rigour/memory.json for Studio', async () => {
-        await initCommand(testDir);
-        const memPath = path.join(testDir, '.rigour', 'memory.json');
-        expect(fs.existsSync(memPath)).toBe(true);
-        const mem = JSON.parse(fs.readFileSync(memPath, 'utf-8'));
-        expect(mem.memories.project_boot).toBeDefined();
-    });
-    it('should support --ide flag to target specific IDE', async () => {
-        await initCommand(testDir, { ide: 'windsurf' });
-        expect(fs.existsSync(path.join(testDir, '.windsurf', 'hooks.json'))).toBe(true);
-        expect(fs.existsSync(path.join(testDir, '.claude', 'settings.json'))).toBe(false);
-    });
-});

package/dist/commands/learn.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/learn.test.js

@@ -1,50 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { learnCommand } from './learn.js';
-const BEFORE = "export async function post(url: string, init: RequestInit) {\n  return fetch(url, init);\n}\n";
-const AFTER = "export async function post(url: string, init: RequestInit) {\n  return fetch(url, { ...init, redirect: 'manual' });\n}\n";
-describe('learnCommand', () => {
-    let cwd;
-    let log;
-    let error;
-    beforeEach(() => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'learn-cli-'));
-        fs.mkdirSync(path.join(cwd, 'src'));
-        fs.writeFileSync(path.join(cwd, 'old.ts'), BEFORE);
-        fs.writeFileSync(path.join(cwd, 'src', 'http.ts'), AFTER);
-        log = vi.spyOn(console, 'log').mockImplementation(() => { });
-        error = vi.spyOn(console, 'error').mockImplementation(() => { });
-        process.exitCode = undefined;
-    });
-    afterEach(() => {
-        log.mockRestore();
-        error.mockRestore();
-        process.exitCode = undefined;
-        fs.rmSync(cwd, { recursive: true, force: true });
-    });
-    it('learns from --before/--after and saves the rule', async () => {
-        await learnCommand(cwd, undefined, { before: 'old.ts', after: 'src/http.ts' });
-        const saved = fs.readdirSync(path.join(cwd, '.rigour', 'rules'));
-        expect(saved).toHaveLength(1);
-        const rule = JSON.parse(fs.readFileSync(path.join(cwd, '.rigour', 'rules', saved[0]), 'utf8'));
-        expect(rule.pattern).toMatchObject({ template: 'require-option', property: 'redirect', value: 'manual' });
-        expect(rule.source).toEqual({ file: 'src/http.ts', function: 'post' });
-    });
-    it('saves nothing on --dry-run and reports JSON', async () => {
-        await learnCommand(cwd, undefined, { before: 'old.ts', after: 'src/http.ts', dryRun: true, json: true });
-        expect(fs.existsSync(path.join(cwd, '.rigour'))).toBe(false);
-        const report = JSON.parse(String(log.mock.calls[0][0]));
-        expect(report.learned).toHaveLength(1);
-        expect(report.saved).toEqual([]);
-    });
-    it('rejects missing or conflicting inputs with a usage exit code', async () => {
-        await learnCommand(cwd, undefined, { before: 'old.ts' });
-        expect(process.exitCode).toBe(2);
-        await learnCommand(cwd, 'abc123', { before: 'old.ts', after: 'src/http.ts' });
-        expect(error.mock.calls.flat().join('\n')).toContain('Give only one of');
-        await learnCommand(cwd, undefined, { before: 'old.ts', after: 'src/http.ts', maxHits: '-1' });
-        expect(error.mock.calls.flat().join('\n')).toContain('--max-hits');
-    });
-});

package/dist/commands/personal.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/personal.test.js

@@ -1,191 +0,0 @@
-import { execFileSync, spawnSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { asUserLevel, disableHere, enabledHere, enableHere } from './personal.js';
-import { setupCommand } from './setup.js';
-import { uninstall } from './uninstall.js';
-let repo;
-let home;
-let bin;
-const saved = { RIGOUR_AGENT_HOME: process.env.RIGOUR_AGENT_HOME, RIGOUR_CLAUDE_CLI: process.env.RIGOUR_CLAUDE_CLI, RIGOUR_HOME: process.env.RIGOUR_HOME };
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const atHome = (rel) => path.join(home, rel);
-const unix = process.platform !== 'win32';
-/** A `claude` CLI that keeps its MCP servers in a file, so add/get/remove behave like the real one. */
-function fakeClaude() {
-    const servers = path.join(bin, 'claude-mcp.txt');
-    fs.writeFileSync(path.join(bin, 'claude'), `#!/bin/sh
-echo "$@" >> "${path.join(bin, 'claude-calls.log')}"
-case "$1 $2" in
-  "--version "*) echo "9.9.9 (Claude Code)"; exit 0 ;;
-  "mcp get") grep -qx "$3" "${servers}" 2>/dev/null; exit $? ;;
-  "mcp add") echo "$5" >> "${servers}"; exit 0 ;;
-  "mcp remove") : > "${servers}"; exit 0 ;;
-esac
-exit 1
-`, { mode: 0o755 });
-    process.env.RIGOUR_CLAUDE_CLI = path.join(bin, 'claude');
-    return path.join(bin, 'claude-calls.log');
-}
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'personal-repo-'));
-    home = fs.mkdtempSync(path.join(os.tmpdir(), 'personal-home-'));
-    bin = fs.mkdtempSync(path.join(os.tmpdir(), 'personal-bin-'));
-    // The agents' home and Rigour's own, both throwaway (os.homedir() would ignore a HOME set here).
-    process.env.RIGOUR_AGENT_HOME = home;
-    process.env.RIGOUR_HOME = home;
-    git('init', '-q', '-b', 'main');
-    git('config', 'core.hooksPath', '.git/hooks');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.writeFileSync(path.join(repo, 'package.json'), JSON.stringify({ name: 'app' }));
-    fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-    vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    vi.spyOn(console, 'error').mockImplementation(() => undefined);
-    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    for (const [key, value] of Object.entries(saved)) {
-        if (value === undefined)
-            delete process.env[key];
-        else
-            process.env[key] = value;
-    }
-    for (const dir of [repo, home, bin])
-        fs.rmSync(dir, { recursive: true, force: true });
-});
-describe('the switch for a repository', () => {
-    it('lives in the git directory, shared by worktrees, and puts .rigour/ in info/exclude once', () => {
-        expect(enabledHere(repo)).toBe(false);
-        enableHere(repo);
-        enableHere(repo);
-        expect(enabledHere(repo)).toBe(true);
-        expect(fs.readFileSync(path.join(repo, '.git/info/exclude'), 'utf8').split('\n').filter(l => l === '.rigour/')).toHaveLength(1);
-        const worktree = path.join(os.tmpdir(), `personal-wt-${process.pid}`);
-        git('worktree', 'add', '-q', '--detach', worktree);
-        try {
-            expect(enabledHere(worktree)).toBe(true);
-        }
-        finally {
-            git('worktree', 'remove', '--force', worktree);
-        }
-        disableHere(repo, true);
-        expect(enabledHere(repo)).toBe(false);
-        expect(fs.readFileSync(path.join(repo, '.git/info/exclude'), 'utf8')).not.toContain('.rigour/');
-    });
-});
-describe.skipIf(!unix)('the guard on a machine-level hook', () => {
-    /** The command a project Stop hook becomes in the user-level Claude settings. */
-    const guarded = (command) => JSON.parse(asUserLevel({ path: '.claude/settings.json', content: JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: 'command', command }] }] } }) }).content).hooks.Stop[0].hooks[0].command;
-    const run = (command) => spawnSync('sh', ['-c', command], { cwd: repo, input: 'payload', encoding: 'utf8', env: { ...process.env, CLAUDE_PROJECT_DIR: '' } });
-    it('runs the command only in a repository switched on, with stdin passed through, even for a quoted command', () => {
-        const command = guarded(`sh -c 'printf "ran:"; cat'`);
-        expect(run(command).stdout).toBe('');
-        expect(run(command).status).toBe(0);
-        enableHere(repo);
-        expect(run(command).stdout).toBe('ran:payload');
-        const outside = spawnSync('sh', ['-c', command], { cwd: os.tmpdir(), input: 'x', encoding: 'utf8' });
-        expect(outside).toMatchObject({ status: 0, stdout: '' });
-    });
-    it('turns each project hook file into its agent\'s user-level twin, every command guarded', () => {
-        const claude = asUserLevel({ path: '.claude/settings.json', content: JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: 'command', command: 'npx rigour hooks stop' }] }] } }) });
-        expect(claude.path).toBe('.claude/settings.json');
-        expect(JSON.parse(claude.content).hooks.Stop[0].hooks[0].command).toMatch(/^sh -c '.*rigour-enabled.*exec npx rigour hooks stop'$/);
-        expect(asUserLevel({ path: '.windsurf/hooks.json', content: '{}' }).path).toBe('.codeium/windsurf/hooks.json');
-        const cline = asUserLevel({ path: '.clinerules/hooks/PostToolUse', content: '#!/usr/bin/env node\nprocess.stdout.write("ran");\n' });
-        expect(cline.path).toBe('Documents/Cline/Hooks/PostToolUse');
-        fs.writeFileSync(path.join(bin, 'hook.js'), cline.content);
-        expect(spawnSync(process.execPath, [path.join(bin, 'hook.js')], { cwd: repo, encoding: 'utf8' }).stdout).toBe('{}');
-        enableHere(repo);
-        expect(spawnSync(process.execPath, [path.join(bin, 'hook.js')], { cwd: repo, encoding: 'utf8' }).stdout).toBe('ran');
-    });
-});
-describe.skipIf(!unix)('rigour setup, personal', () => {
-    it('leaves the working tree untouched, installs machine hooks into the configs the person has, and comes back out exactly', async () => {
-        const calls = fakeClaude();
-        const ownSettings = { permissions: { allow: ['Bash(ls)'] }, hooks: { PostToolUse: [{ matcher: 'Write', hooks: [{ type: 'command', command: 'npm run format' }] }] } };
-        fs.mkdirSync(atHome('.claude'), { recursive: true });
-        fs.writeFileSync(atHome('.claude/settings.json'), JSON.stringify(ownSettings));
-        fs.mkdirSync(atHome('.cursor')); // Cursor is installed here; Windsurf and Cline are not
-        await setupCommand(repo, { semantic: false });
-        expect(git('status', '--porcelain', '--untracked-files=all')).toBe(''); // nothing in the working tree
-        expect(enabledHere(repo)).toBe(true);
-        expect(fs.readFileSync(path.join(repo, '.git/hooks/pre-push'), 'utf8')).toContain('hooks push --git');
-        const settings = JSON.parse(fs.readFileSync(atHome('.claude/settings.json'), 'utf8'));
-        expect(settings.permissions).toEqual(ownSettings.permissions);
-        const commands = JSON.stringify(settings.hooks);
-        expect(commands).toContain('npm run format');
-        expect(commands).toContain('rigour-enabled'); // every Rigour hook is guarded
-        for (const rel of ['.cursor/hooks.json', '.cursor/mcp.json'])
-            expect(fs.existsSync(atHome(rel)), rel).toBe(true);
-        for (const rel of ['.codeium', 'Documents'])
-            expect(fs.existsSync(atHome(rel)), rel).toBe(false); // nothing for an agent that is not installed
-        expect(fs.readFileSync(calls, 'utf8')).toMatch(/^mcp add --scope user rigour -- /m);
-        // Setting up a second repository reuses the machine install: one Rigour entry per event, not two.
-        await setupCommand(repo, { semantic: false });
-        const again = JSON.parse(fs.readFileSync(atHome('.claude/settings.json'), 'utf8'));
-        expect(again.hooks.Stop).toHaveLength(1);
-        // This repository off: the machine hooks stay, silent here now.
-        uninstall(repo);
-        expect(enabledHere(repo)).toBe(false);
-        expect(fs.existsSync(path.join(repo, '.git/hooks/pre-push'))).toBe(false);
-        expect(fs.existsSync(atHome('.cursor/hooks.json'))).toBe(true);
-        // Off the machine: the person's own settings are back as they were.
-        uninstall(repo, { machine: true });
-        expect(JSON.parse(fs.readFileSync(atHome('.claude/settings.json'), 'utf8'))).toEqual(ownSettings);
-        for (const rel of ['.cursor/hooks.json', '.codeium/windsurf/hooks.json', 'Documents/Cline/Hooks/PostToolUse', '.cursor/mcp.json']) {
-            expect(fs.existsSync(atHome(rel))).toBe(false);
-        }
-        expect(fs.readFileSync(calls, 'utf8')).toMatch(/^mcp remove --scope user rigour$/m);
-        expect(git('status', '--porcelain', '--untracked-files=all')).toBe('');
-    });
-});
-describe('rigour setup --team', () => {
-    it('commits the configuration, without instruction files or empty documents unless asked', async () => {
-        await setupCommand(repo, { semantic: false, team: true });
-        expect(fs.existsSync(path.join(repo, 'rigour.yml'))).toBe(true);
-        expect(fs.readFileSync(path.join(repo, '.claude/settings.json'), 'utf8')).toContain('hooks check');
-        for (const rel of ['CLAUDE.md', 'AGENTS.md', 'docs/AGENT_INSTRUCTIONS.md', 'docs/SPEC.md', 'docs/ARCH.md'])
-            expect(fs.existsSync(path.join(repo, rel))).toBe(false);
-        expect(enabledHere(repo)).toBe(false); // machine hooks stay silent beside the committed ones
-    });
-    it('writes instruction files where the project has none when asked', async () => {
-        await setupCommand(repo, { semantic: false, team: true, instructions: true });
-        expect(fs.existsSync(path.join(repo, 'CLAUDE.md'))).toBe(true);
-    });
-    it("leaves a teammate's clone exactly as committed, and still writes instructions when asked", async () => {
-        await setupCommand(repo, { semantic: false, team: true });
-        git('add', '-A');
-        git('commit', '-qm', 'adopt rigour');
-        await setupCommand(repo, { semantic: false }); // a teammate after cloning: rigour.yml is tracked
-        expect(git('status', '--porcelain')).toBe(''); // no committed file changed
-        expect(fs.readFileSync(path.join(repo, '.git/hooks/pre-push'), 'utf8')).toContain('hooks push --git');
-        await setupCommand(repo, { semantic: false, instructions: true });
-        expect(fs.readFileSync(path.join(repo, 'CLAUDE.md'), 'utf8')).toBe('@AGENTS.md\n');
-    });
-    it('keeps a .cursor/mcp.json that is not valid JSON', async () => {
-        fs.mkdirSync(path.join(repo, '.cursor'));
-        fs.writeFileSync(path.join(repo, '.cursor/mcp.json'), '{ not json');
-        await setupCommand(repo, { semantic: false, team: true });
-        expect(fs.readFileSync(path.join(repo, '.cursor/mcp.json'), 'utf8')).toBe('{ not json');
-    });
-});
-describe('rigour setup, personal, with git hooks kept in the repository', () => {
-    it('leaves a committed hooks folder (Husky) alone and says what to add', async () => {
-        fs.mkdirSync(path.join(repo, '.husky'));
-        fs.writeFileSync(path.join(repo, '.husky/pre-push'), 'npm test\n');
-        git('add', '-A');
-        git('commit', '-qm', 'husky');
-        git('config', 'core.hooksPath', '.husky');
-        await setupCommand(repo, { semantic: false });
-        expect(fs.readFileSync(path.join(repo, '.husky/pre-push'), 'utf8')).toBe('npm test\n');
-        expect(git('status', '--porcelain', '--untracked-files=all')).toBe('');
-        expect(vi.mocked(console.log).mock.calls.flat().join('\n')).toContain('hooks push --git "$@" || exit $?');
-    });
-});

package/dist/commands/repo-setup.test.d.ts

@@ -1 +0,0 @@
-export {};