@rigour-labs/core 6.8.0 → 6.8.1

package/dist/context.test.js

@@ -1,228 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { GateRunner } from '../src/gates/runner.js';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-const TEST_CWD = path.join(os.tmpdir(), 'rigour-temp-test-context-' + process.pid);
-describe('Context Awareness Engine', () => {
-    beforeAll(async () => {
-        await fs.ensureDir(TEST_CWD);
-    });
-    afterAll(async () => {
-        await fs.remove(TEST_CWD);
-    });
-    it('should detect context drift for redundant env suffixes (Golden Example)', async () => {
-        // Setup: Define standard GCP_PROJECT_ID
-        await fs.writeFile(path.join(TEST_CWD, '.env.example'), 'GCP_PROJECT_ID=my-project\n');
-        // Setup: Use drifted GCP_PROJECT_ID_PRODUCTION
-        await fs.writeFile(path.join(TEST_CWD, 'feature.js'), `
-            const id = process.env.GCP_PROJECT_ID_PRODUCTION;
-            console.log(id);
-        `);
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        const report = await runner.run(TEST_CWD);
-        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
-        expect(driftFailures.length).toBeGreaterThan(0);
-        expect(driftFailures[0].details).toContain('GCP_PROJECT_ID_PRODUCTION');
-        expect(driftFailures[0].hint).toContain('GCP_PROJECT_ID');
-    });
-    it('should not flag valid environment variables', async () => {
-        await fs.writeFile(path.join(TEST_CWD, 'valid.js'), `
-            const id = process.env.GCP_PROJECT_ID;
-        `);
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 100,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        const report = await runner.run(TEST_CWD);
-        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
-        // Filter out failures from other files if they still exist in TEST_CWD
-        const specificFailures = driftFailures.filter(f => f.files?.includes('valid.js'));
-        expect(specificFailures.length).toBe(0);
-    });
-    it('should classify arrow function exports as camelCase, not unknown', async () => {
-        // Create files with arrow function patterns that previously returned 'unknown'
-        await fs.writeFile(path.join(TEST_CWD, 'api.ts'), `
-            export const fetchData = async () => { return []; };
-            export const getUserProfile = async (id: string) => { return {}; };
-            export const use = () => {};
-            export const get = async () => {};
-            const handleClick = (e: Event) => {};
-            let processItem = async (item: any) => {};
-        `);
-        // Create a second file with consistent arrow function naming
-        await fs.writeFile(path.join(TEST_CWD, 'service.ts'), `
-            export const createUser = async (data: any) => {};
-            export const deleteUser = async (id: string) => {};
-            export const updateUser = async (id: string, data: any) => {};
-        `);
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        const report = await runner.run(TEST_CWD);
-        // Should NOT have any "unknown" naming convention failures
-        const namingFailures = report.failures.filter(f => f.id === 'context-drift' && f.details?.includes('unknown'));
-        expect(namingFailures.length).toBe(0);
-    });
-    it('should not classify plain variable declarations as function patterns', async () => {
-        // Create file with non-function const declarations
-        await fs.writeFile(path.join(TEST_CWD, 'constants.ts'), `
-            export const API_URL = 'https://api.example.com';
-            export const MAX_RETRIES = 3;
-            const config = { timeout: 5000 };
-            let count = 0;
-        `);
-        // Create file with actual functions for a dominant pattern
-        await fs.writeFile(path.join(TEST_CWD, 'utils.ts'), `
-            function getData() { return []; }
-            function setData(d: any) { return d; }
-            function processRequest(req: any) { return req; }
-        `);
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                context: {
-                    enabled: true,
-                    sensitivity: 0.8,
-                    mining_depth: 10,
-                    ignored_patterns: [],
-                    cross_file_patterns: true,
-                    naming_consistency: true,
-                    import_relationships: true,
-                    max_cross_file_depth: 50,
-                },
-            },
-            output: { report_path: 'rigour-report.json' }
-        };
-        const runner = new GateRunner(config);
-        const report = await runner.run(TEST_CWD);
-        // SCREAMING_SNAKE constants should NOT create naming drift failures
-        // because they should not be in the 'function' pattern bucket at all
-        const namingFailures = report.failures.filter(f => f.id === 'context-drift' && f.details?.includes('SCREAMING_SNAKE'));
-        expect(namingFailures.length).toBe(0);
-    });
-});
-/**
- * Direct unit tests for detectCasing logic
- */
-describe('detectCasing classification', () => {
-    // We test the regex rules directly since detectCasing is private
-    function detectCasing(name) {
-        if (/^[A-Z][a-z]/.test(name) && /[a-z][A-Z]/.test(name))
-            return 'PascalCase';
-        if (/^[a-z]/.test(name) && /[a-z][A-Z]/.test(name))
-            return 'camelCase';
-        if (/^[a-z][a-zA-Z0-9]*$/.test(name))
-            return 'camelCase'; // single-word lowercase
-        if (/^[a-z]+(_[a-z]+)+$/.test(name))
-            return 'snake_case';
-        if (/^[A-Z]+(_[A-Z]+)*$/.test(name))
-            return 'SCREAMING_SNAKE';
-        if (/^[A-Z][a-zA-Z]*$/.test(name))
-            return 'PascalCase';
-        return 'unknown';
-    }
-    // Multi-word camelCase
-    it('classifies multi-word camelCase', () => {
-        expect(detectCasing('fetchData')).toBe('camelCase');
-        expect(detectCasing('getUserProfile')).toBe('camelCase');
-        expect(detectCasing('handleClick')).toBe('camelCase');
-        expect(detectCasing('processItem')).toBe('camelCase');
-        expect(detectCasing('createNewUser')).toBe('camelCase');
-    });
-    // Single-word lowercase (the bug fix)
-    it('classifies single-word lowercase as camelCase', () => {
-        expect(detectCasing('fetch')).toBe('camelCase');
-        expect(detectCasing('use')).toBe('camelCase');
-        expect(detectCasing('get')).toBe('camelCase');
-        expect(detectCasing('set')).toBe('camelCase');
-        expect(detectCasing('run')).toBe('camelCase');
-        expect(detectCasing('a')).toBe('camelCase');
-        expect(detectCasing('x')).toBe('camelCase');
-        expect(detectCasing('id')).toBe('camelCase');
-    });
-    // Single-word lowercase with digits
-    it('classifies lowercase with digits as camelCase', () => {
-        expect(detectCasing('handler2')).toBe('camelCase');
-        expect(detectCasing('config3')).toBe('camelCase');
-        expect(detectCasing('v2')).toBe('camelCase');
-    });
-    // PascalCase
-    it('classifies PascalCase', () => {
-        expect(detectCasing('MyComponent')).toBe('PascalCase');
-        expect(detectCasing('UserService')).toBe('PascalCase');
-        expect(detectCasing('App')).toBe('PascalCase');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE'); // single uppercase letter
-    });
-    // snake_case
-    it('classifies snake_case', () => {
-        expect(detectCasing('my_func')).toBe('snake_case');
-        expect(detectCasing('get_data')).toBe('snake_case');
-        expect(detectCasing('process_all_items')).toBe('snake_case');
-    });
-    // SCREAMING_SNAKE
-    it('classifies SCREAMING_SNAKE_CASE', () => {
-        expect(detectCasing('API_URL')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('MAX_RETRIES')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('A')).toBe('SCREAMING_SNAKE');
-        expect(detectCasing('DB')).toBe('SCREAMING_SNAKE');
-    });
-    // Edge cases that should NOT be unknown
-    it('does not return unknown for valid identifiers', () => {
-        const validIdentifiers = [
-            'fetch', 'getData', 'MyClass', 'my_func', 'API_KEY',
-            'use', 'run', 'a', 'x', 'id', 'App', 'handler2',
-            'processItem', 'UserProfile', 'get_all_data', 'MAX_SIZE',
-        ];
-        for (const name of validIdentifiers) {
-            expect(detectCasing(name)).not.toBe('unknown');
-        }
-    });
-});

