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

package/dist/commands/review-summary.test.js

@@ -1,46 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { splitByChangedLines } from '@rigour-labs/core';
-import { buildCiReviewSummary, renderGithubSummary } from './review-summary.js';
-function failure(id, severity, file, line, details) {
-    return { id, title: id, details, hint: details, severity, provenance: 'traditional', files: [file], line };
-}
-describe('GitHub change review summary', () => {
-    it('prioritizes severe findings and never includes raw secret-bearing messages', () => {
-        const failures = [
-            failure('style-drift', 'low', 'src/a.ts', 3, 'ordinary style'),
-            failure('security-patterns', 'critical', 'src/shell.ts', 8, 'API_KEY=secret-value-that-must-not-appear'),
-            failure('logic-drift', 'medium', 'src/logic.ts', 5, 'changed operator'),
-        ];
-        const summary = buildCiReviewSummary(failures, 5, { 'src/a.ts': new Set([3]), 'src/shell.ts': new Set([8]) });
-        const markdown = renderGithubSummary(summary);
-        expect(summary.findings.map(item => item.rule)).toEqual(['security-patterns', 'logic-drift', 'style-drift']);
-        expect(summary.severity).toEqual({ critical: 1, high: 0, medium: 1, low: 1 });
-        expect(summary.excluded_outside_changed_lines).toBe(2);
-        expect(summary.changed_lines).toBe(2);
-        expect(markdown).toContain('Trace the input and sink');
-        expect(markdown).not.toContain('secret-value-that-must-not-appear');
-    });
-    it('caps output and escapes untrusted path text', () => {
-        const failures = Array.from({ length: 8 }, (_, i) => failure('style-drift', 'low', `src/bad\`\n${i}.ts`, i + 1, 'untrusted'));
-        const summary = buildCiReviewSummary(failures, 8, {});
-        const markdown = renderGithubSummary(summary);
-        expect(summary.findings).toHaveLength(5);
-        expect(summary.truncated).toBe(3);
-        expect(markdown).not.toContain('bad`');
-        expect(markdown).toContain('3 more finding(s)');
-    });
-    it('does not imply a clean repository when changed lines pass', () => {
-        const markdown = renderGithubSummary(buildCiReviewSummary([], 20, {}));
-        expect(markdown).toContain('No findings on changed lines');
-        expect(markdown).toContain('does not assess the full repository');
-    });
-    it('abstains from attributing file-level findings to changed line one', () => {
-        const withLine = failure('security-patterns', 'high', 'src/a.ts', 5, 'specific line');
-        const fileLevel = { ...failure('AST_COMPLEXITY', 'medium', 'src/a.ts', 1, 'whole file'), line: undefined };
-        const split = splitByChangedLines([withLine, fileLevel], { 'src/a.ts': new Set([1, 5]) });
-        expect(split.findings).toEqual([withLine]);
-        expect(split.fileFindings).toEqual([fileLevel]);
-        const summary = buildCiReviewSummary(split.findings, 2, { 'src/a.ts': new Set([1, 5]) }, split.fileFindings.length + split.unlocated);
-        expect(renderGithubSummary(summary)).toContain('file-level finding(s) lacked a changed-line location');
-    });
-});

package/dist/commands/review-task.test.d.ts

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

package/dist/commands/review-task.test.js

@@ -1,47 +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 { reviewAckCommand, reviewExportCommand, reviewTaskCommand } from './review-task.js';
-let repo;
-let out;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'cli-review-task-'));
-    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, 'README.md'), 'x\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-    fs.writeFileSync(path.join(repo, 'sync.ts'), "export async function syncOrders(db, rows) {\n  await db.from('orders').upsert(rows);\n}\n");
-    out = [];
-    vi.spyOn(console, 'log').mockImplementation((...args) => { out.push(args.join(' ')); });
-    vi.spyOn(console, 'error').mockImplementation((...args) => { out.push(args.join(' ')); });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    process.exitCode = undefined;
-    fs.rmSync(repo, { recursive: true, force: true });
-});
-describe('review-task, review-ack, review-export', () => {
-    it('lists the risky function, records a human review, and exports it', async () => {
-        await reviewTaskCommand(repo, { json: true });
-        expect(JSON.parse(out.join('\n')).items).toEqual([expect.objectContaining({ file: 'sync.ts', function: 'syncOrders' })]);
-        reviewAckCommand(repo, 'sync.ts', 'syncOrders', { verdict: 'no_issue', note: 'rows are one page; key is the order id' });
-        expect(out.at(-1)).toContain('Recorded: sync.ts syncOrders (no_issue)');
-        out = [];
-        await reviewTaskCommand(repo, {});
-        expect(out.join('\n')).toContain('No risky changed function waiting for review (1 already reviewed)');
-        reviewExportCommand(repo);
-        const exported = JSON.parse(fs.readFileSync(path.join(repo, '.rigour', 'reviewed.json'), 'utf8'));
-        expect(exported.entries).toEqual([expect.objectContaining({ file: 'sync.ts', function: 'syncOrders', reviewer: 'human', verdict: 'no_issue' })]);
-    });
-    it('rejects an acknowledgement without a real note, with a failing exit code', () => {
-        reviewAckCommand(repo, 'sync.ts', 'syncOrders', { verdict: 'no_issue', note: 'ok' });
-        expect(out.at(-1)).toContain('Not recorded: note must say what was checked');
-        expect(process.exitCode).toBe(1);
-    });
-});

