@rigour-labs/cli 6.8.0 → 6.8.1

package/dist/commands/studio-learning.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildLearning, readableFixLesson } from './studio-learning.js';
-const now = new Date('2026-10-09T12:00:00Z');
-const lesson = {
-    id: 'l1', repositoryId: 'r', visibility: 'team', state: 'validated', kind: 'fix',
-    subject: 'Fixed before: Credential header follows redirects (semantic-bugs). The cookie reaches fetch.',
-    evidence: { files: ['src/a.ts', 'src/b.ts'] }, confidence: 1, source: 'fix', createdAt: Date.parse('2026-09-20T00:00:00Z'), updatedAt: 0,
-};
-const story = (at, stage = 'edit') => ({ id: at, at, stage, file: 'src/c.ts', rule: 'semantic-bugs', title: 'Credential header follows redirects', diff: [] });
-describe('buildLearning', () => {
-    it("follows a lesson from where it was learned to the repeats it stopped", () => {
-        const events = [
-            { type: 'lessons_served', timestamp: '2026-10-01T00:00:00Z', via: 'recall', lessons: [lesson.subject] },
-            { type: 'lessons_served', timestamp: '2026-10-02T00:00:00Z', via: 'review', lessons: [lesson.subject, 'other'] },
-        ];
-        const learning = buildLearning({ now, lessons: [lesson], reviewLessons: [], stories: [story('2026-09-19T00:00:00Z', 'stop'), story('2026-10-05T00:00:00Z')], events });
-        expect(learning.lessons[0]).toMatchObject({
-            text: 'Credential header follows redirects: The cookie reaches fetch.',
-            origin: 'development', learnedFrom: '2 fixes as an agent tried to finish', scope: 'team',
-            told: 2, stoppedInDevelopment: 1, reachedPr: null,
-        });
-        expect(learning.prRecorded).toBe(false);
-        expect(learning.weeks.map(w => [w.stoppedInDevelopment, w.reachedPr])).toEqual([[0, null], [0, null], [0, null], [1, null]]);
-    });
-    it('counts repeats that reached a PR once branch reviews are recorded here', () => {
-        const events = [{ type: 'pr_catches', timestamp: '2026-10-08T00:00:00Z', findings: [{ rule: 'semantic-bugs', title: 'Credential header follows redirects', file: 'src/d.ts' }] }];
-        const learning = buildLearning({ now, lessons: [lesson], reviewLessons: [], stories: [], events });
-        expect(learning.lessons[0].reachedPr).toBe(1);
-        expect(learning.weeks[3].reachedPr).toBe(1);
-    });
-    it('does not repeat the title when the detail says the same thing', () => {
-        const same = { ...lesson, subject: 'Fixed before: Stripe API key detected in code (security-patterns). Stripe API key detected in code.' };
-        expect(buildLearning({ now, lessons: [same], reviewLessons: [], stories: [], events: [] }).lessons[0].text).toBe('Stripe API key detected in code');
-    });
-    it('shows a lesson once, in words, without a truncated title or rule tag', () => {
-        expect(readableFixLesson("Fixed before: [credential-redirect] The `x-hook-signature` header is sent through `fetch(endpoint, { method: 'POST', headers: { 'x-h…` (semantic-bugs). [credential-redirect] The `x-hook-signature` header is sent through `fetch(endpoint, { method: 'POST', headers: { 'x-hook-signature': signature } })` without `redirect: \"manual\"`."))
-            .toBe("The `x-hook-signature` header is sent through `fetch(endpoint, { method: 'POST', headers: { 'x-hook-signature': signature } })` without `redirect: \"manual\"`");
-        const twice = [lesson, { ...lesson, id: 'l2', visibility: 'personal' }];
-        expect(buildLearning({ now, lessons: twice, reviewLessons: [], stories: [], events: [] }).lessons).toHaveLength(1);
-    });
-});

package/dist/commands/studio-progress.test.d.ts

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

package/dist/commands/studio-progress.test.js

