@rigour-labs/core 6.8.0 → 6.8.1

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

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

package/dist/deep/prompts.test.js

@@ -1,235 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildAnalysisPrompt, buildCrossFilePrompt, chunkFacts, DEEP_SYSTEM_PROMPT } from './prompts.js';
-import { factsToPromptString } from './fact-extractor.js';
-// ── Test helpers ──
-function makeGoFacts(overrides = {}) {
-    return {
-        path: 'pkg/server.go',
-        language: 'go',
-        lineCount: 200,
-        classes: [],
-        functions: [{
-                name: 'Server.Start',
-                lineStart: 10,
-                lineEnd: 50,
-                lineCount: 40,
-                paramCount: 1,
-                params: ['ctx context.Context'],
-                maxNesting: 3,
-                hasReturn: true,
-                isAsync: false,
-                isExported: true,
-            }],
-        imports: ['net/http', 'context', 'sync'],
-        exports: [],
-        errorHandling: [],
-        testAssertions: 0,
-        hasTests: false,
-        structs: [{
-                name: 'Server',
-                lineStart: 5,
-                lineEnd: 15,
-                fieldCount: 5,
-                methodCount: 4,
-                methods: ['Start', 'Stop', 'Handle', 'Route'],
-                lineCount: 10,
-                embeds: ['BaseServer'],
-            }],
-        interfaces: [{
-                name: 'Handler',
-                lineStart: 20,
-                methodCount: 2,
-                methods: ['ServeHTTP', 'Health'],
-            }],
-        goroutines: 3,
-        channels: 1,
-        mutexes: 1,
-        defers: 2,
-        ...overrides,
-    };
-}
-function makeTsFacts(overrides = {}) {
-    return {
-        path: 'src/service.ts',
-        language: 'typescript',
-        lineCount: 150,
-        classes: [{
-                name: 'UserService',
-                lineStart: 5,
-                lineEnd: 140,
-                methodCount: 6,
-                methods: ['find', 'create', 'update', 'delete', 'validate', 'notify'],
-                publicMethods: ['find', 'create', 'update', 'delete'],
-                lineCount: 135,
-                dependencies: ['Database', 'Logger'],
-            }],
-        functions: [],
-        imports: ['express', 'lodash', './types'],
-        exports: ['UserService'],
-        errorHandling: [
-            { type: 'try-catch', lineStart: 10, isEmpty: false, strategy: 'throw' },
-        ],
-        testAssertions: 0,
-        hasTests: false,
-        ...overrides,
-    };
-}
-describe('Deep Analysis Prompts', () => {
-    // ── DEEP_SYSTEM_PROMPT ──
-    describe('DEEP_SYSTEM_PROMPT', () => {
-        it('should contain all category groups', () => {
-            expect(DEEP_SYSTEM_PROMPT).toContain('SOLID Principles');
-            expect(DEEP_SYSTEM_PROMPT).toContain('Design Patterns');
-            expect(DEEP_SYSTEM_PROMPT).toContain('DRY');
-            expect(DEEP_SYSTEM_PROMPT).toContain('Error Handling');
-            expect(DEEP_SYSTEM_PROMPT).toContain('Concurrency');
-            expect(DEEP_SYSTEM_PROMPT).toContain('Testing');
-        });
-        it('should contain key category IDs', () => {
-            expect(DEEP_SYSTEM_PROMPT).toContain('god_class');
-            expect(DEEP_SYSTEM_PROMPT).toContain('god_function');
-            expect(DEEP_SYSTEM_PROMPT).toContain('srp_violation');
-            expect(DEEP_SYSTEM_PROMPT).toContain('race_condition');
-            expect(DEEP_SYSTEM_PROMPT).toContain('empty_catch');
-            expect(DEEP_SYSTEM_PROMPT).toContain('missing_test');
-        });
-        it('should include output schema', () => {
-            expect(DEEP_SYSTEM_PROMPT).toContain('"findings"');
-            expect(DEEP_SYSTEM_PROMPT).toContain('"category"');
-            expect(DEEP_SYSTEM_PROMPT).toContain('"severity"');
-            expect(DEEP_SYSTEM_PROMPT).toContain('"confidence"');
-        });
-        it('should contain Go-specific guidance', () => {
-            expect(DEEP_SYSTEM_PROMPT).toContain('Go code');
-            expect(DEEP_SYSTEM_PROMPT).toContain('struct');
-            expect(DEEP_SYSTEM_PROMPT).toContain('receiver method');
-        });
-    });
-    // ── buildAnalysisPrompt ──
-    describe('buildAnalysisPrompt', () => {
-        it('should build prompt with default checks', () => {
-            const factsStr = 'FILE: src/service.ts (typescript, 150 lines)';
-            const prompt = buildAnalysisPrompt(factsStr);
-            // Default checks include descriptions for SOLID, DRY, design patterns
-            expect(prompt).toContain('SOLID');
-            expect(prompt).toContain('DRY');
-            expect(prompt).toContain('god class');
-            expect(prompt).toContain(factsStr);
-        });
-        it('should include language-specific guidance for Go', () => {
-            const factsStr = 'FILE: pkg/server.go (go, 200 lines)\n  STRUCT Server (10 lines, 5 fields)';
-            const prompt = buildAnalysisPrompt(factsStr);
-            // Should detect Go as dominant language and add Go guidance
-            expect(prompt.toLowerCase()).toContain('go');
-        });
-        it('should include language-specific guidance for TypeScript', () => {
-            const factsStr = 'FILE: src/service.ts (typescript, 150 lines)\n  CLASS UserService';
-            const prompt = buildAnalysisPrompt(factsStr);
-            expect(prompt.toLowerCase()).toContain('typescript');
-        });
-        it('should respect custom check selection', () => {
-            const factsStr = 'FILE: src/service.ts (typescript, 150 lines)';
-            const checks = {
-                solid: true,
-                dry: false,
-                design_patterns: false,
-                concurrency: true,
-            };
-            const prompt = buildAnalysisPrompt(factsStr, checks);
-            expect(prompt).toContain('SOLID');
-            expect(prompt).toContain('Concurrency');
-        });
-    });
-    // ── buildCrossFilePrompt ──
-    describe('buildCrossFilePrompt', () => {
-        it('should analyze patterns across multiple files', () => {
-            const allFacts = [
-                makeTsFacts({ path: 'src/user.service.ts' }),
-                makeTsFacts({
-                    path: 'src/order.service.ts',
-                    classes: [{
-                            name: 'OrderService',
-                            lineStart: 1,
-                            lineEnd: 100,
-                            methodCount: 5,
-                            methods: ['find', 'create', 'update', 'delete', 'process'],
-                            publicMethods: ['find', 'create'],
-                            lineCount: 100,
-                            dependencies: ['Database', 'Logger'],
-                        }],
-                }),
-                makeTsFacts({
-                    path: 'src/product.service.ts',
-                    errorHandling: [
-                        { type: 'try-catch', lineStart: 5, isEmpty: false, strategy: 'log' },
-                        { type: 'try-catch', lineStart: 15, isEmpty: false, strategy: 'throw' },
-                    ],
-                }),
-            ];
-            const prompt = buildCrossFilePrompt(allFacts);
-            expect(prompt).toBeDefined();
-            expect(prompt.length).toBeGreaterThan(0);
-            // Should reference file count
-            expect(prompt).toContain('3');
-        });
-        it('should include Go-specific cross-file info', () => {
-            const allFacts = [
-                makeGoFacts({ path: 'pkg/server.go' }),
-                makeGoFacts({
-                    path: 'pkg/handler.go',
-                    structs: [{
-                            name: 'Handler',
-                            lineStart: 1,
-                            lineEnd: 50,
-                            fieldCount: 3,
-                            methodCount: 5,
-                            methods: ['Get', 'Post', 'Put', 'Delete', 'Options'],
-                            lineCount: 50,
-                            embeds: [],
-                        }],
-                }),
-            ];
-            const prompt = buildCrossFilePrompt(allFacts);
-            expect(prompt).toBeDefined();
-            expect(prompt.length).toBeGreaterThan(0);
-        });
-    });
-    // ── chunkFacts ──
-    describe('chunkFacts', () => {
-        it('never lets the serialized chunk overrun the prompt budget, so no file is dropped', () => {
-            const facts = Array.from({ length: 40 }, (_, i) => makeTsFacts({
-                path: `src/deeply/nested/module-${i}/implementation-file-with-a-long-name-${i}.ts`,
-                lineCount: 300,
-                imports: Array.from({ length: 8 }, (_, j) => `@scope/package-with-long-name-${j}/sub/path`),
-            }));
-            const chunks = chunkFacts(facts, 6000);
-            expect(chunks.flat()).toHaveLength(facts.length);
-            for (const chunk of chunks) {
-                const text = factsToPromptString(chunk);
-                for (const f of chunk)
-                    expect(text).toContain(`FILE: ${f.path}`);
-            }
-        });
-        it('should split facts into token-limited chunks', () => {
-            const manyFacts = Array.from({ length: 50 }, (_, i) => makeTsFacts({
-                path: `src/file${i}.ts`,
-                lineCount: 200,
-            }));
-            const chunks = chunkFacts(manyFacts, 4000);
-            expect(chunks.length).toBeGreaterThan(1);
-            // All facts should be distributed across chunks
-            const totalFiles = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-            expect(totalFiles).toBe(50);
-        });
-        it('should handle single file within budget', () => {
-            const facts = [makeTsFacts()];
-            const chunks = chunkFacts(facts, 10000);
-            expect(chunks).toHaveLength(1);
-            expect(chunks[0]).toHaveLength(1);
-        });
-        it('should handle empty input', () => {
-            const chunks = chunkFacts([], 4000);
-            expect(chunks).toHaveLength(0);
-        });
-    });
-});

