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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "6.8.0",
+  "version": "6.8.1-rc.1",
   "description": "Code review that happens while your agent writes: deterministic checks on the lines it changed, quiet unless it can prove a defect, and learning from your team's fixes and dismissals. Works with Claude Code, Cursor, Codex, Cline and Windsurf.",
   "engines": {
     "node": ">=22.13"
@@ -36,7 +36,10 @@
   "files": [
     "dist",
     "studio-dist",
-    "templates"
+    "templates",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map"
   ],
   "repository": {
     "type": "git",
@@ -56,13 +59,13 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "6.8.0"
+    "@rigour-labs/core": "6.8.1-rc.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "6.8.0"
+    "@rigour-labs/studio": "6.8.1-rc.1"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",

package/dist/cli-help.test.d.ts

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

package/dist/cli-help.test.js

@@ -1,27 +0,0 @@
-import { Command } from 'commander';
-import { describe, expect, it } from 'vitest';
-import { configureHelp } from './cli-help.js';
-function program() {
-    const p = new Command('rigour');
-    for (const name of ['setup', 'review', 'studio', 'doctor', 'check', 'scan', 'learn'])
-        p.command(name).description(name);
-    return p;
-}
-describe('rigour help', () => {
-    it('lists the four everyday commands and says how to see the rest', () => {
-        const p = program();
-        configureHelp(p, ['node', 'rigour', '--help']);
-        const text = p.helpInformation() + '\n';
-        expect(text).toMatch(/setup[\s\S]*review[\s\S]*studio[\s\S]*doctor/);
-        expect(text).not.toMatch(/\n\s+check\b/);
-    });
-    it('lists every command with --all, and drops the flag before parsing', () => {
-        const p = program();
-        const argv = configureHelp(p, ['node', 'rigour', 'help', '--all']);
-        expect(argv).toEqual(['node', 'rigour', 'help']);
-        expect(p.helpInformation()).toMatch(/\n\s+check\b/);
-    });
-    it('leaves --all alone for any other command', () => {
-        expect(configureHelp(program(), ['node', 'rigour', 'review', '--all'])).toEqual(['node', 'rigour', 'review', '--all']);
-    });
-});

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

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

package/dist/commands/brief.test.js

@@ -1,134 +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 } from '@rigour-labs/core';
-import { briefCommand, hooksBriefCommand, hooksBriefFileCommand } from './brief.js';
-import { hooksCheckCommand, hooksInitCommand } from './hooks.js';
-let repo;
-const write = (file, text) => {
-    fs.mkdirSync(path.dirname(path.join(repo, file)), { recursive: true });
-    fs.writeFileSync(path.join(repo, file), text);
-};
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'brief-cli-'));
-    execFileSync('git', ['-C', repo, 'init', '-q', '-b', 'feat/retry']);
-    write('AGENTS.md', '- Every job in `src/jobs/` must take `withLock()` before its first read; a job that reads first double-sends.\n');
-    write('src/jobs/retry.ts', 'export async function retryJob() {}\n');
-    execFileSync('git', ['-C', repo, 'add', '-A']);
-    delete process.env.RIGOUR_BRIEF;
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    delete process.env.RIGOUR_BRIEF;
-    fs.rmSync(repo, { recursive: true, force: true });
-});
-describe('the prompt hook', () => {
-    const payload = (session, prompt = 'make the jobs retry with backoff') => JSON.stringify({ cwd: repo, session_id: session, prompt, hook_event_name: 'UserPromptSubmit' });
-    it("briefs from the session's first prompt, once per session, as context Claude Code adds", async () => {
-        const reply = JSON.parse(await hooksBriefCommand(payload('s1'), '/'));
-        expect(reply.hookSpecificOutput.hookEventName).toBe('UserPromptSubmit');
-        expect(reply.hookSpecificOutput.additionalContext).toContain('1. [must] Every job in `src/jobs/` must take `withLock()`');
-        expect(await hooksBriefCommand(payload('s1', 'now add tests'), '/')).toBe(''); // never twice in a session
-        expect(await hooksBriefCommand(payload('s2'), '/')).not.toBe(''); // a new session is briefed
-        expect(readThread(repo)?.events.map(e => [e.kind, e.session, e.agent])).toEqual([['brief', 's1', 'claude'], ['brief', 's2', 'claude']]);
-    });
-    it('says nothing when the team or the person switched briefings off, or the payload is not a session', async () => {
-        write('rigour.yml', 'version: 1\nbrief:\n  enabled: false\n');
-        expect(await hooksBriefCommand(payload('s1'), '/')).toBe('');
-        fs.rmSync(path.join(repo, 'rigour.yml'));
-        process.env.RIGOUR_BRIEF = '0';
-        expect(await hooksBriefCommand(payload('s2'), '/')).toBe('');
-        delete process.env.RIGOUR_BRIEF;
-        expect(await hooksBriefCommand('not json', '/')).toBe('');
-        expect(await hooksBriefCommand(JSON.stringify({ cwd: repo, prompt: 'x' }), '/')).toBe('');
-        expect(readThread(repo)?.events ?? []).toEqual([]);
-    });
-    it('caps the briefing at the max_items the team set', async () => {
-        write('AGENTS.md', Array.from({ length: 8 }, (_, i) => `- Every job in \`src/jobs/\` must call \`step${i}()\` before \`retryJob\` reads.\n`).join('\n'));
-        write('rigour.yml', 'version: 1\nbrief:\n  max_items: 3\n');
-        const text = JSON.parse(await hooksBriefCommand(payload('s3', 'retry job'), '/')).hookSpecificOutput.additionalContext;
-        expect(text.split('\n').filter(l => /^\d+\. /.test(l))).toHaveLength(3);
-    });
-});
-describe('the edit hook', () => {
-    const edit = (session, file) => JSON.stringify({ cwd: repo, session_id: session, hook_event_name: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: path.join(repo, file) } });
-    it("gives the team's word on a file the first time a session edits it, once per file per session", async () => {
-        const first = JSON.parse(await hooksBriefFileCommand(edit('s1', 'src/jobs/retry.ts'), '/'));
-        expect(first.hookSpecificOutput.hookEventName).toBe('PreToolUse');
-        expect(first.hookSpecificOutput.additionalContext).toContain('Rigour, before you edit src/jobs/retry.ts');
-        expect(first.hookSpecificOutput.additionalContext).toContain('1. [must] Every job in `src/jobs/` must take `withLock()`');
-        expect(await hooksBriefFileCommand(edit('s1', 'src/jobs/retry.ts'), '/')).toBe(''); // the same file again
-        expect(await hooksBriefFileCommand(edit('s2', 'src/jobs/retry.ts'), '/')).not.toBe(''); // another session
-        expect(await hooksBriefFileCommand(edit('s1', 'README.md'), '/')).toBe(''); // nothing applies: nothing said
-        expect(readThread(repo)?.events.map(e => [e.kind, e.file, e.session, e.items])).toEqual([['brief', 'src/jobs/retry.ts', 's1', 1], ['brief', 'src/jobs/retry.ts', 's2', 1], ['brief', 'README.md', 's1', 0]]);
-    });
-    it('places a file being created in a new folder, and says nothing for a file of another repository inside this one', async () => {
-        const created = JSON.parse(await hooksBriefFileCommand(edit('n1', 'src/jobs/new/sweep.ts'), '/'));
-        expect(created.hookSpecificOutput.additionalContext).toContain('Rigour, before you edit src/jobs/new/sweep.ts');
-        fs.mkdirSync(path.join(repo, 'vendor/other'), { recursive: true });
-        execFileSync('git', ['-C', path.join(repo, 'vendor/other'), 'init', '-q']);
-        expect(await hooksBriefFileCommand(edit('n1', 'vendor/other/src/jobs/x.ts'), '/')).toBe('');
-    });
-    it('says nothing for a file outside the repository, a bad payload, or when briefings are switched off', async () => {
-        expect(await hooksBriefFileCommand(JSON.stringify({ cwd: repo, session_id: 's1', tool_input: { file_path: '/etc/hosts' } }), '/')).toBe('');
-        expect(await hooksBriefFileCommand('not json', '/')).toBe('');
-        expect(await hooksBriefFileCommand(JSON.stringify({ cwd: repo, tool_input: { file_path: 'src/jobs/retry.ts' } }), '/')).toBe('');
-        process.env.RIGOUR_BRIEF = 'off';
-        expect(await hooksBriefFileCommand(edit('s3', 'src/jobs/retry.ts'), '/')).toBe('');
-        delete process.env.RIGOUR_BRIEF;
-        write('rigour.yml', 'version: 1\nbrief:\n  enabled: false\n');
-        expect(await hooksBriefFileCommand(edit('s4', 'src/jobs/retry.ts'), '/')).toBe('');
-        expect(readThread(repo)?.events ?? []).toEqual([]);
-    });
-});
-describe('the DLP pre-tool hook with --brief', () => {
-    it("adds the file's briefing to its own answer on a first edit, and nothing on other tools or later edits", async () => {
-        const out = [];
-        vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => (out.push(String(chunk)), true));
-        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const run = async (tool, session) => {
-            out.length = 0;
-            await hooksCheckCommand(repo, { mode: 'dlp', brief: true, files: JSON.stringify({ cwd: repo, session_id: session, tool_name: tool, tool_input: { file_path: path.join(repo, 'src/jobs/retry.ts') } }) });
-            return JSON.parse(out.join(''));
-        };
-        const first = await run('Edit', 'd1');
-        expect(first.status).toBe('clean'); // the DLP answer is unchanged
-        expect(first.hookSpecificOutput).toMatchObject({ hookEventName: 'PreToolUse', additionalContext: expect.stringContaining('Rigour, before you edit src/jobs/retry.ts') });
-        expect((await run('Edit', 'd1')).hookSpecificOutput).toBeUndefined(); // briefed once in the session
-        expect((await run('Read', 'd2')).hookSpecificOutput).toBeUndefined(); // not an edit
-        out.length = 0;
-        await hooksCheckCommand(repo, { mode: 'dlp', files: JSON.stringify({ cwd: repo, session_id: 'd3', tool_name: 'Edit', tool_input: { file_path: path.join(repo, 'src/jobs/retry.ts') } }) });
-        expect(JSON.parse(out.join('')).hookSpecificOutput).toBeUndefined(); // without --brief, DLP only
-    });
-});
-describe('rigour brief', () => {
-    it('prints the briefing as JSON for a goal and files', async () => {
-        const out = [];
-        vi.spyOn(console, 'log').mockImplementation((line) => void out.push(String(line)));
-        expect(await briefCommand(repo, 'retry', { files: 'src/jobs/retry.ts', json: true })).toBe(0);
-        expect(JSON.parse(out.join('\n'))).toMatchObject({ goal: 'retry', files: ['src/jobs/retry.ts'], items: [{ kind: 'rule', requirement: true, cite: 'AGENTS.md' }] });
-    });
-});
-describe('rigour hooks init --brief', () => {
-    it('installs the prompt hook only when asked', async () => {
-        vi.spyOn(console, 'log').mockImplementation(() => undefined);
-        await hooksInitCommand(repo, { tool: 'claude' });
-        const plain = JSON.parse(fs.readFileSync(path.join(repo, '.claude/settings.json'), 'utf8')).hooks;
-        expect(plain.UserPromptSubmit).toBeUndefined();
-        expect(plain.PreToolUse.some((h) => h.matcher === 'Write|Edit|MultiEdit')).toBe(false);
-        await hooksInitCommand(repo, { tool: 'claude', brief: true, force: true });
-        const hook = JSON.parse(fs.readFileSync(path.join(repo, '.claude/settings.json'), 'utf8')).hooks.UserPromptSubmit;
-        expect(hook[0].hooks[0].command).toMatch(/ brief$/);
-        expect(hook[0].hooks[0].timeout).toBe(20);
-        // DLP on (the default): the DLP hook, which already runs before every tool, briefs too; no second process per edit.
-        const pre = JSON.parse(fs.readFileSync(path.join(repo, '.claude/settings.json'), 'utf8')).hooks.PreToolUse;
-        expect(pre.some((h) => h.matcher === 'Write|Edit|MultiEdit')).toBe(false);
-        expect(pre.find((h) => h.matcher === '.*').hooks[0].command).toMatch(/--mode dlp --stdin --brief$/);
-        // DLP off: an edit hook of its own.
-        await hooksInitCommand(repo, { tool: 'claude', brief: true, dlp: false, force: true });
-        const own = JSON.parse(fs.readFileSync(path.join(repo, '.claude/settings.json'), 'utf8')).hooks.PreToolUse.find((h) => h.matcher === 'Write|Edit|MultiEdit');
-        expect(own.hooks[0].command).toMatch(/ brief-file$/);
-    });
-});