@@ -1,41 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { describe, expect, it } from 'vitest';
-import { buildProgress, precisionsAcross } from './studio-progress.js';
-const now = new Date('2026-10-09T12:00:00Z');
-const story = (openedAt, at) => ({ id: at, at, openedAt, stage: 'edit', file: 'a.ts', rule: 'r', title: 't', diff: [] });
-const learning = {
-    prRecorded: false,
-    weeks: [{ from: '2026-09-25T12:00:00Z', stoppedInDevelopment: 0, reachedPr: null }, { from: '2026-10-02T12:00:00Z', stoppedInDevelopment: 2, reachedPr: null }],
-    lessons: [
-        { id: 'a', text: 'Never follow redirects with credentials', origin: 'development', learnedFrom: '', learnedAt: '2026-09-26T00:00:00Z', state: 'validated', scope: 'team', told: 3, stoppedInDevelopment: 2, reachedPr: null, canDecide: false },
-        { id: 'b', text: 'Amounts are cents', origin: 'development', learnedFrom: '', learnedAt: '2026-10-05T00:00:00Z', state: 'candidate', scope: 'this repo', told: 0, stoppedInDevelopment: 0, reachedPr: null, canDecide: true },
-    ],
-};
-describe('buildProgress', () => {
-    it('reports each week from records: stopped, overruled, median time to fix, lessons so far', () => {
-        const progress = buildProgress({
-            now,
-            stories: [story('2026-10-03T10:00:00Z', '2026-10-03T10:02:00Z'), story('2026-10-04T10:00:00Z', '2026-10-04T10:10:00Z'), story('2026-09-27T09:00:00Z', '2026-09-27T09:04:00Z')],
-            dismissals: [{ key: 'k', reason: 'x', at: '2026-10-05T00:00:00Z' }],
-            learning,
-            checks: [],
-        });
-        expect(progress.weeks).toEqual([
-            { from: '2026-09-25T12:00:00Z', stopped: 1, overruled: 0, repeatsStopped: 0, repeatsReachedPr: null, minutesToFix: 4, lessons: 1 },
-            { from: '2026-10-02T12:00:00Z', stopped: 2, overruled: 1, repeatsStopped: 2, repeatsReachedPr: null, minutesToFix: 6, lessons: 2 },
-        ]);
-        expect(progress.topLessons.map(l => l.id)).toEqual(['a']);
-    });
-    it('ranks checks by how often their findings were acted on, summed over every checkout', () => {
-        const roots = [0, 1].map(() => fs.mkdtempSync(path.join(os.tmpdir(), 'progress-')));
-        roots.forEach((root, i) => {
-            fs.mkdirSync(path.join(root, '.rigour'));
-            fs.writeFileSync(path.join(root, '.rigour', 'check-outcomes.json'), JSON.stringify({ 'security-patterns: Key': { fixed: 2 + i, dismissed: 0 }, 'ast: Too complex': { fixed: 0, dismissed: 3 } }));
-        });
-        const checks = buildProgress({ now, stories: [], dismissals: [], learning, checks: precisionsAcross(roots) }).checks;
-        expect(checks.map(c => [c.check, c.fixed, c.dismissed, c.muted])).toEqual([['security-patterns: Key', 5, 0, false], ['ast: Too complex', 0, 6, true]]);
-        roots.forEach(root => fs.rmSync(root, { recursive: true, force: true }));
-    });
-});

package/dist/commands/studio-reviewer.test.d.ts

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

package/dist/commands/studio-reviewer.test.js