package/dist/deep/reference-pack.test.d.ts

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

package/dist/deep/reference-pack.test.js

@@ -1,46 +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 { buildReferencePack } from './reference-pack.js';
-let repo;
-afterEach(() => { if (repo)
-    fs.rmSync(repo, { recursive: true, force: true }); repo = undefined; });
-function project() {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'reference-pack-'));
-    const files = {
-        'src/paths.ts': "export function cleanPath(p: string): string {\n  return p.replace(/\\/+/g, '/');\n}\n",
-        'src/routes.ts': "import { cleanPath } from './paths';\nexport function routePath(dir: string, route: string): string {\n  return cleanPath(`/${dir}${route}`);\n}\n",
-        'src/generator.ts': "import { routePath } from './routes';\nexport const home = routePath('.', '/');\n",
-    };
-    for (const [name, text] of Object.entries(files)) {
-        fs.mkdirSync(path.dirname(path.join(repo, name)), { recursive: true });
-        fs.writeFileSync(path.join(repo, name), text);
-    }
-    execFileSync('git', ['init', '-q'], { cwd: repo });
-    execFileSync('git', ['add', '-A'], { cwd: repo });
-    return repo;
-}
-describe('buildReferencePack', () => {
-    it('carries the intent, removed lines, callee definitions and callers of a changed export', () => {
-        const cwd = project();
-        const pack = buildReferencePack({
-            cwd, file: 'src/routes.ts', focusLines: [3], maxChars: 10_000,
-            prBody: 'Normalize virtual route paths.',
-            removed: [{ line: 3, text: ["  return `/${dir}${route}`;"] }],
-        });
-        expect(pack.text).toContain('PR DESCRIPTION (what the author intends):\nNormalize virtual route paths.');
-        expect(pack.text).toContain('REMOVED by this change, just before line 3 of src/routes.ts:\n-   return `/${dir}${route}`;');
-        expect(pack.text).toContain('CALLED: src/paths.ts:1\nexport function cleanPath');
-        expect(pack.text).toContain("CALLER of routePath:\nsrc/generator.ts:2:export const home = routePath('.', '/');");
-        expect(pack.source).toContain('cleanPath');
-    });
-    it('stays within its budget, keeping the highest-priority sections', () => {
-        const cwd = project();
-        const pack = buildReferencePack({ cwd, file: 'src/routes.ts', focusLines: [3], maxChars: 80, prBody: 'Normalize virtual route paths.' });
-        expect(pack.text).toContain('PR DESCRIPTION');
-        expect(pack.text).not.toContain('CALLED');
-        expect(pack.text.length).toBeLessThanOrEqual(80);
-    });
-});