package/dist/deep/agent-review.test.d.ts

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

package/dist/deep/agent-review.test.js

@@ -1,53 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { reviewWithTools } from './agent-review.js';
-import { verifyCodeFindings } from './code-verifier.js';
-let repo;
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-review-'));
-    fs.writeFileSync(path.join(repo, 'limits.ts'), 'export const MAX_ROWS = 0;\n');
-    fs.writeFileSync(path.join(repo, 'page.ts'), Array.from({ length: 60 }, (_, i) => `// line ${i + 1}`).join('\n'));
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-const context = { file: 'page.ts', language: 'typescript', text: '1| export function page() {}', ranges: [[1, 5]], source: 'export function page() {}' };
-function scripted(replies) {
-    const seen = [];
-    const provider = {
-        name: 'fake', isAvailable: async () => true, setup: async () => { }, dispose: () => { }, analyze: async () => '',
-        chat: async (messages, tools, options) => {
-            seen.push({ messages: [...messages], tools: tools.length, toolChoice: options?.toolChoice });
-            return replies.shift() ?? { text: '{"findings": []}', toolCalls: [] };
-        },
-    };
-    return { provider, seen };
-}
-const findingJson = (line, description) => JSON.stringify({ findings: [{ category: 'correctness', severity: 'high', file: 'page.ts', line, description, suggestion: 's', confidence: 0.9 }] });
-describe('reviewWithTools', () => {
-    it('runs the tools the model asks for, then grounds its finding in what it read', async () => {
-        const { provider, seen } = scripted([
-            { text: '', toolCalls: [{ id: 't1', name: 'read_file', arguments: { path: 'limits.ts' } }, { id: 't2', name: 'read_file', arguments: { path: 'page.ts', start_line: 40, end_line: 45 } }] },
-            { text: findingJson(42, '`MAX_ROWS` is 0, so the page loop never runs.'), toolCalls: [] },
-        ]);
-        const result = await reviewWithTools(provider, context, '', repo, {});
-        expect(result.toolCalls).toBe(2);
-        const toolResults = seen[1].messages.filter(m => m.role === 'tool').map(m => m.content);
-        expect(toolResults[0]).toContain('export const MAX_ROWS = 0;');
-        // Line 42 was outside the sent source, but the model read it, and it read MAX_ROWS.
-        expect(verifyCodeFindings(result.findings, [result.context])).toHaveLength(1);
-        expect(verifyCodeFindings(result.findings, [context])).toHaveLength(0);
-    });
-    it('forbids tool calls after the budget, keeping the tools defined for the history, and asks for the answer', async () => {
-        const greedy = Array.from({ length: 20 }, (_, i) => ({ text: '', toolCalls: [{ id: `t${i}`, name: 'grep', arguments: { pattern: 'line' } }] }));
-        const { provider, seen } = scripted(greedy);
-        const result = await reviewWithTools(provider, context, '', repo, {});
-        expect(result.toolCalls).toBeLessThanOrEqual(12);
-        expect(seen.at(-1)).toMatchObject({ tools: 2, toolChoice: 'none' });
-        expect(result.findings).toEqual([]);
-    });
-    it('refuses a provider that cannot call tools', async () => {
-        const provider = { name: 'local', isAvailable: async () => true, setup: async () => { }, dispose: () => { }, analyze: async () => '' };
-        await expect(reviewWithTools(provider, context, '', repo, {})).rejects.toThrow('cannot call tools');
-    });
-});