@@ -1,92 +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 { dismissFromStudio, loadStudioReviewer, saveStudioReviewer, saveTeamReviewer } from './studio-reviewer.js';
-let repo;
-let home;
-const savedHome = process.env.RIGOUR_HOME;
-beforeEach(() => {
-    // A home of its own for the person's settings: the shared test home is never written by another test's choice.
-    home = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-home-reviewer-'));
-    process.env.RIGOUR_HOME = home;
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'studio-reviewer-'));
-    const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-    git('init', '-q', '-b', 'feature');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('commit', '-q', '--allow-empty', '-m', 'init');
-});
-afterEach(() => {
-    process.env.RIGOUR_HOME = savedHome;
-    for (const dir of [repo, home])
-        fs.rmSync(dir, { recursive: true, force: true });
-});
-describe('the reviewer in Studio', () => {
-    it('shows the defaults, where each value comes from, and which agent CLIs exist', async () => {
-        const view = await loadStudioReviewer(repo);
-        expect(view).toMatchObject({ branch: 'feature', teamFile: false, user: {}, effective: { enabled: false, mode: 'single', panel: false, source: { mode: 'team', panel: 'team' } } });
-        expect(view.team).toMatchObject({ mode: 'single', panel: 'off', judges: 2, escalate: 'always' });
-        expect(view.available.map(a => a.name)).toEqual(['claude', 'cursor', 'codex']);
-    });
-    it('saves a person\'s own choice, applies it over the team\'s, and goes back to the team\'s on null', async () => {
-        const on = await saveStudioReviewer(repo, { enabled: true, panel: true, judges: 3 });
-        expect(on.user).toEqual({ enabled: true, panel: true, judges: 3 });
-        expect(on.effective).toMatchObject({ enabled: true, mode: 'full', panel: true, judges: 3, source: { panel: 'user' } });
-        const back = await saveStudioReviewer(repo, { panel: null });
-        expect(back.user).toEqual({ enabled: true, judges: 3 });
-        expect(back.effective.panel).toBe(false);
-    });
-    it('refuses what a person cannot set, and the team\'s floor still wins over a person\'s choice', async () => {
-        await expect(saveStudioReviewer(repo, { mode_required: false })).rejects.toThrow('not a reviewer setting a person can change: mode_required');
-        await expect(saveStudioReviewer(repo, { judges: 4 })).rejects.toThrow('judges is 2 or 3');
-        fs.writeFileSync(path.join(repo, 'rigour.yml'), 'version: 1\nreview:\n  reviewer:\n    mode: full\n    panel: required\n');
-        const view = await saveStudioReviewer(repo, { panel: false });
-        expect(view.teamFile).toBe(true);
-        expect(view.effective).toMatchObject({ panel: true, required: { panel: true } });
-        expect(view.effective.refused).toEqual(['panel off (user) refused: rigour.yml sets review.reviewer.panel: required']);
-    });
-    it('dismisses only with a finding id and a reason', async () => {
-        await expect(dismissFromStudio(repo, { id: 'nope', reason: 'whatever it is' })).rejects.toThrow('reviewer finding id');
-        await expect(dismissFromStudio(repo, { id: 'abcdef0123', reason: 'no' })).rejects.toThrow('say why');
-        await expect(dismissFromStudio(repo, { id: 'abcdef0123', reason: 'the lock is one level up' })).rejects.toThrow('this team does not dismiss reviewer findings');
-        fs.writeFileSync(path.join(repo, 'rigour.yml'), 'version: 1\nreview:\n  reviewer:\n    dismissals: true\n');
-        await expect(dismissFromStudio(repo, { id: 'abcdef0123', reason: 'the lock is one level up' })).rejects.toThrow('no open reviewer finding abcdef0123 on feature');
-    });
-    it('edits the team\'s rigour.yml in place, comments kept, and shows the diff to commit', async () => {
-        const yml = '# Team gates\nversion: 1\nreview:\n  reviewer:\n    # agreed in the retro\n    mode: single\n';
-        fs.writeFileSync(path.join(repo, 'rigour.yml'), yml);
-        execFileSync('git', ['-C', repo, 'add', 'rigour.yml']);
-        execFileSync('git', ['-C', repo, 'commit', '-qm', 'team config']);
-        const view = await saveTeamReviewer(repo, { patch: { mode: 'full', panel: 'required', judges: 3 } });
-        const after = fs.readFileSync(path.join(repo, 'rigour.yml'), 'utf8');
-        expect(after).toContain('# Team gates');
-        expect(after).toContain('# agreed in the retro');
-        expect(after).toMatch(/mode: full[\s\S]*panel: required[\s\S]*judges: 3/);
-        expect(view.diff).toContain('-    mode: single');
-        expect(view.diff).toContain('+    panel: required');
-        expect(view.effective).toMatchObject({ mode: 'full', panel: true, judges: 3, required: { panel: true } });
-        await saveTeamReviewer(repo, { patch: { judges: null } });
-        expect(fs.readFileSync(path.join(repo, 'rigour.yml'), 'utf8')).not.toContain('judges');
-    });
-    it('refuses a team write that would break rigour.yml, touches other sections, or creates the file unasked', async () => {
-        await expect(saveTeamReviewer(repo, { patch: { mode: 'full' } })).rejects.toThrow('there is no rigour.yml');
-        expect(fs.existsSync(path.join(repo, 'rigour.yml'))).toBe(false);
-        const created = await saveTeamReviewer(repo, { patch: { enabled: true }, create: true });
-        expect(created.teamFile).toBe(true);
-        expect(created.diff).toContain('+review:');
-        expect(created.diff).not.toContain('version');
-        await expect(saveTeamReviewer(repo, { patch: { gates: {} } })).rejects.toThrow('not a team reviewer setting: gates');
-        await expect(saveTeamReviewer(repo, { patch: { judges: 7 } })).rejects.toThrow('that would not be a valid rigour.yml');
-        expect(fs.readFileSync(path.join(repo, 'rigour.yml'), 'utf8')).not.toContain('judges');
-    });
-    it('refuses a linked rigour.yml and a model name a CLI would read as a flag', async () => {
-        const elsewhere = path.join(home, 'elsewhere.yml');
-        fs.writeFileSync(elsewhere, 'version: 1\n');
-        fs.symlinkSync(elsewhere, path.join(repo, 'rigour.yml'));
-        await expect(saveTeamReviewer(repo, { patch: { enabled: true } })).rejects.toThrow('rigour.yml is a link');
-        expect(fs.readFileSync(elsewhere, 'utf8')).toBe('version: 1\n');
-        await expect(saveStudioReviewer(repo, { models: { claude: '--dangerously-skip-permissions' } })).rejects.toThrow('not starting with -');
-    });
-});