package/dist/deep/related-changes.test.d.ts

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

package/dist/deep/related-changes.test.js

@@ -1,33 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { importsFrom, relatedChanges } from './related-changes.js';
-import { rankChangedFunctions } from './risk.js';
-let dir;
-const write = (file, body) => {
-    fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
-    fs.writeFileSync(path.join(dir, file), body);
-};
-beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'related-')); });
-afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-describe('relatedChanges', () => {
-    it('links a changed function to another changed file that imports and calls it, never tests or same-named functions', () => {
-        write('src/billing/price.ts', 'export function priceOf(row) {\n  return row.currency;\n}\n');
-        write('src/billing/invoice.ts', "import { priceOf } from './price';\n\nexport function invoice(row) {\n  return { cur: 'USD', price: priceOf(row) };\n}\n");
-        write('src/billing/price.test.ts', "import { priceOf } from './price';\npriceOf({});\n");
-        write('src/other/price.ts', 'export function priceOf(x) {\n  return 1;\n}\n');
-        write('src/other/use.ts', "import { priceOf } from './price';\nexport const y = () => priceOf(2);\n");
-        const focus = { 'src/billing/price.ts': [2], 'src/billing/invoice.ts': [4], 'src/billing/price.test.ts': [2], 'src/other/use.ts': [2] };
-        const links = relatedChanges(dir, Object.keys(focus), rankChangedFunctions(dir, focus));
-        expect(links).toEqual([{ callee: 'priceOf', calleeFile: 'src/billing/price.ts', calleeLine: 1, callerFile: 'src/billing/invoice.ts', callerLine: 4 }]);
-    });
-});
-describe('importsFrom', () => {
-    it('resolves relative and aliased module paths', () => {
-        expect(importsFrom("import { a, b } from '../lib/x';", 'b', 'src/app/y.ts', 'src/lib/x.ts')).toBe(true);
-        expect(importsFrom('import { b } from "@/lib/x";', 'b', 'src/app/y.ts', 'src/lib/x.ts')).toBe(true);
-        expect(importsFrom("import { bb } from '../lib/x';", 'b', 'src/app/y.ts', 'src/lib/x.ts')).toBe(false);
-        expect(importsFrom("import { b } from './x';", 'b', 'src/app/y.ts', 'src/lib/x.ts')).toBe(false);
-    });
-});