package/dist/deep/code-context.test.d.ts

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

package/dist/deep/code-context.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildCodeContext } from './code-context.js';
-function fn(name, lineStart, lineEnd) {
-    return {
-        name, lineStart, lineEnd, lineCount: lineEnd - lineStart + 1, paramCount: 0, params: [],
-        maxNesting: 1, hasReturn: true, isAsync: false, isExported: true,
-    };
-}
-function facts(path, functions) {
-    return {
-        path, language: 'typescript', lineCount: 0, classes: [], functions, imports: [], exports: [],
-        errorHandling: [], testAssertions: 0, hasTests: false,
-    };
-}
-const source = (n) => Array.from({ length: n }, (_, i) => `const line${i + 1} = ${i + 1};`).join('\n');
-describe('buildCodeContext', () => {
-    it('sends a small file whole, with line numbers', () => {
-        const ctx = buildCodeContext(facts('src/a.ts', []), 'const a = 1;\nexport { a };', { maxChars: 10_000 });
-        expect(ctx.text).toBe('FILE: src/a.ts (typescript, 2 lines)\n1| const a = 1;\n2| export { a };');
-        expect(ctx.ranges).toEqual([[1, 2]]);
-        expect(ctx.source).toContain('export { a }');
-    });
-    it('cuts a large file into function segments and names what it omitted', () => {
-        const content = source(300);
-        const ctx = buildCodeContext(facts('src/big.ts', [fn('first', 1, 100), fn('second', 101, 200), fn('third', 201, 300)]), content, { maxChars: 4_000 });
-        expect(ctx.ranges[0]).toEqual([1, 100]);
-        expect(ctx.text).toMatch(/omitted for size: .*function second \(lines 101-200\)/);
-        expect(ctx.text).toContain('function third (lines 201-300)');
-        expect(ctx.source).not.toContain('line150 ');
-    });
-    it('puts the segment around changed lines first', () => {
-        const content = source(300);
-        const ctx = buildCodeContext(facts('src/big.ts', [fn('first', 1, 100), fn('second', 101, 200), fn('third', 201, 300)]), content, {
-            maxChars: 4_000, focusLines: [250],
-        });
-        expect(ctx.ranges[0]).toEqual([201, 300]);
-        expect(ctx.text).toContain('function first (lines 1-100)');
-    });
-    it('truncates a single oversized function explicitly instead of dropping it', () => {
-        const content = source(2_000);
-        const ctx = buildCodeContext(facts('src/huge.ts', [fn('huge', 1, 2_000)]), content, { maxChars: 2_000 });
-        expect(ctx.ranges).toHaveLength(1);
-        expect(ctx.ranges[0][0]).toBe(1);
-        expect(ctx.ranges[0][1]).toBeLessThan(2_000);
-        expect(ctx.text).toMatch(/… \[\d+ lines omitted\]$/);
-        expect(ctx.text.length).toBeLessThanOrEqual(2_000);
-    });
-});