package/dist/commands/studio-week.test.d.ts

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

package/dist/commands/studio-week.test.js

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildWeek } from './studio-week.js';
-import { reviewFixStory } from './studio-checkouts.js';
-const now = new Date('2026-10-09T12:00:00Z');
-const story = (at, stage) => ({ id: at, at, stage, file: 'src/a.ts', rule: 'semantic-bugs', title: 'T', diff: [] });
-describe('buildWeek', () => {
-    it('counts only this week, by the stage that caught it, and says how far the record goes back', () => {
-        const week = buildWeek({
-            now,
-            stories: [story('2026-09-20T00:00:00Z', 'edit'), story('2026-10-05T00:00:00Z', 'edit'), story('2026-10-06T00:00:00Z', 'stop'), story('2026-10-07T00:00:00Z', 'review')],
-            open: [{ file: 'src/b.ts', rule: 'semantic-bugs', title: 'Open one', openedAt: '2026-10-08T00:00:00Z' }],
-            dismissals: [{ key: 'k', reason: 'intended', at: '2026-10-08T00:00:00Z' }, { key: 'old', reason: 'x', at: '2026-09-01T00:00:00Z' }],
-            events: [],
-        });
-        expect(week.recordingSince).toBe('2026-09-20T00:00:00Z');
-        expect(week.stopped).toEqual({ total: 3, byStage: { edit: 1, review: 1, stop: 1, pr: 0 } });
-        expect(week.agentSaidDone).toBe(1);
-        expect(week.stories.map(s => s.at)).toEqual(['2026-10-07T00:00:00Z', '2026-10-06T00:00:00Z', '2026-10-05T00:00:00Z']);
-        expect([week.raised, week.overruled]).toEqual([5, 1]);
-        expect(week.needs).toEqual([expect.objectContaining({ title: 'Open one' })]);
-    });
-    it('reports PR catches as unknown, not zero, when no branch review was ever recorded here', () => {
-        expect(buildWeek({ now, stories: [], open: [], dismissals: [], events: [] }).prCatches).toBeNull();
-        const events = [{ type: 'pr_catches', timestamp: '2026-10-08T00:00:00Z', findings: [{ rule: 'r', title: 't', file: 'f' }] }];
-        expect(buildWeek({ now, stories: [], open: [], dismissals: [], events }).prCatches).toBe(1);
-    });
-    it('counts a function an agent fixed in a pre-PR review as a problem stopped', () => {
-        const fix = reviewFixStory({ file: 'src/insights.ts', function: 'loadDiagnosis', hash: 'h', reviewer: 'agent', verdict: 'fixed', note: 'Six positional parameters replaced by one options object.', at: '2026-10-08T00:00:00Z' });
-        expect(fix).toMatchObject({ stage: 'review', title: 'Six positional parameters replaced by one options object (in `loadDiagnosis`)', diff: [] });
-        expect(buildWeek({ now, stories: [fix], open: [], dismissals: [], events: [] }).stopped.byStage.review).toBe(1);
-    });
-});

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

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