package/dist/deep/review-context-export.test.d.ts

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

package/dist/deep/review-context-export.test.js

@@ -1,32 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { buildCodeReviewPrompt } from './code-review-prompt.js';
-import { exportReviewContexts } from './review-context-export.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-const DIFF = `diff --git a/src/total.ts b/src/total.ts
---- a/src/total.ts
-+++ b/src/total.ts
-@@ -2,2 +2,2 @@
-   let sum = 0;
--  for (let i = 0; i < items.length; i++) sum += items[i];
-+  for (let i = 0; i <= items.length; i++) sum += items[i];
-`;
-describe('exportReviewContexts', () => {
-    it('emits the review prompt for each changed file, with its focus lines and what the change removed', async () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'review-context-'));
-        fs.mkdirSync(path.join(dir, 'src'));
-        fs.writeFileSync(path.join(dir, 'src/total.ts'), '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 [context, ...rest] = await exportReviewContexts(dir, DIFF, { prBody: 'Sum the basket.' });
-        expect(rest).toEqual([]);
-        expect(context.file).toBe('src/total.ts');
-        expect(context.focusLines).toEqual([3]);
-        expect(context.prompt.startsWith(buildCodeReviewPrompt({ file: '', language: '', text: '', ranges: [], source: '' }).slice(0, 60))).toBe(true);
-        expect(context.prompt).toContain('3|   for (let i = 0; i <= items.length; i++) sum += items[i];');
-        expect(context.prompt).toContain('-   for (let i = 0; i < items.length; i++) sum += items[i];');
-        expect(context.prompt).toContain('Sum the basket.');
-    });
-});

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

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

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

@@ -1,39 +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 { ReviewToolbox } from './review-tools.js';
-let repo;
-const call = (name, args) => ({ id: 'c1', name, arguments: args });
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'review-tools-'));
-    fs.mkdirSync(path.join(repo, 'src'));
-    fs.writeFileSync(path.join(repo, 'src/a.ts'), Array.from({ length: 300 }, (_, i) => `const v${i + 1} = ${i + 1};`).join('\n'));
-    fs.writeFileSync(path.join(repo, '.env'), 'API_KEY=secret');
-    execFileSync('git', ['init', '-q'], { cwd: repo });
-    execFileSync('git', ['add', '-A'], { cwd: repo });
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('ReviewToolbox', () => {
-    it('reads numbered lines, caps a call at 200 lines, and records what was read', () => {
-        const tools = new ReviewToolbox(repo);
-        const out = tools.run(call('read_file', { path: 'src/a.ts', start_line: 10, end_line: 900 }));
-        expect(out).toContain('src/a.ts lines 10-209 of 300');
-        expect(out).toContain('   10| const v10 = 10;');
-        expect(tools.reads.get('src/a.ts')).toEqual([[10, 209]]);
-        expect(tools.readText).toContain('const v209');
-    });
-    it('refuses paths outside the repository and secrets files, without throwing', () => {
-        const tools = new ReviewToolbox(repo);
-        expect(tools.run(call('read_file', { path: '../../etc/passwd' }))).toMatch(/^Error:/);
-        expect(tools.run(call('read_file', { path: '.env' }))).toBe('Error: this file is not readable by the reviewer');
-        expect(tools.reads.size).toBe(0);
-    });
-    it('greps tracked files but never shows a secrets file', () => {
-        const tools = new ReviewToolbox(repo);
-        expect(tools.run(call('grep', { pattern: 'v12 =' }))).toBe('src/a.ts:12:const v12 = 12;');
-        expect(tools.run(call('grep', { pattern: 'API_KEY' }))).toBe('No matches.');
-        expect(tools.run(call('shell', {}))).toBe('Unknown tool "shell".');
-    });
-});

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

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

package/dist/deep/risk.test.js

@@ -1,101 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { functionHash, rankChangedFunctions, scoreRisk } from './risk.js';
-import { DEFAULT_MIN_SCORE, routeFiles } from './router.js';
-let dir;
-beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'risk-')); });
-afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-const SYNC = [
-    'export async function syncOrders(db, cursor) {', // 1
-    '  for (const page of pages(cursor)) {', // 2
-    '    if (page.rows.length) {', // 3
-    "      await db.from('orders').upsert(page.rows);", // 4
-    '    }', // 5
-    '  }', // 6
-    '}', // 7
-    'function label(name) {', // 8
-    '  return name.trim();', // 9
-    '}', // 10
-].join('\n');
-const plain = { exported: false, async: false, nesting: 0, lines: 3, removedGuard: false, sensitive: [] };
-describe('rankChangedFunctions', () => {
-    it('reads the signals of each changed function', () => {
-        fs.writeFileSync(path.join(dir, 'sync.ts'), SYNC);
-        const ranked = rankChangedFunctions(dir, { 'sync.ts': [4, 9] }, { 'sync.ts': [{ line: 4, text: ['    if (!page.ok) return;'] }] });
-        const byName = Object.fromEntries(ranked.map(f => [f.name, f]));
-        expect(byName.syncOrders.signals).toEqual({
-            exported: true, async: true, nesting: 2, lines: 7, removedGuard: true, sensitive: ['data-write', 'paging'],
-        });
-        expect(byName.label.signals).toMatchObject({ exported: false, async: false, nesting: 0, removedGuard: false, sensitive: [] });
-        expect([byName.label.start, byName.label.end]).toEqual([8, 10]);
-    });
-});
-describe('test files', () => {
-    it('are never routed, however their fixtures read', () => {
-        fs.mkdirSync(path.join(dir, '__tests__'));
-        for (const file of ['sync.test.ts', 'sync.spec.js', '__tests__/sync.ts'])
-            fs.writeFileSync(path.join(dir, file), SYNC);
-        expect(rankChangedFunctions(dir, { 'sync.test.ts': [4], 'sync.spec.js': [4], '__tests__/sync.ts': [4] })).toEqual([]);
-    });
-});
-describe('team lessons as a risk signal', () => {
-    const lesson = (over) => ({
-        id: 'l1', text: 'Trim before comparing names.', file: 'sync.ts', symbols: ['trimStart'], state: 'verified',
-        evidence: [{ pr: 1, comment: 'c', author: 'r' }], createdAt: '', updatedAt: '', ...over,
-    });
-    const LABEL = 'function label(name) {\n  return name.trimStart();\n}\n';
-    it('makes a plain function risky when a lesson for its file names a symbol it uses', () => {
-        fs.writeFileSync(path.join(dir, 'sync.ts'), LABEL);
-        const [f] = rankChangedFunctions(dir, { 'sync.ts': [2] }, {}, [lesson({})]);
-        expect(f.signals.lesson).toBe('Trim before comparing names.');
-        expect(f.score).toBeGreaterThanOrEqual(DEFAULT_MIN_SCORE);
-    });
-    it('ignores lessons for other files and lessons naming only common words', () => {
-        fs.writeFileSync(path.join(dir, 'sync.ts'), LABEL);
-        const other = rankChangedFunctions(dir, { 'sync.ts': [2] }, {}, [lesson({ file: 'other.ts' }), lesson({ symbols: ['name'] })]);
-        expect(other[0].signals.lesson).toBeUndefined();
-        expect(other[0].score).toBe(0);
-    });
-});
-describe('scoreRisk', () => {
-    it('ranks a data write behind a removed guard above a plain helper', () => {
-        const risky = { exported: true, async: true, nesting: 2, lines: 30, removedGuard: true, sensitive: ['data-write', 'paging'] };
-        expect(scoreRisk(risky)).toBeGreaterThan(scoreRisk(plain));
-    });
-    it('gives a short, flat, private, non-sensitive function no model review', () => {
-        expect(scoreRisk(plain)).toBe(0);
-    });
-    it('never scores below zero', () => {
-        expect(scoreRisk({ ...plain, lines: 1 })).toBeGreaterThanOrEqual(0);
-    });
-});
-describe('routeFiles', () => {
-    it('always keeps files it cannot rank, and reports what it left to the gates', () => {
-        fs.writeFileSync(path.join(dir, 'helper.ts'), 'function label(name) {\n  return name.trim();\n}\n');
-        fs.writeFileSync(path.join(dir, 'query.py'), 'def f():\n    return 1\n');
-        const routed = routeFiles(dir, ['helper.ts', 'query.py'], { 'helper.ts': [2], 'query.py': [2] }, {}, { min_score: 1 });
-        expect([...routed.files]).toEqual(['query.py']);
-        expect(routed.stats).toEqual({ functions: 1, routed: 0, files_skipped: 1, already_reviewed: 0 });
-    });
-    it('skips a risky function reviewed before at exactly this code, and only that code', () => {
-        fs.writeFileSync(path.join(dir, 'sync.ts'), SYNC);
-        const [risky] = rankChangedFunctions(dir, { 'sync.ts': [4] });
-        const cleared = routeFiles(dir, ['sync.ts'], { 'sync.ts': [4] }, {}, {}, [{ file: 'sync.ts', function: 'syncOrders', hash: risky.hash }]);
-        expect(cleared.stats).toMatchObject({ routed: 0, already_reviewed: 1, files_skipped: 1 });
-        const stale = routeFiles(dir, ['sync.ts'], { 'sync.ts': [4] }, {}, {}, [{ file: 'sync.ts', function: 'syncOrders', hash: 'old' }]);
-        expect(stale.stats).toMatchObject({ routed: 1, already_reviewed: 0 });
-    });
-});
-describe('functionHash', () => {
-    it('changes when anything inside the function changes, strings included', () => {
-        const a = 'function f() { return "a  b"; }';
-        const b = 'function f() { return "a b"; }';
-        expect(functionHash(a)).not.toBe(functionHash(b));
-        expect(functionHash('function f() { return `x ${y}`; }')).not.toBe(functionHash('function f() { return `x  ${y}`; }'));
-    });
-    it('treats a Windows checkout of the same code as the same code', () => {
-        expect(functionHash('function f() {\r\n  return 1;\r\n}')).toBe(functionHash('function f() {\n  return 1;\n}'));
-    });
-});

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

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