package/dist/commands/scan-rules.test.d.ts

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

package/dist/commands/scan-rules.test.js

@@ -1,29 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { scanRulesCommand } from './scan-rules.js';
-describe('rigour scan-rules', () => {
-    let dir;
-    afterEach(() => { if (dir)
-        fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; vi.restoreAllMocks(); });
-    function scan(files, rules) {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'scan-rules-'));
-        for (const [name, text] of Object.entries(files))
-            fs.writeFileSync(path.join(dir, name), text);
-        const out = [];
-        vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out.push(String(chunk)); return true; });
-        scanRulesCommand(dir, Object.keys(files).filter(f => f.endsWith('.ts')), { rules });
-        return out.join('').trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
-    }
-    it('runs only the named rules and prints one JSON line per finding', () => {
-        const code = "export function setup(fn: () => void) {\n  window.addEventListener('a', fn);\n  addEventListener('b', fn);\n}\n"
-            + "// @ts-expect-error internal\nexport const r = (e: any) => e[Symbol.for('lib.internal.x')];\n";
-        expect(scan({ 'a.ts': code }, 'env/bare-browser-global')).toEqual([
-            { rule: 'env/bare-browser-global', file: 'a.ts', line: 3, severity: 'medium', message: expect.stringContaining('addEventListener') },
-        ]);
-    });
-    it('rejects an unknown rule id rather than scanning nothing', () => {
-        expect(() => scan({ 'a.ts': 'export {};\n' }, 'no/such-rule')).toThrow('Unknown rule(s): no/such-rule');
-    });
-});

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

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

package/dist/commands/scan.test.js

@@ -1,64 +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 { scanCommand } from './scan.js';
-describe('scanCommand', () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scan-test-'));
-        vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(async () => {
-        await fs.remove(testDir);
-        vi.restoreAllMocks();
-    });
-    it('runs in zero-config mode without rigour.yml', async () => {
-        await fs.writeJson(path.join(testDir, 'package.json'), { name: 'scan-zero-config-test' });
-        await fs.writeFile(path.join(testDir, 'index.js'), "import fake from 'totally-fake-package';\nconsole.log(fake);\n");
-        await expect(scanCommand(testDir, [], {})).resolves.not.toThrow();
-        expect(process.exit).toHaveBeenCalled();
-        expect(await fs.pathExists(path.join(testDir, 'rigour-report.json'))).toBe(true);
-    }, 30_000);
-    it('uses provided config path when passed', async () => {
-        await fs.writeFile(path.join(testDir, 'app.js'), "export const ok = 42;\n");
-        await fs.writeFile(path.join(testDir, 'scan-config.yml'), `
-version: 1
-gates:
-  required_files: []
-  forbid_todos: false
-  forbid_fixme: false
-  context:
-    enabled: false
-  environment:
-    enabled: false
-  retry_loop_breaker:
-    enabled: false
-  security:
-    enabled: false
-  duplication_drift:
-    enabled: false
-  hallucinated_imports:
-    enabled: false
-  inconsistent_error_handling:
-    enabled: false
-  context_window_artifacts:
-    enabled: false
-  promise_safety:
-    enabled: false
-  phantom_apis:
-    enabled: false
-  deprecated_apis:
-    enabled: false
-  test_quality:
-    enabled: false
-output:
-  report_path: scan-report.json
-`);
-        await expect(scanCommand(testDir, [], { config: 'scan-config.yml' })).resolves.not.toThrow();
-        expect(process.exit).toHaveBeenCalledWith(0);
-        expect(await fs.pathExists(path.join(testDir, 'scan-report.json'))).toBe(true);
-    }, 30_000);
-});

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

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

package/dist/commands/skills.test.js