package/dist/commands/thread.test.js

@@ -1,32 +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 { appendTaskEvent } from '@rigour-labs/core';
-import { threadCommand } from './thread.js';
-let repo;
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'thread-cli-'));
-    execFileSync('git', ['-C', repo, 'init', '-q', '-b', 'feat/PROJ-9-thing']);
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(repo, { recursive: true, force: true });
-});
-describe('rigour thread', () => {
-    it('prints the thread, as text or JSON, and exits 1 with a reason when there is none', () => {
-        const out = [];
-        vi.spyOn(console, 'log').mockImplementation((line) => void out.push(String(line)));
-        vi.spyOn(console, 'error').mockImplementation((line) => void out.push(String(line)));
-        expect(threadCommand(repo, 'feat/PROJ-9-thing', {})).toBe(1);
-        expect(out.join('\n')).toContain('no thread for feat/PROJ-9-thing');
-        appendTaskEvent(repo, { kind: 'push', passed: true, failed: 0 });
-        out.length = 0;
-        expect(threadCommand(repo, undefined, {})).toBe(0);
-        expect(out[0]).toContain('branch:feat/PROJ-9-thing'); // no commit names the ticket yet
-        out.length = 0;
-        expect(threadCommand(repo, 'feat/PROJ-9-thing', { json: true })).toBe(0);
-        expect(JSON.parse(out.join('\n'))).toMatchObject({ task: 'branch:feat/PROJ-9-thing', events: [{ kind: 'push', passed: true }] });
-    });
-});

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

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

package/dist/commands/uninstall.test.js