package/dist/deep/code-pass.test.d.ts

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

package/dist/deep/code-pass.test.js

@@ -1,112 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { runCodePass } from './code-pass.js';
-import { parseVerdicts } from './self-check.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-const SOURCE = 'export function total(items: number[]) {\n  let sum = 0;\n  for (let i = 0; i <= items.length; i++) sum += items[i];\n  return sum;\n}\n';
-const facts = { path: 'total.ts', language: 'typescript', classes: [], functions: [] };
-function finding(line, category, description) {
-    return { category, severity: 'high', file: 'total.ts', line, description, suggestion: 's', confidence: 0.9 };
-}
-const isCheck = (prompt) => /^You reported \d+ defect/.test(prompt);
-/** Review passes answer from `reviews` in turn; the self-check withdraws findings whose line is in `withdraw`. */
-function fakeProvider(reviews, withdraw) {
-    const prompts = [];
-    const provider = {
-        name: 'fake', isAvailable: async () => true, setup: async () => { }, dispose: () => { },
-        analyze: async (prompt) => {
-            prompts.push(prompt);
-            if (isCheck(prompt)) {
-                const listed = [...prompt.matchAll(/^(\d+)\. total\.ts:(\d+):/gm)];
-                return JSON.stringify({ verdicts: listed.map(m => ({ n: Number(m[1]), real: !withdraw.includes(Number(m[2])) })) });
-            }
-            return JSON.stringify({ findings: reviews.shift() ?? [] });
-        },
-    };
-    return { provider, prompts };
-}
-function run(provider, reference) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'code-pass-'));
-    fs.writeFileSync(path.join(dir, 'total.ts'), SOURCE);
-    return runCodePass(provider, [facts], { cwd: dir, inference: {}, maxSourceChars: 10_000, focusLines: { 'total.ts': [3] }, reference });
-}
-describe('runCodePass', () => {
-    it('reviews once without reference material (the small tiers)', async () => {
-        const { provider, prompts } = fakeProvider([[finding(3, 'correctness', 'off by one on `items`')]], []);
-        const result = await run(provider);
-        expect(prompts).toHaveLength(1);
-        expect(result.findings.map(f => f.line)).toEqual([3]);
-        expect([result.proposed, result.withdrawn]).toEqual([1, 0]);
-    });
-    it('does not repeat an identical pass when there is only one reference section', async () => {
-        const { provider, prompts } = fakeProvider([[]], []);
-        await run(provider, { maxChars: 4000, prBody: 'Sum the basket.' });
-        expect(prompts).toHaveLength(1);
-    });
-    it('with reference material, reviews twice in opposite orders, merges, and keeps what one self-check call confirms', async () => {
-        const { provider, prompts } = fakeProvider([
-            [finding(3, 'correctness', 'reads past the end of `items`')],
-            [finding(3, 'correctness', 'same bug seen again'), finding(2, 'consistency', 'style-ish claim about `sum`')],
-        ], [2]);
-        const result = await run(provider, {
-            maxChars: 4000, prBody: 'Sum the basket.',
-            removed: { 'total.ts': [{ line: 3, text: ['  for (let i = 0; i < items.length; i++) sum += items[i];'] }] },
-        });
-        const reviews = prompts.filter(p => !isCheck(p));
-        expect(reviews).toHaveLength(2);
-        expect(reviews[0].indexOf('PR DESCRIPTION')).toBeLessThan(reviews[0].indexOf('REMOVED by this change'));
-        expect(reviews[1].indexOf('REMOVED by this change')).toBeLessThan(reviews[1].indexOf('PR DESCRIPTION'));
-        expect(prompts.filter(isCheck)).toHaveLength(1);
-        expect(result.findings.map(f => [f.line, f.category])).toEqual([[3, 'correctness']]);
-        expect([result.proposed, result.withdrawn]).toEqual([2, 1]); // two distinct findings, one withdrawn
-    });
-    it('reads only well-formed verdicts from a self-check reply', () => {
-        expect([...parseVerdicts('Sure! {"verdicts": [{"n": 1, "real": false}, {"n": 2, "real": true}, {"n": "3", "real": false}]}')])
-            .toEqual([[1, false], [2, true]]);
-        expect(parseVerdicts('I am not sure').size).toBe(0);
-    });
-    it('keeps every finding when the self-check call fails', async () => {
-        const { provider } = fakeProvider([[finding(3, 'correctness', 'reads past the end of `items`')], []], []);
-        const analyze = provider.analyze;
-        provider.analyze = async (prompt, options) => isCheck(prompt) ? Promise.reject(new Error('timeout')) : analyze(prompt, options);
-        const result = await run(provider, { maxChars: 4000, prBody: 'Sum the basket.', removed: { 'total.ts': [{ line: 3, text: ['x'] }] } });
-        expect(result.findings.map(f => f.line)).toEqual([3]);
-        expect(result.withdrawn).toBe(0);
-    });
-    it('starts no file after the deadline, and counts what it skipped', async () => {
-        const { provider, prompts } = fakeProvider([[]], []);
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'code-pass-'));
-        fs.writeFileSync(path.join(dir, 'total.ts'), SOURCE);
-        const result = await runCodePass(provider, [facts, facts], { cwd: dir, inference: {}, maxSourceChars: 10_000, deadline: Date.now() - 1 });
-        expect(prompts).toHaveLength(0);
-        expect(result.skipped).toBe(2);
-    });
-    it('reviews files concurrently but reports them in file order', async () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'code-pass-'));
-        const names = ['a.ts', 'b.ts', 'c.ts'];
-        for (const name of names)
-            fs.writeFileSync(path.join(dir, name), SOURCE);
-        let inFlight = 0;
-        let peak = 0;
-        const provider = {
-            name: 'fake', isAvailable: async () => true, setup: async () => { }, dispose: () => { },
-            analyze: async (prompt) => {
-                inFlight++;
-                peak = Math.max(peak, inFlight);
-                const file = names.find(n => prompt.includes(n));
-                await new Promise(resolve => setTimeout(resolve, file === 'a.ts' ? 30 : 5));
-                inFlight--;
-                return JSON.stringify({ findings: [{ ...finding(3, 'correctness', 'off by one'), file }] });
-            },
-        };
-        const many = names.map(name => ({ ...facts, path: name }));
-        const result = await runCodePass(provider, many, { cwd: dir, inference: {}, maxSourceChars: 10_000, concurrency: 2 });
-        expect(peak).toBe(2);
-        expect(result.findings.map(f => f.file)).toEqual(names);
-        expect(result.contexts.map(c => c.file)).toEqual(names);
-    });
-});