package/dist/commands/deep-provider.test.d.ts

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

package/dist/commands/deep-provider.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { deepProvider } from './deep-provider.js';
-import { UsageError } from './review-config.js';
-describe('deepProvider', () => {
-    it('uses the resolved provider when there is a key', () => {
-        expect(deepProvider('openrouter', 'openrouter', 'k')).toEqual({ provider: 'openrouter', apiKey: 'k' });
-        expect(deepProvider(undefined, undefined, 'k')).toEqual({ provider: 'claude', apiKey: 'k' });
-    });
-    it('refuses a named cloud provider with no key instead of switching to the local model', () => {
-        expect(() => deepProvider('openrouter', 'openrouter', undefined)).toThrow(UsageError);
-        expect(() => deepProvider('openrouter', 'openrouter', undefined)).toThrow(/RIGOUR_API_KEY/);
-    });
-    it('runs the built-in model when no provider was named, and a model server on this machine when one was', () => {
-        expect(deepProvider(undefined, 'anthropic', undefined)).toEqual({ provider: 'local' });
-        expect(deepProvider('local', 'local', undefined)).toEqual({ provider: 'local' });
-        expect(deepProvider('Ollama', 'ollama', undefined)).toEqual({ provider: 'ollama', apiKey: 'ollama' });
-        expect(deepProvider('lmstudio', 'lmstudio', undefined)).toEqual({ provider: 'lmstudio', apiKey: 'lmstudio' });
-    });
-});

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

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