@@ -1,56 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { installSkills, skillsDoctor } from './skills.js';
-describe('Rigour skills', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-skills-'));
-        vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('installs native Codex skills with valid discovery metadata', async () => {
-        await installSkills(testDir, ['context'], { target: 'codex' });
-        const filePath = path.join(testDir, '.agents', 'skills', 'rigour-context', 'SKILL.md');
-        const content = fs.readFileSync(filePath, 'utf-8');
-        expect(content).toContain('name: rigour-context');
-        expect(content).toContain('rigour_context_scope');
-        expect(content).toContain('repository-wide scan');
-    });
-    it('installs focused Cursor commands instead of a global rule', async () => {
-        await installSkills(testDir, ['verify'], { target: 'cursor' });
-        const filePath = path.join(testDir, '.cursor', 'commands', 'rigour-verify.md');
-        const content = fs.readFileSync(filePath, 'utf-8');
-        expect(content).toContain('rigour_check');
-        expect(content).toContain('rigour_get_fix_packet');
-        expect(content).not.toContain('alwaysApply');
-    });
-    it('keeps an existing playbook unless force is requested', async () => {
-        const filePath = path.join(testDir, '.cursor', 'commands', 'rigour-context.md');
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, 'team customisation');
-        await installSkills(testDir, ['context'], { target: 'cursor' });
-        expect(fs.readFileSync(filePath, 'utf-8')).toBe('team customisation');
-        await installSkills(testDir, ['context'], { target: 'cursor', force: true });
-        expect(fs.readFileSync(filePath, 'utf-8')).toContain('rigour_context_scope');
-    });
-    it('supports a no-write preview and portable playbooks', async () => {
-        await installSkills(testDir, ['handoff'], { target: 'universal', dryRun: true });
-        expect(fs.existsSync(path.join(testDir, 'docs', 'rigour-skills', 'rigour-handoff.md'))).toBe(false);
-        await installSkills(testDir, ['handoff'], { target: 'universal' });
-        const content = fs.readFileSync(path.join(testDir, 'docs', 'rigour-skills', 'rigour-handoff.md'), 'utf-8');
-        expect(content).toContain('portable Rigour playbook');
-        expect(content).toContain('rigour_handoff_accept');
-    });
-    it('reports missing and installed targets through doctor', async () => {
-        await skillsDoctor(testDir);
-        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('missing'));
-        await installSkills(testDir, ['all'], { target: 'all' });
-        await skillsDoctor(testDir);
-        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('All Rigour playbooks are installed'));
-    });
-});

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

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

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

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { aboutAnotherRepository, buildActivity, groupSessions, readableFunction } from './studio-activity.js';
-describe('buildActivity', () => {
-    it('turns the record into sentences, newest first, and leaves raw tool traffic out', () => {
-        const items = buildActivity({
-            events: [
-                { type: 'hook_check', timestamp: '2026-10-09T10:00:00Z', files: ['src/pay.ts'], findings: [{ message: 'Stripe API key detected in code' }] },
-                { type: 'tool_call', timestamp: '2026-10-09T10:01:00Z', tool: 'rigour_recall' },
-                { type: 'stop_review', timestamp: '2026-10-09T10:03:00Z', blocked: true, blocking: 1 },
-                { type: 'lessons_served', timestamp: '2026-10-09T10:04:00Z', via: 'recall', lessons: ['Amounts are cents'] },
-            ],
-            ledger: [{ file: 'src/refund.ts', function: 'issueRefund', hash: 'h', reviewer: 'agent', verdict: 'fixed', note: 'Read the row under lock.', at: '2026-10-09T10:05:00Z' }],
-            stories: [{ id: 's', at: '2026-10-09T10:02:00Z', stage: 'edit', file: 'src/pay.ts', rule: 'security-patterns', title: 'Stripe API key detected in code', diff: [] }],
-        });
-        expect(items.map(i => i.text)).toEqual([
-            'Fixed `issueRefund` in src/refund.ts',
-            'Told the agent 1 lesson before it wrote',
-            'Kept the agent working: 1 problem left when it tried to finish',
-            'Fixed: Stripe API key detected in code',
-            'Stopped an edit to src/pay.ts: Stripe API key detected in code',
-        ]);
-    });
-    it('names unnamed functions the way people do', () => {
-        expect(readableFunction('<anonymous>@17', 'src/proxy.test.ts')).toBe('the test at line 17');
-        expect(readableFunction('<anonymous>@4', 'src/a.ts')).toBe('the function at line 4');
-        expect(readableFunction('loadDiagnosis', 'src/a.ts')).toBe('`loadDiagnosis`');
-    });
-    it('groups activity into sessions, with fixes up front and routine items folded', () => {
-        const item = (at, kind, text = 'x') => ({ at, kind, text });
-        const sessions = groupSessions([
-            item('2026-10-09T12:00:00Z', 'reviewed', 'Reviewed `a` in a.ts: no issue'),
-            item('2026-10-09T11:50:00Z', 'reviewed', 'Fixed `b` in b.ts'),
-            item('2026-10-09T11:40:00Z', 'checked'),
-            item('2026-10-09T08:00:00Z', 'stopped'),
-        ]);
-        expect(sessions).toHaveLength(2);
-        expect(sessions[0].counts).toMatchObject({ reviewed: 2, reviewedFixed: 1, checked: 1 });
-        expect(sessions[0].highlights.map(i => i.text)).toEqual(['Fixed `b` in b.ts']);
-        expect(sessions[0].rest).toHaveLength(2);
-        expect(sessions[1].highlights).toHaveLength(1);
-    });
-    it("leaves out old edit events that were about another repository's files", () => {
-        expect(aboutAnotherRepository({ type: 'hook_check', files: ['/work/other/src/a.ts'] }, ['/work/app'])).toBe(true);
-        expect(aboutAnotherRepository({ type: 'hook_check', files: ['/work/app/src/a.ts'] }, ['/work/app'])).toBe(false);
-        expect(aboutAnotherRepository({ type: 'hook_check', files: ['src/a.ts'] }, ['/work/app'])).toBe(false);
-    });
-});

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

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

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