package/dist/deep/code-review-prompt.test.d.ts

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

package/dist/deep/code-review-prompt.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildCodeReviewPrompt, REVIEW_CATEGORIES } from './code-review-prompt.js';
-const context = { file: 'src/a.ts', language: 'typescript', text: 'FILE: src/a.ts\n1| export const a = 1;', ranges: [[1, 1]], source: '' };
-describe('buildCodeReviewPrompt', () => {
-    it('includes every category, the rules and the numbered source', () => {
-        const prompt = buildCodeReviewPrompt(context);
-        for (const c of REVIEW_CATEGORIES)
-            expect(prompt).toContain(`- ${c.key}: ${c.focus}`);
-        expect(prompt).toContain('Report only defects you can point to');
-        expect(prompt).toContain('1| export const a = 1;');
-        expect(prompt).toContain('Review src/a.ts');
-    });
-    it('allows an empty answer so the model is not pushed to invent findings', () => {
-        expect(buildCodeReviewPrompt(context)).toContain('{"findings": []}');
-    });
-    it('uses unique category keys', () => {
-        const keys = REVIEW_CATEGORIES.map(c => c.key);
-        expect(new Set(keys).size).toBe(keys.length);
-    });
-});

package/dist/deep/code-verifier.test.d.ts

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