@@ -1,104 +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 { installGitPushHook } from './hooks-git.js';
-import { initCommand } from './init.js';
-import { uninstall } from './uninstall.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const read = (rel) => fs.readFileSync(path.join(repo, rel), 'utf8');
-const write = (rel, body) => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-/** Every file in the working tree (and the pre-push hook), with its content: the repository as a person would compare it. */
-function snapshot() {
-    const files = {};
-    const walk = (dir) => {
-        for (const entry of fs.readdirSync(path.join(repo, dir), { withFileTypes: true })) {
-            const rel = path.posix.join(dir, entry.name);
-            if (rel === '.git' || rel.startsWith('.rigour'))
-                continue;
-            if (entry.isDirectory())
-                walk(rel);
-            else
-                files[rel] = read(rel);
-        }
-    };
-    walk('.');
-    const hook = path.join(repo, '.git/hooks/pre-push');
-    if (fs.existsSync(hook))
-        files['.git/hooks/pre-push'] = fs.readFileSync(hook, 'utf8');
-    return files;
-}
-const OWN_SETTINGS = JSON.stringify({ permissions: { allow: ['Bash(ls)'] }, env: { FOO: '1' }, hooks: { PostToolUse: [{ matcher: 'Write', hooks: [{ type: 'command', command: 'npm run format' }] }] } }, null, 2);
-const OWN_MCP = JSON.stringify({ mcpServers: { docs: { command: 'docs-server' } } }, null, 2);
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'uninstall-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'core.hooksPath', '.git/hooks');
-    write('package.json', JSON.stringify({ name: 'app' }));
-    write('.gitignore', 'node_modules\n');
-    write('AGENTS.md', '# Our own agent rules\n');
-    write('.claude/settings.json', OWN_SETTINGS);
-    write('.mcp.json', OWN_MCP);
-    vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    vi.spyOn(console, 'error').mockImplementation(() => undefined);
-    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(repo, { recursive: true, force: true });
-});
-describe('rigour uninstall', () => {
-    it('after init, takes out exactly what Rigour put in: the repository is as it was, rigour.yml and .rigour/ aside', async () => {
-        const before = snapshot();
-        await initCommand(repo, { instructions: true });
-        // What init did to the person's own files: merged, never replaced.
-        const settings = JSON.parse(read('.claude/settings.json'));
-        expect(settings.permissions).toEqual({ allow: ['Bash(ls)'] });
-        expect(settings.env).toEqual({ FOO: '1' });
-        expect(settings.mcpServers).toBeUndefined(); // Claude Code reads MCP servers from .mcp.json
-        expect(JSON.stringify(settings.hooks)).toContain('npm run format');
-        expect(JSON.stringify(settings.hooks)).toMatch(/hooks check/);
-        expect(Object.keys(JSON.parse(read('.mcp.json')).mcpServers)).toEqual(['docs', 'rigour']);
-        expect(read('AGENTS.md')).toBe('# Our own agent rules\n'); // the team's own instructions are kept
-        expect(fs.existsSync(path.join(repo, 'CLAUDE.md'))).toBe(true);
-        expect(read('.git/hooks/pre-push')).toContain('hooks push --git');
-        const dry = uninstall(repo, { dryRun: true });
-        expect(dry.changes.length).toBeGreaterThan(3); // Claude Code's hooks, .mcp.json, CLAUDE.md, the git hook
-        expect(snapshot()['.claude/settings.json']).toBe(read('.claude/settings.json')); // a dry run changes nothing
-        uninstall(repo);
-        const after = snapshot();
-        const expected = { ...before, 'rigour.yml': after['rigour.yml'], '.gitignore': after['.gitignore'] };
-        for (const rel of Object.keys(expected))
-            if (rel.endsWith('.json'))
-                expected[rel] = JSON.stringify(JSON.parse(expected[rel]), null, 4) + '\n';
-        expect(Object.keys(after).sort()).toEqual(Object.keys(expected).sort());
-        expect(JSON.parse(after['.claude/settings.json'])).toEqual(JSON.parse(OWN_SETTINGS));
-        expect(JSON.parse(after['.mcp.json'])).toEqual(JSON.parse(OWN_MCP));
-        expect(after['AGENTS.md']).toBe('# Our own agent rules\n');
-        // --all: rigour.yml, .rigour/ and the .gitignore lines go too.
-        uninstall(repo, { all: true });
-        expect(fs.existsSync(path.join(repo, 'rigour.yml'))).toBe(false);
-        expect(fs.existsSync(path.join(repo, '.rigour'))).toBe(false);
-        expect(read('.gitignore')).toBe('node_modules\n');
-    });
-    it('keeps a file Rigour created that the person has since edited, and says so', async () => {
-        await initCommand(repo, { instructions: true });
-        fs.appendFileSync(path.join(repo, 'CLAUDE.md'), '\n## Our addition\n');
-        const report = uninstall(repo);
-        expect(fs.existsSync(path.join(repo, 'CLAUDE.md'))).toBe(true);
-        expect(report.kept).toContainEqual('CLAUDE.md: edited since Rigour created it');
-    });
-    it('removes only its own lines from a pre-push hook another tool owns', () => {
-        write('.husky/pre-push', '#!/bin/sh\nnpm test\n');
-        git('config', 'core.hooksPath', '.husky');
-        installGitPushHook(repo, 'rigour');
-        expect(read('.husky/pre-push')).toContain('hooks push --git');
-        uninstall(repo);
-        expect(read('.husky/pre-push')).toBe('#!/bin/sh\nnpm test\n');
-    });
-});

package/dist/init-rules.test.d.ts

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

package/dist/init-rules.test.js