@@ -1,23 +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 { checkoutRoots } from './studio-checkouts.js';
-let repo;
-beforeEach(() => {
-    repo = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'checkouts-')));
-    execFileSync('git', ['init', '-q', repo]);
-    execFileSync('git', ['-C', repo, '-c', 'user.email=t@example.com', '-c', 'user.name=t', 'commit', '-q', '--allow-empty', '-m', 'init']);
-    fs.mkdirSync(path.join(repo, '.rigour'));
-});
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-describe('checkoutRoots', () => {
-    it('lists each checkout once, however the folder is spelled', () => {
-        const tree = path.join(repo, 'wt');
-        execFileSync('git', ['-C', repo, 'worktree', 'add', '-q', tree]);
-        fs.mkdirSync(path.join(tree, '.rigour'));
-        // git reports these folders with forward slashes; started from a trailing-slash path
-        expect(checkoutRoots(repo + path.sep)).toEqual([repo, fs.realpathSync.native(tree)]);
-    });
-});

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

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

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildAgentContext } from './studio-context.js';
-const now = new Date('2026-10-09T12:00:00Z');
-const t = (iso) => Date.parse(iso);
-describe('buildAgentContext', () => {
-    it('sums what agents were given this week: focused files, recalls, lessons, reuse', () => {
-        const ctx = buildAgentContext({
-            now,
-            context: [
-                { toolName: 'rigour_context_scope', cacheStatus: 'none', candidateFiles: 180, returnedFiles: 6, candidateTokens: 90000, returnedTokens: 4000, createdAt: t('2026-10-08T00:00:00Z') },
-                { toolName: 'rigour_context_scope', cacheStatus: 'none', candidateFiles: 180, returnedFiles: 4, candidateTokens: 90000, returnedTokens: 3000, createdAt: t('2026-09-01T00:00:00Z') },
-                { toolName: 'rigour_recall', cacheStatus: 'none', candidateTokens: 0, returnedTokens: 200, createdAt: t('2026-10-07T00:00:00Z') },
-            ],
-            events: [
-                { type: 'lessons_served', timestamp: '2026-10-07T00:00:00Z', lessons: ['a', 'b'] },
-                { type: 'reuse_suggested', timestamp: '2026-10-08T00:00:00Z', planned: 'formatMoney', existing: 'formatCents in src/lib/money.ts:12', action: 'BLOCK' },
-            ],
-        });
-        expect(ctx.week).toEqual({
-            scopes: 1, filesConsidered: 180, filesReturned: 6, tokensConsidered: 90000, tokensReturned: 4000, recalls: 1, lessonsTold: 2,
-            reuse: [{ at: '2026-10-08T00:00:00Z', planned: 'formatMoney', existing: 'formatCents in src/lib/money.ts:12', action: 'BLOCK' }],
-        });
-        expect(ctx.weeks.at(-1)).toMatchObject({ scopes: 1, filesReturned: 6, filesConsidered: 180, recalls: 1, lessonsTold: 2, reuse: 1 });
-        expect(ctx.weeks.reduce((n, w) => n + w.scopes, 0)).toBe(2); // September 1 is inside the 8 weeks
-    });
-});

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

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

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

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveStudioVersion } from './studio-contracts.js';
-describe('resolveStudioVersion', () => {
-    it('prefers the released CLI version used to serve Studio', () => {
-        expect(resolveStudioVersion('6.2.1', '5.4.0')).toBe('6.2.1');
-        expect(resolveStudioVersion(undefined, '6.2.0')).toBe('6.2.0');
-    });
-});

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

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

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

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createStudioGuard, refuseStudioRequest, STUDIO_KEY_HEADER, studioLaunchUrl } from './studio-guard.js';
-const guard = createStudioGuard([3000, 3001]);
-const req = (method, headers) => ({ method, headers });
-describe('Studio request guard', () => {
-    it('serves reads only to its own loopback host, so a rebound DNS name cannot read files', () => {
-        expect(refuseStudioRequest(req('GET', { host: '127.0.0.1:3000' }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('GET', { host: 'localhost:3001' }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('GET', { host: 'attacker.example:3000' }), guard)).toBe('unknown host');
-        expect(refuseStudioRequest(req('GET', {}), guard)).toBe('unknown host');
-    });
-    it('accepts a write only with the launch key and no foreign origin', () => {
-        const host = { host: '127.0.0.1:3000' };
-        expect(refuseStudioRequest(req('POST', { ...host, [STUDIO_KEY_HEADER]: guard.launchKey }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('POST', { ...host, origin: 'http://127.0.0.1:3000', [STUDIO_KEY_HEADER]: guard.launchKey }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('POST', host), guard)).toContain('missing studio key');
-        expect(refuseStudioRequest(req('DELETE', { ...host, [STUDIO_KEY_HEADER]: 'x'.repeat(48) }), guard)).toContain('wrong studio key');
-        expect(refuseStudioRequest(req('POST', { ...host, origin: 'https://evil.example', [STUDIO_KEY_HEADER]: guard.launchKey }), guard)).toBe('cross-origin write');
-    });
-    it('puts the key in the fragment, which the browser never sends to a server', () => {
-        expect(studioLaunchUrl('http://127.0.0.1:3000', guard)).toBe(`http://127.0.0.1:3000/#key=${guard.launchKey}`);
-        expect(createStudioGuard([3000]).launchKey).not.toBe(guard.launchKey);
-    });
-});

package/dist/commands/studio-learned-rules.test.d.ts

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

package/dist/commands/studio-learned-rules.test.js

@@ -1,31 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { saveLearnedRule } from '@rigour-labs/core';
-import { loadStudioLearnedRules } from './studio-learned-rules.js';
-const base = {
-    version: 1, message: 'm', severity: 'medium',
-    source: { commit: 'abc12345', file: 'src/http.ts', function: 'post' },
-    validation: { firesBefore: 1, firesAfter: 0, maxHits: 3, repoHits: ['src/other.ts:4'] },
-};
-describe('loadStudioLearnedRules', () => {
-    let cwd;
-    afterEach(() => { if (cwd)
-        fs.rmSync(cwd, { recursive: true, force: true }); cwd = undefined; });
-    it('describes each rule by what it requires and where it applies', () => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'studio-learned-'));
-        saveLearnedRule(cwd, { ...base, id: 'require-option-redirect-aaaa1111', pattern: { template: 'require-option', callee: { level: 'declaration', key: 'src/http.ts#Deps.fetch' }, argIndex: 1, property: 'redirect' } });
-        saveLearnedRule(cwd, { ...base, id: 'require-guard-cache-control-bbbb2222', pattern: { template: 'require-guard', callee: { level: 'text', key: 'Response.json' }, property: 'cache-control', guard: 'stepsAvailable', appliesWhenArgsMention: false, scope: { file: 'src/route.ts', fn: 'GET>respond' } } });
-        const rules = loadStudioLearnedRules(cwd);
-        expect(rules.map(r => [r.requirement, r.appliesTo])).toEqual([
-            ['`cache-control` conditional on `stepsAvailable`', 'regression guard for GET>respond in src/route.ts'],
-            ['`redirect` in argument 2', 'declaration src/http.ts#Deps.fetch'],
-        ]);
-        expect(rules[1].validation.repoHits).toEqual(['src/other.ts:4']);
-    });
-    it('is empty for a repository without learned rules', () => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'studio-learned-'));
-        expect(loadStudioLearnedRules(cwd)).toEqual([]);
-    });
-});

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

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

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 {};