package/dist/deep/code-verifier.test.js

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { quotedIdentifiers, verifyCodeFindings } from './code-verifier.js';
-const context = {
-    file: 'src/api/report.ts',
-    language: 'typescript',
-    text: '',
-    ranges: [[10, 40]],
-    source: 'export async function loadReport(days) {\n  const rows = await fetchAll(days);\n}',
-};
-function finding(overrides) {
-    return {
-        category: 'scalability', severity: 'high', file: 'src/api/report.ts', line: 12,
-        description: '`fetchAll` loads every row for the window into memory.', suggestion: 'Aggregate in the database.',
-        confidence: 0.8, ...overrides,
-    };
-}
-describe('verifyCodeFindings', () => {
-    it('counts every dropped finding by reason, so a drop is never silent', () => {
-        const rejected = {};
-        verifyCodeFindings([
-            finding({}), finding({ file: 'src/other.ts' }), finding({ line: 80 }), finding({ line: undefined }),
-            finding({ confidence: 0.1 }), finding({ description: '`fetchEverything` has no limit.' }),
-        ], [context], rejected);
-        expect(rejected).toEqual({ no_context: 1, out_of_range: 1, no_line: 1, low_confidence: 1, ungrounded_identifier: 1 });
-    });
-    it('keeps a finding grounded in the sent source', () => {
-        const [kept] = verifyCodeFindings([finding({})], [context]);
-        expect(kept).toMatchObject({ file: 'src/api/report.ts', verified: true });
-    });
-    it('resolves a basename-only file for a single-file review', () => {
-        expect(verifyCodeFindings([finding({ file: 'report.ts' })], [context])).toHaveLength(1);
-    });
-    it('drops findings for files that were not sent', () => {
-        expect(verifyCodeFindings([finding({ file: 'src/other.ts' })], [context])).toHaveLength(0);
-    });
-    it('drops findings whose line is outside the sent ranges', () => {
-        expect(verifyCodeFindings([finding({ line: 80 })], [context])).toHaveLength(0);
-    });
-    it('drops findings that cite an identifier the model was never shown', () => {
-        expect(verifyCodeFindings([finding({ description: '`fetchEverything` has no limit.' })], [context])).toHaveLength(0);
-    });
-    it('drops findings that cite no line, however confident', () => {
-        expect(verifyCodeFindings([finding({ line: undefined, confidence: 0.9 })], [context])).toHaveLength(0);
-        expect(verifyCodeFindings([finding({ line: null, description: 'The code is well-structured.' })], [context])).toHaveLength(0);
-    });
-    it('drops very low confidence findings', () => {
-        expect(verifyCodeFindings([finding({ confidence: 0.2 })], [context])).toHaveLength(0);
-    });
-});
-describe('quotedIdentifiers', () => {
-    it('extracts identifier-like backticked tokens only', () => {
-        expect(quotedIdentifiers('`fetchAll()` and `rows.length` but not `a + b` or `"quoted"`')).toEqual(['fetchAll', 'rows.length']);
-    });
-});

package/dist/deep/diff-tests/calls.test.d.ts

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