@@ -1,55 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-import { initCommand } from './commands/init.js';
-describe('rigour init: agents and instruction files', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-init-rules-'));
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-    });
-    afterEach(async () => {
-        vi.restoreAllMocks();
-        await fs.remove(testDir);
-    });
-    it('writes one AGENTS.md and a CLAUDE.md that imports it, and nothing per agent', async () => {
-        await initCommand(testDir, { instructions: true });
-        expect(await fs.readFile(path.join(testDir, 'AGENTS.md'), 'utf-8')).toContain('rigour review --base origin/main');
-        expect(await fs.readFile(path.join(testDir, 'CLAUDE.md'), 'utf-8')).toBe('@AGENTS.md\n');
-        for (const rel of ['docs/AGENT_INSTRUCTIONS.md', '.cursor/rules/rigour.mdc', '.clinerules/rigour.md', '.windsurfrules', '.gemini/styleguide.md']) {
-            expect(await fs.pathExists(path.join(testDir, rel)), rel).toBe(false);
-        }
-    });
-    it("keeps the team's own instruction files and says what to add", async () => {
-        await fs.writeFile(path.join(testDir, 'AGENTS.md'), '# Ours\n');
-        await fs.writeFile(path.join(testDir, 'CLAUDE.md'), '# Ours too\n');
-        await initCommand(testDir, { instructions: true });
-        expect(await fs.readFile(path.join(testDir, 'AGENTS.md'), 'utf-8')).toBe('# Ours\n');
-        expect(await fs.readFile(path.join(testDir, 'CLAUDE.md'), 'utf-8')).toBe('# Ours too\n');
-        const said = vi.mocked(console.log).mock.calls.flat().join('\n');
-        expect(said).toContain("Kept your AGENTS.md: add Rigour's section");
-        expect(said).toContain('add a line "@AGENTS.md"');
-    });
-    it('sets up only the agents the repository uses: Claude Code when it shows none', async () => {
-        await initCommand(testDir);
-        expect(await fs.pathExists(path.join(testDir, '.claude', 'settings.json'))).toBe(true);
-        for (const rel of ['.cursor', '.clinerules', '.windsurf'])
-            expect(await fs.pathExists(path.join(testDir, rel)), rel).toBe(false);
-    });
-    it('sets up an agent the repository shows signs of, or the ones asked for', async () => {
-        await fs.ensureDir(path.join(testDir, '.cursor'));
-        await initCommand(testDir);
-        expect(await fs.pathExists(path.join(testDir, '.cursor', 'hooks.json'))).toBe(true);
-        expect(await fs.pathExists(path.join(testDir, '.windsurf'))).toBe(false);
-        const other = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-init-rules-'));
-        try {
-            await initCommand(other, { ide: 'windsurf' });
-            expect(await fs.pathExists(path.join(other, '.windsurf', 'hooks.json'))).toBe(true);
-            expect(await fs.pathExists(path.join(other, '.claude', 'settings.json'))).toBe(false);
-        }
-        finally {
-            await fs.remove(other);
-        }
-    });
-});

package/dist/smoke.test.d.ts

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

package/dist/smoke.test.js