package/dist/commands/deep.test.js

@@ -1,46 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-const core = vi.hoisted(() => ({
-    prepare: vi.fn(),
-    findEngine: vi.fn(),
-    getCachedModel: vi.fn(),
-    tiers: [],
-}));
-vi.mock('@rigour-labs/core', () => ({
-    SidecarProvider: class {
-        constructor(tier) { core.tiers.push(tier); }
-        prepare = core.prepare;
-        findEngine = core.findEngine;
-    },
-    getCachedModel: core.getCachedModel,
-}));
-const { deepPullCommand } = await import('./deep.js');
-describe('rigour deep pull', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-        core.tiers.length = 0;
-    });
-    it('prepares the lite tier by default and reports what it installed', async () => {
-        core.prepare.mockResolvedValue(undefined);
-        core.findEngine.mockResolvedValue({ path: '/home/.rigour/bin/llama-b5604/llama-cli', version: '5604' });
-        core.getCachedModel.mockResolvedValue({ info: { name: 'Qwen2.5-Coder-0.5B-Instruct (stock)' } });
-        const log = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-        expect(await deepPullCommand(false)).toBe(0);
-        expect(core.tiers).toEqual(['lite']);
-        expect(log.mock.calls.flat().join('\n')).toContain('llama.cpp 5604');
-        expect(log.mock.calls.flat().join('\n')).toContain('Qwen2.5-Coder-0.5B-Instruct (stock)');
-    });
-    it('prepares the deep tier with --pro', async () => {
-        core.prepare.mockResolvedValue(undefined);
-        core.findEngine.mockResolvedValue(null);
-        core.getCachedModel.mockResolvedValue(null);
-        vi.spyOn(console, 'log').mockImplementation(() => undefined);
-        await deepPullCommand(true);
-        expect(core.tiers).toEqual(['deep']);
-    });
-    it('exits 3 with the reason when the engine or model cannot be installed', async () => {
-        core.prepare.mockRejectedValue(new Error('HTTP 404 for https://github.com/...'));
-        const error = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-        expect(await deepPullCommand(false)).toBe(3);
-        expect(error.mock.calls.flat().join('\n')).toContain('HTTP 404');
-    });
-});

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

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