package/dist/deep/diff-tests/calls.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { safeCalls, testFileSource } from './calls.js';
-describe('safeCalls', () => {
-    it('keeps calls of the function with literal arguments only', () => {
-        expect(safeCalls('encodePath', [
-            "encodePath('/a b')",
-            "encodePath('/x?y', { keepQuery: true, depth: -1 }, [1, null, undefined]);",
-            'encodePath(`/%`)',
-        ])).toEqual(["encodePath('/a b')", "encodePath('/x?y', { keepQuery: true, depth: -1 }, [1, null, undefined])", 'encodePath(`/%`)']);
-    });
-    it('drops anything that could do more than call the function on data', () => {
-        expect(safeCalls('encodePath', [
-            "require('fs').rmSync('/')",
-            "encodePath(process.env.HOME)",
-            "encodePath((() => { fetch('x') })())",
-            'encodePath(`${secret}`)',
-            "other('/a')",
-            "encodePath('/a'); encodePath('/b')",
-            "encodePath({ [key]: 1 })",
-        ])).toEqual([]);
-    });
-});
-describe('testFileSource', () => {
-    it('imports the function, runs each call and records return values or errors without asserting', () => {
-        const source = testFileSource('vitest', 'encodePath', '../src/path', ["encodePath('/a b')"]);
-        expect(source).toContain("import { test } from 'vitest';");
-        expect(source).toContain('import { encodePath } from "../src/path";');
-        expect(source).toContain(`["encodePath('/a b')", () => encodePath('/a b')],`);
-        expect(source).toContain('writeFileSync(process.env.RIGOUR_DIFF_OUT as string, JSON.stringify(out));');
-        expect(source).not.toContain('expect(');
-        expect(testFileSource('jest', 'f', './f', ['f(1)'])).not.toContain("from 'vitest'");
-    });
-});

package/dist/deep/diff-tests/run.test.d.ts

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

package/dist/deep/diff-tests/run.test.js

@@ -1,58 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { runDiffTests } from './run.js';
-// The workspace root's node_modules, where the vitest binary is installed.
-const WORKSPACE_MODULES = path.resolve(__dirname, '../../../../../node_modules');
-let repo;
-afterEach(() => { if (repo)
-    fs.rmSync(repo, { recursive: true, force: true }); repo = undefined; });
-const BEFORE = "export function encodePath(p: string): string {\n  return p.replace(/ /g, '%20').replace(/#/g, '%23');\n}\n";
-const AFTER = "export function encodePath(p: string): string {\n  return p.replace(/#/g, '%23');\n}\n";
-function repoWithChange() {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'diff-tests-'));
-    const git = (...args) => execFileSync('git', args, { cwd: repo });
-    git('init', '-q');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.writeFileSync(path.join(repo, 'package.json'), JSON.stringify({ name: 'paths', type: 'module', devDependencies: { vitest: '*' } }));
-    fs.writeFileSync(path.join(repo, '.gitignore'), 'node_modules\n');
-    fs.mkdirSync(path.join(repo, 'src'));
-    fs.writeFileSync(path.join(repo, 'src/encode.ts'), BEFORE);
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-    fs.symlinkSync(WORKSPACE_MODULES, path.join(repo, 'node_modules'), process.platform === 'win32' ? 'junction' : 'dir');
-    fs.writeFileSync(path.join(repo, 'src/encode.ts'), AFTER);
-    return repo;
-}
-function provider(calls, intended = false) {
-    return {
-        name: 'fake', isAvailable: async () => true, setup: async () => { }, dispose: () => { },
-        analyze: async (prompt) => prompt.includes('"intended"') ? JSON.stringify({ intended }) : JSON.stringify({ calls }),
-    };
-}
-describe('runDiffTests', () => {
-    it('reports a call whose outcome changed between the base and the change', async () => {
-        const cwd = repoWithChange();
-        const changes = await runDiffTests({
-            cwd, baseRef: 'HEAD', focusLines: { 'src/encode.ts': [2] }, inference: {},
-            provider: provider(["encodePath('/a b')", "encodePath('/x#y')", "process.exit(1)"]),
-        });
-        expect(changes).toEqual([{
-                file: 'src/encode.ts', line: 2, name: 'encodePath', call: "encodePath('/a b')",
-                before: 'returns "/a%20b"', after: 'returns "/a b"',
-            }]);
-        expect(fs.readdirSync(path.join(cwd, 'src'))).toEqual(['encode.ts']);
-    }, 60_000);
-    it('drops a change the PR description says is intended', async () => {
-        const cwd = repoWithChange();
-        const changes = await runDiffTests({
-            cwd, baseRef: 'HEAD', focusLines: { 'src/encode.ts': [2] }, inference: {}, prBody: 'Stop encoding spaces.',
-            provider: provider(["encodePath('/a b')"], true),
-        });
-        expect(changes).toEqual([]);
-    }, 60_000);
-});

package/dist/deep/fact-extractor.test.d.ts

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