@@ -1,82 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-async function getCheckCommand() {
-    const { checkCommand } = await import('./commands/check.js');
-    return checkCommand;
-}
-describe('CLI Smoke Test', () => {
-    const testDir = path.join(os.tmpdir(), 'rigour-temp-smoke-test-' + process.pid);
-    beforeEach(async () => {
-        await fs.ensureDir(testDir);
-        // @ts-ignore
-        vi.spyOn(process, 'exit').mockImplementation(() => { });
-    });
-    afterEach(async () => {
-        try {
-            const restrictedDir = path.join(testDir, '.restricted');
-            if (await fs.pathExists(restrictedDir)) {
-                await fs.chmod(restrictedDir, 0o777);
-            }
-            await fs.remove(testDir);
-        }
-        catch (e) {
-            // Best effort cleanup
-        }
-        vi.restoreAllMocks();
-    });
-    it('should respect ignore patterns and avoid EPERM', async () => {
-        const restrictedDir = path.join(testDir, '.restricted');
-        await fs.ensureDir(restrictedDir);
-        await fs.writeFile(path.join(restrictedDir, 'secret.js'), 'TODO: leak');
-        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
-version: 1
-ignore:
-  - ".restricted/**"
-gates:
-  forbid_todos: true
-  required_files: []
-  context:
-    enabled: false
-  environment:
-    enabled: false
-  safety:
-    protected_paths: []
-  retry_loop_breaker:
-    enabled: false
-`);
-        // Simulate EPERM by changing permissions
-        await fs.chmod(restrictedDir, 0o000);
-        try {
-            // We need to mock process.exit or checkCommand should not exit if we want to test it easily
-            // For now, we'll just verify it doesn't throw before it would exit (internal logic)
-            // But checkCommand calls process.exit(1) on failure.
-            // Re-importing checkCommand to ensure it uses the latest core
-            const checkCommand = await getCheckCommand();
-            await expect(checkCommand(testDir, [], { ci: true })).resolves.not.toThrow();
-        }
-        finally {
-            await fs.chmod(restrictedDir, 0o777);
-        }
-    }, 30_000);
-    it('should check specific files when provided', async () => {
-        await fs.writeFile(path.join(testDir, 'bad.js'), '// TODO: fixme');
-        await fs.writeFile(path.join(testDir, 'good.js'), 'console.log("hello")');
-        await fs.writeFile(path.join(testDir, 'rigour.yml'), `
-version: 1
-gates:
-  forbid_todos: true
-  required_files: []
-`);
-        // If we check ONLY good.js, it should PASS (exit PASS)
-        const checkCommand = await getCheckCommand();
-        await checkCommand(testDir, [path.join(testDir, 'good.js')], { ci: true });
-        expect(process.exit).toHaveBeenCalledWith(0);
-        // If we check bad.js, it should FAIL (exit FAIL)
-        vi.clearAllMocks();
-        const checkCommandFail = await getCheckCommand();
-        await checkCommandFail(testDir, [path.join(testDir, 'bad.js')], { ci: true });
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-});

package/dist/utils/cli-version.test.d.ts

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

package/dist/utils/cli-version.test.js

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getCliVersion } from './cli-version.js';
-describe('getCliVersion', () => {
-    it('resolves package version at runtime', () => {
-        const version = getCliVersion();
-        expect(version).toMatch(/^\d+\.\d+\.\d+/);
-        expect(version).not.toBe('0.0.0');
-    });
-});

package/dist/utils/version.test.d.ts

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

package/dist/utils/version.test.js

@@ -1,22 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { checkForUpdates } from './version.js';
-describe('the update check', () => {
-    afterEach(() => { vi.unstubAllGlobals(); });
-    it('never asks the registry in CI, in an agent hook, or when the person opted out', async () => {
-        const fetch = vi.fn();
-        vi.stubGlobal('fetch', fetch);
-        const review = ['node', 'rigour', 'review'];
-        for (const env of [{ RIGOUR_UPDATE_CHECK: '0' }, { DO_NOT_TRACK: '1' }, { DO_NOT_TRACK: 'yes' }, { CI: 'true' }, { GITHUB_ACTIONS: 'true' }]) {
-            expect(await checkForUpdates('1.0.0', env, review)).toBeNull();
-        }
-        expect(await checkForUpdates('1.0.0', {}, ['node', 'rigour', 'hooks', 'check'])).toBeNull(); // an agent hook on every edit
-        expect(fetch).not.toHaveBeenCalled();
-    });
-    it('asks once a day for a person at a terminal', async () => {
-        const fetch = vi.fn(async () => new Response(JSON.stringify({ version: '9.0.0' })));
-        vi.stubGlobal('fetch', fetch);
-        expect(await checkForUpdates('1.0.0', {}, ['node', 'rigour', 'review'])).toMatchObject({ hasUpdate: true, latestVersion: '9.0.0' });
-        expect(await checkForUpdates('1.0.0', {}, ['node', 'rigour', 'review'])).toMatchObject({ latestVersion: '9.0.0' });
-        expect(fetch).toHaveBeenCalledTimes(1);
-    });
-});