package/dist/commands/demo.test.js

@@ -1,59 +0,0 @@
-/**
- * Tests for the demo command — all modes: default, --hooks, --cinematic.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { demoCommand } from './demo.js';
-describe('demoCommand', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let consoleSpy;
-    beforeEach(() => {
-        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should run default demo without errors', async () => {
-        await expect(demoCommand({})).resolves.not.toThrow();
-    }, 30_000);
-    it('should run with --hooks flag', async () => {
-        await expect(demoCommand({ hooks: true, speed: 'fast' })).resolves.not.toThrow();
-        // Should show hooks simulation
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('hooks');
-    }, 30_000);
-    it('should run with --cinematic flag at fast speed', async () => {
-        await expect(demoCommand({ cinematic: true, speed: 'fast' })).resolves.not.toThrow();
-        // Cinematic mode should show the before/after flow
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('fix');
-    }, 60_000);
-    it('should produce FAIL status on demo project', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('FAIL');
-    }, 30_000);
-    it('should generate fix packet and audit report', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('Fix packet generated');
-        expect(allOutput).toContain('Audit report exported');
-    }, 30_000);
-    it('should show score bars in output', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        // Score bars use block characters
-        expect(allOutput).toContain('/100');
-    }, 30_000);
-    it('should show whitepaper link in cinematic closing', async () => {
-        await demoCommand({ cinematic: true, speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('zenodo.org');
-    }, 60_000);
-    it('should show hooks init command in closing', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('hooks init');
-    }, 30_000);
-});

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

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

package/dist/commands/doctor.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { detectInstallKind, hasVersionShadowing } from './doctor.js';
-describe('doctor helpers', () => {
-    it('classifies Homebrew paths', () => {
-        expect(detectInstallKind('/opt/homebrew/bin/rigour')).toBe('homebrew');
-        expect(detectInstallKind('/usr/local/bin/rigour')).toBe('homebrew');
-        expect(detectInstallKind('/opt/homebrew/Cellar/rigour/4.0.5/bin/rigour')).toBe('homebrew');
-    });
-    it('classifies npm/global node_modules paths', () => {
-        expect(detectInstallKind('/opt/homebrew/lib/node_modules/@rigour-labs/cli/dist/cli.js')).toBe('npm');
-        expect(detectInstallKind('/Users/test/.nvm/versions/node/v22.0.0/lib/node_modules/@rigour-labs/cli/dist/cli.js')).toBe('npm');
-    });
-    it('returns unknown for unrelated paths', () => {
-        expect(detectInstallKind('/usr/bin/rigour')).toBe('unknown');
-    });
-    it('detects version shadowing only when versions differ', () => {
-        expect(hasVersionShadowing(['4.0.5', '4.0.5'])).toBe(false);
-        expect(hasVersionShadowing(['4.0.5', '2.0.0'])).toBe(true);
-    });
-});

package/dist/commands/exit-codes.test.d.ts

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

package/dist/commands/exit-codes.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { exitCodeFor, EXIT_FAIL, EXIT_INTERNAL_ERROR, EXIT_PASS } from './exit-codes.js';
-const report = (status, deepStatus) => ({
-    status,
-    stats: { duration_ms: 1, ...(deepStatus ? { deep: { enabled: true, status: deepStatus } } : {}) },
-});
-describe('exitCodeFor', () => {
-    it('maps PASS and FAIL to 0 and 1', () => {
-        expect(exitCodeFor(report('PASS'))).toBe(EXIT_PASS);
-        expect(exitCodeFor(report('FAIL'))).toBe(EXIT_FAIL);
-    });
-    it('exits 3 when deep analysis was requested but did not run', () => {
-        expect(exitCodeFor(report('FAIL', 'error'))).toBe(EXIT_INTERNAL_ERROR);
-        expect(exitCodeFor(report('PASS', 'error'))).toBe(EXIT_INTERNAL_ERROR);
-    });
-    it('keeps the normal code for completed or partial deep runs', () => {
-        expect(exitCodeFor(report('PASS', 'ok'))).toBe(EXIT_PASS);
-        expect(exitCodeFor(report('FAIL', 'partial'))).toBe(EXIT_FAIL);
-    });
-});

package/dist/commands/export-training-sites.test.d.ts

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

package/dist/commands/export-training-sites.test.js

@@ -1,25 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { exportTrainingSitesCommand } from './export-training-sites.js';
-describe('rigour export-training-sites', () => {
-    let repo;
-    afterEach(() => { if (repo)
-        fs.rmSync(repo, { recursive: true, force: true }); repo = undefined; vi.restoreAllMocks(); });
-    it('writes one JSON line per awaited call in tracked source files, skipping tests', () => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'sites-cli-'));
-        execFileSync('git', ['init', '-q'], { cwd: repo });
-        fs.mkdirSync(path.join(repo, 'src'));
-        fs.writeFileSync(path.join(repo, 'src/load.ts'), 'declare function get(): Promise<number>;\nexport async function load() { return await get(); }\n');
-        fs.writeFileSync(path.join(repo, 'src/load.test.ts'), 'declare function get(): Promise<number>;\nexport async function t() { return await get(); }\n');
-        execFileSync('git', ['add', '-A'], { cwd: repo });
-        const out = [];
-        vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out.push(String(chunk)); return true; });
-        exportTrainingSitesCommand(repo, []);
-        const sites = out.join('').trim().split('\n').map(line => JSON.parse(line));
-        expect(sites).toEqual([expect.objectContaining({ file: 'src/load.ts', function: 'load', callee: 'get', ordinal: 0, handledBy: null, line: 2 })]);
-        expect(sites[0].source).toContain('return await get()');
-    });
-});

package/dist/commands/hooks-check-repos.test.d.ts

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

package/dist/commands/hooks-check-repos.test.js

@@ -1,33 +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 } from 'vitest';
-import { groupFilesByRepo, hookFindings } from './hooks-check-repos.js';
-let base;
-const repo = (name) => {
-    const dir = path.join(base, name);
-    fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
-    execFileSync('git', ['init', '-q', dir]);
-    return fs.realpathSync.native(dir);
-};
-beforeEach(() => { base = fs.mkdtempSync(path.join(os.tmpdir(), 'hook-repos-')); });
-afterEach(() => fs.rmSync(base, { recursive: true, force: true }));
-describe('groupFilesByRepo', () => {
-    it("checks each file in its own repository, not the session's", () => {
-        const app = repo('app');
-        const lib = repo('lib');
-        const groups = groupFilesByRepo(app, ['src/a.ts', path.join(lib, 'src/b.ts')]);
-        expect(groups).toEqual([{ root: app, files: ['src/a.ts'] }, { root: lib, files: ['src/b.ts'] }]);
-    });
-});
-describe('hookFindings', () => {
-    it('keeps code findings and drops findings about the write itself', () => {
-        const result = { status: 'fail', duration_ms: 1, failures: [
-                { gate: 'security-patterns', file: 'src/a.ts', message: 'Hard-coded secret', severity: 'critical', line: 3 },
-                { gate: 'file-guard', file: '.rigour/dismissed.json', message: 'BLOCKED', severity: 'critical' },
-                { gate: 'file-size', file: 'src/big.ts', message: 'Too long', severity: 'low' },
-            ] };
-        expect(hookFindings(result)).toEqual([expect.objectContaining({ id: 'security-patterns', title: 'Hard-coded secret', files: ['src/a.ts'], line: 3 })]);
-    });
-});

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

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

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

@@ -1,64 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { gitPushGateCommand, installGitPushHook, selfTestCommand, selfTestGitPushHook } from './hooks-git.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const bin = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../dist/bin.js');
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'git-hook-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    git('config', 'core.hooksPath', '.git/hooks'); // a machine-wide hooks path must not reach the test
-    fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-    fs.writeFileSync(path.join(repo, 'rigour.yml'), 'version: 1\ngates:\n  unused_exports:\n    block: true\n'); // this team blocks on dead code
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('the git pre-push hook', () => {
-    it('is installed where git looks, once, and completes a hook another tool owns instead of replacing it', () => {
-        const first = installGitPushHook(repo, 'npx --yes @rigour-labs/cli@9.9.9');
-        expect(first.action).toBe('installed');
-        const text = fs.readFileSync(first.path, 'utf8');
-        expect(text).toContain('exec npx --yes @rigour-labs/cli@9.9.9 hooks push --git "$@"');
-        if (process.platform !== 'win32')
-            expect(fs.statSync(first.path).mode & 0o111).toBeTruthy(); // no execute bit on Windows
-        expect(installGitPushHook(repo, 'npx --yes @rigour-labs/cli@9.9.9').action).toBe('present');
-        git('config', 'core.hooksPath', '.husky');
-        fs.mkdirSync(path.join(repo, '.husky'));
-        fs.writeFileSync(path.join(repo, '.husky/pre-push'), '#!/bin/sh\nnpm test\n');
-        const appended = installGitPushHook(repo, 'rigour');
-        expect(appended).toMatchObject({ action: 'appended', path: path.join(repo, '.husky/pre-push') });
-        expect(fs.readFileSync(appended.path, 'utf8')).toBe('#!/bin/sh\nnpm test\n\n# Rigour push gate (rigour hooks init): the same gate for every tool and the terminal.\nrigour hooks push --git "$@" || exit $?\n');
-        expect(installGitPushHook(repo, 'rigour').action).toBe('present');
-        expect(installGitPushHook(path.join(os.tmpdir()), 'rigour').action).toBe('no repository');
-        // A hooks directory outside the repository belongs to whoever set it: named, never written.
-        const elsewhere = fs.mkdtempSync(path.join(os.tmpdir(), 'global-hooks-'));
-        fs.writeFileSync(path.join(elsewhere, 'pre-push'), '#!/bin/sh\nexit 0\n');
-        git('config', 'core.hooksPath', elsewhere);
-        expect(installGitPushHook(repo, 'rigour')).toEqual({ path: path.join(elsewhere, 'pre-push'), action: 'managed elsewhere' });
-        expect(fs.readFileSync(path.join(elsewhere, 'pre-push'), 'utf8')).toBe('#!/bin/sh\nexit 0\n');
-        fs.rmSync(elsewhere, { recursive: true, force: true });
-    });
-    it('refuses a push from a tree with uncommitted changes to tracked files, and lets a branch deletion through', async () => {
-        const refs = `refs/heads/main ${git('rev-parse', 'HEAD')} refs/heads/main 0000000000000000000000000000000000000000\n`;
-        fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 2;\n');
-        const dirty = await gitPushGateCommand(refs, repo);
-        expect(dirty.exitCode).toBe(1);
-        expect(dirty.message).toContain('uncommitted changes to tracked files');
-        expect(dirty.message).toContain(' M a.ts');
-        const deletion = await gitPushGateCommand('(delete) 0000000000000000000000000000000000000000 refs/heads/old 1234567890123456789012345678901234567890\n', repo);
-        expect(deletion).toEqual({ exitCode: 0, message: '' });
-    });
-    it('holds under a real git push: a change the gate must refuse is refused, the fix lands, read from the remote', async () => {
-        const result = await selfTestGitPushHook(selfTestCommand(bin));
-        expect(result.steps.join('\n')).toContain('was refused');
-        expect(result).toMatchObject({ ok: true });
-    }, 120_000);
-});

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

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

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

@@ -1,89 +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 } from 'vitest';
-import { readThread } from '@rigour-labs/core';
-import { hooksPushCommand, isPush, pushTarget } from './hooks-push.js';
-describe('push command parsing', () => {
-    it('acts on a real push only', () => {
-        expect(isPush('git push -u origin feature')).toBe(true);
-        expect(isPush('cd app && git -C . push')).toBe(true);
-        expect(isPush('git push --dry-run')).toBe(false);
-        expect(isPush('git status && npm test')).toBe(false);
-        expect(isPush('echo "do not git pushx"')).toBe(false);
-        expect(isPush('claude -p review --disallowedTools "Bash(git push:*)"')).toBe(false); // text inside an argument
-        expect(isPush('npm test && git push origin main')).toBe(true);
-        expect(isPush('git -C "/work/my app" push')).toBe(true);
-    });
-    it('finds the repository the push runs in', () => {
-        expect(pushTarget('cd /work/app && git push')).toBe('/work/app');
-        expect(pushTarget('git -C "/work/my app" push')).toBe('/work/my app');
-        expect(pushTarget('git push')).toBeUndefined();
-    });
-});
-describe('rigour hooks push', () => {
-    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);
-    };
-    const push = (command = 'git push') => hooksPushCommand(JSON.stringify({ cwd: repo, tool_input: { command } }), '/');
-    beforeEach(() => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'push-gate-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        write('.gitignore', '.rigour/\nnode_modules/\n');
-        write('src/main.ts', "import { used } from './util';\nconsole.log(used);\n");
-        write('src/util.ts', 'export const used = 1;\n');
-        write('package.json', '{"scripts":{"start":"node src/main.ts"}}\n');
-        write('rigour.yml', 'version: 1\ngates:\n  unused_exports:\n    block: true\n'); // this team blocks on dead code
-        git('add', '-A');
-        git('commit', '-qm', 'init');
-        git('checkout', '-q', '-b', 'feature');
-    });
-    afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-    it('lets any other command, and a clean branch, through', async () => {
-        expect(await push('npm test')).toEqual({ exitCode: 0, message: '' });
-        write('src/util.ts', 'export const used = 2;\n');
-        git('commit', '-qam', 'tweak');
-        expect(await push()).toEqual({ exitCode: 0, message: '' });
-    });
-    it('blocks a push when a check could not run: a TypeScript project whose program cannot be built', async () => {
-        write('tsconfig.json', '{"extends":"./.generated/tsconfig.json"}\n');
-        write('src/util.ts', 'export const used = 2;\n');
-        git('add', '-A');
-        git('commit', '-qm', 'typed change, broken config');
-        const result = await push();
-        expect(result.exitCode).toBe(2);
-        expect(result.message).toContain('- typed-checks-unavailable could not run: ');
-        expect(result.message).toContain('.generated/tsconfig.json');
-        // The task's thread keeps the blocked push.
-        expect(readThread(repo, 'feature')?.events.map(e => [e.kind, e.passed, e.failed])).toEqual([['push', false, 1]]);
-    });
-    it('blocks a push that adds an export nothing uses, saying where', async () => {
-        write('src/util.ts', 'export const used = 1;\nexport const forgotten = 2;\n');
-        git('commit', '-qam', 'add forgotten');
-        const result = await push();
-        expect(result.exitCode).toBe(2);
-        expect(result.message).toContain('Push blocked');
-        expect(result.message).toContain('src/util.ts:2 Unused export');
-    });
-    it("blocks a push the project's own formatter rejects, and keeps the output in a log", async () => {
-        const bin = path.join(repo, 'node_modules', '.bin');
-        fs.mkdirSync(bin, { recursive: true });
-        fs.writeFileSync(path.join(bin, 'prettier.js'), "console.log('[warn] src/util.ts'); process.exit(1);\n");
-        fs.writeFileSync(path.join(bin, 'prettier'), '#!/bin/sh\nexec node "$(dirname "$0")/prettier.js" "$@"\n', { mode: 0o755 });
-        fs.writeFileSync(path.join(bin, 'prettier.cmd'), '@node "%~dp0\\prettier.js" %*\r\n');
-        write('src/util.ts', 'export const used =   3;\n');
-        git('commit', '-qam', 'unformatted');
-        const result = await push();
-        expect(result.exitCode).toBe(2);
-        expect(result.message).toContain('- format failed: prettier --check');
-        const log = result.message.match(/full output: (\S+)\)/)[1];
-        expect(fs.readFileSync(log, 'utf8')).toContain('[warn] src/util.ts');
-    });
-});

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

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