@rigour-labs/cli 6.8.0 → 6.8.1

package/dist/commands/hooks-stop.test.js

@@ -1,167 +0,0 @@
-import { execFileSync } 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 { readThread, recordSessionBaseline } from '@rigour-labs/core';
-import { hooksStopCommand } from './hooks-stop.js';
-// A credential header on a redirect-following request: a proven (verified) high finding.
-const LEAKY = "export async function notify(endpoint: string, signature: string) {\n  return fetch(endpoint, { method: 'POST', headers: { 'x-hook-signature': signature } });\n}\n";
-// Only a heuristic finding (fetch without error handling), not proven.
-const HEURISTIC = "export async function load(url: string) {\n  return fetch(url);\n}\n";
-describe('rigour hooks stop', () => {
-    let repo;
-    const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-    const write = (rel, body) => {
-        fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-        fs.writeFileSync(path.join(repo, rel), body);
-    };
-    beforeEach(() => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'stop-hook-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        write('rigour.yml', 'version: 1\ngates:\n  semantic_bugs:\n    enabled: true\n  unused_exports:\n    block: true\n'); // this team blocks on dead code
-        write('.gitignore', '.rigour/\n');
-        git('add', '-A');
-        git('commit', '-qm', 'init');
-    });
-    afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); vi.restoreAllMocks(); });
-    it('keeps Claude working on a proven finding, then gives up after three attempts', async () => {
-        write('src/notify.ts', LEAKY);
-        const payload = JSON.stringify({ cwd: repo, session_id: 's1' });
-        const first = JSON.parse(await hooksStopCommand('claude', payload, '/'));
-        expect(first.decision).toBe('block');
-        expect(first.reason).toContain('src/notify.ts:2');
-        expect(first.reason).toContain('attempt 1 of 3');
-        // The task's thread keeps the blocked stop review, with the agent and its session.
-        expect(readThread(repo)?.events.map(e => [e.kind, e.agent, e.session, e.blocked])).toEqual([['stop-review', 'claude', 's1', true]]);
-        for (const n of [1, 2]) {
-            write('src/notify.ts', `${LEAKY}// attempt ${n}\n`); // the agent edits, still leaking
-            await hooksStopCommand('claude', payload, '/');
-        }
-        write('src/notify.ts', `${LEAKY}// attempt 3\n`);
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-    });
-    it('sends Cursor a follow-up message, and stops following up at the loop limit', async () => {
-        write('src/notify.ts', LEAKY);
-        const reply = JSON.parse(await hooksStopCommand('cursor', JSON.stringify({ cwd: repo, status: 'completed', loop_count: 0 }), '/'));
-        expect(reply.followup_message).toContain('src/notify.ts:2');
-        expect(await hooksStopCommand('cursor', JSON.stringify({ cwd: repo, status: 'completed', loop_count: 3 }), '/')).toBe('');
-        expect(await hooksStopCommand('cursor', JSON.stringify({ cwd: repo, status: 'aborted' }), '/')).toBe('');
-    });
-    it('asks once, at the end of the task, about what the team learned that applies to the change', async () => {
-        const lesson = { id: 'l1', text: 'Time out every fetch the loader makes.', file: 'src/load.ts', symbols: ['load'], state: 'verified', evidence: [{ pr: 7, comment: 'c1', author: 'senior' }, { pr: 9, comment: 'c2', author: 'senior' }], createdAt: '2026-01-01', updatedAt: '2026-01-01' };
-        write('.rigour/review-lessons.json', JSON.stringify({ version: 1, lessons: [lesson, { ...lesson, id: 'l2', text: 'Unrelated lesson about billing.', file: 'src/billing.ts', symbols: ['charge'] }] }));
-        write('src/load.ts', HEURISTIC);
-        write('src/main.ts', "import { load } from './load';\nvoid load('/');\n");
-        const payload = JSON.stringify({ cwd: repo, session_id: 'teach' });
-        const first = JSON.parse(await hooksStopCommand('claude', payload, '/'));
-        expect(first.decision).toBe('block');
-        expect(first.reason).toContain('src/load.ts: Time out every fetch the loader makes. (acted on in PR #7, #9)');
-        expect(first.reason).not.toContain('billing');
-        write('src/load.ts', `${HEURISTIC}// the agent checked it\n`);
-        expect(await hooksStopCommand('claude', payload, '/')).toBe(''); // asked once: never a loop
-    });
-    it('lets the agent stop when only heuristic findings remain', async () => {
-        write('src/load.ts', HEURISTIC);
-        write('src/main.ts', "import { load } from './load';\nvoid load('/');\n");
-        write('package.json', '{"scripts":{"start":"node src/main.ts"}}\n'); // wired in: not dead code
-        expect(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 's2' }), '/')).toBe('');
-    });
-    it('says once when the review cannot run, then lets the agent stop', async () => {
-        const notARepo = fs.mkdtempSync(path.join(os.tmpdir(), 'stop-hook-norepo-'));
-        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const payload = JSON.stringify({ cwd: notARepo, session_id: 'broken' });
-        const first = JSON.parse(await hooksStopCommand('claude', payload, '/'));
-        expect(first).toMatchObject({ decision: 'block' });
-        expect(first.reason).toContain('Rigour could not review this change');
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-        fs.rmSync(notARepo, { recursive: true, force: true });
-    });
-    it('still reviews what the session committed', async () => {
-        recordSessionBaseline(repo, 's3');
-        write('src/notify.ts', LEAKY);
-        git('add', '-A');
-        git('commit', '-qm', 'hide it in a commit');
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 's3' }), '/'));
-        expect(reply.reason).toContain('src/notify.ts:2');
-    });
-    it('reviews the whole branch, including commits made before the session started', async () => {
-        git('checkout', '-q', '-b', 'feature');
-        write('src/notify.ts', LEAKY);
-        git('add', '-A');
-        git('commit', '-qm', 'earlier work on the branch');
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 'branch' }), '/'));
-        expect(reply.reason).toContain('src/notify.ts:2');
-    });
-    it('says there was nothing to review instead of passing silently', async () => {
-        git('checkout', '-q', '-b', 'empty');
-        const said = [];
-        vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => { said.push(String(chunk)); return true; });
-        expect(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 'empty' }), '/')).toBe('');
-        expect(said.join('')).toContain('nothing to review against main @');
-    });
-    it('holds the agent back on an export the branch added that nothing uses', async () => {
-        git('checkout', '-q', '-b', 'dead');
-        write('src/util.ts', 'export const used = 1;\nexport const forgotten = 2;\n');
-        write('src/main.ts', "import { used } from './util';\nconsole.log(used);\n");
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 'dead' }), '/'));
-        expect(reply.reason).toContain('src/util.ts:2 Unused export');
-    });
-    it('does not repeat itself after a turn that changed nothing, and reviews again after an edit', async () => {
-        write('src/notify.ts', LEAKY);
-        const payload = JSON.stringify({ cwd: repo, session_id: 'quiet' });
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-        expect(await hooksStopCommand('claude', payload, '/')).toBe(''); // a read-only turn: already said
-        write('src/notify.ts', LEAKY + '// touched\n');
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-    });
-    it("does not count Rigour's own files as new work where the repository does not ignore them", async () => {
-        write('.gitignore', ''); // a repository that does not ignore .rigour/ or the report
-        git('add', '-A');
-        git('commit', '-qm', 'ignore nothing');
-        write('src/notify.ts', LEAKY);
-        const payload = JSON.stringify({ cwd: repo, session_id: 'own-files' });
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-        write('rigour-report.json', '{"rewritten":true}\n'); // what a review leaves behind
-        write('.rigour/scan-cache.json', '{}\n');
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-    });
-    it('ignores an attempt counter written into the workspace', async () => {
-        write('.rigour/stop-hook.json', JSON.stringify({ s4: 3 }));
-        write('src/notify.ts', LEAKY);
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 's4' }), '/'));
-        expect(reply.reason).toContain('attempt 1 of 3');
-    });
-});
-describe('the agent fix loop', () => {
-    it('turns an agent fix to a stop-hook finding into a validated rule', async () => {
-        const { learnCommand } = await import('./learn.js');
-        const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-loop-'));
-        const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        fs.writeFileSync(path.join(repo, '.gitignore'), '.rigour/\n');
-        git('add', '-A');
-        git('commit', '-qm', 'init');
-        fs.mkdirSync(path.join(repo, 'src'));
-        fs.writeFileSync(path.join(repo, 'src/notify.ts'), LEAKY);
-        fs.writeFileSync(path.join(repo, 'package.json'), '{"scripts":{"notify":"node src/notify.ts"}}\n'); // wired in: not dead code
-        const payload = JSON.stringify({ cwd: repo, session_id: 'loop' });
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-        fs.writeFileSync(path.join(repo, 'src/notify.ts'), LEAKY.replace("{ method: 'POST',", "{ method: 'POST', redirect: 'manual',"));
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        await learnCommand(repo, undefined, { agentFixes: true });
-        const rules = fs.readdirSync(path.join(repo, '.rigour', 'rules'));
-        expect(rules).toHaveLength(1);
-        expect(JSON.parse(fs.readFileSync(path.join(repo, '.rigour', 'rules', rules[0]), 'utf8')).pattern)
-            .toMatchObject({ template: 'require-option', property: 'redirect', value: 'manual' });
-        expect(fs.readdirSync(path.join(repo, '.rigour', 'agent-fixes', 'resolved'))).toEqual([]);
-        fs.rmSync(repo, { recursive: true, force: true });
-    });
-});

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

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

package/dist/commands/hooks.test.js

@@ -1,256 +0,0 @@
-/**
- * Tests for hooks init command.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import { readThread } from '@rigour-labs/core';
-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("keeps each edit check on the task's thread, with the files and the findings", async () => {
-        execFileSync('git', ['-C', testDir, 'init', '-q', '-b', 'feat/PROJ-21-thread']);
-        fs.writeFileSync(path.join(testDir, 'ok.ts'), 'export const x = 1;\n');
-        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        await hooksCheckCommand(testDir, { files: 'ok.ts', agent: 'codex' });
-        expect(readThread(testDir, 'feat/PROJ-21-thread')?.events.map(e => [e.kind, e.agent, e.files, e.findings, e.status])).toEqual([['edit-check', 'codex', ['ok.ts'], 0, '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 {};