@rigour-labs/core 6.8.0 → 6.8.1

package/dist/review/stories.test.d.ts

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

package/dist/review/stories.test.js

@@ -1,58 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { recordReviewOutcome } from './agent-fixes.js';
-import { readAgentEvents } from './effectiveness.js';
-import { recordLessonsServed, recordPrCatches } from './learning-events.js';
-import { compactDiff, readStories } from './stories.js';
-let cwd;
-beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'stories-')); fs.mkdirSync(path.join(cwd, 'src')); });
-afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
-const finding = (id, title) => ({ id, title, details: `${title}.`, severity: 'high', files: ['src/a.ts'], line: 2 });
-describe('compactDiff', () => {
-    it('keeps only the changed lines and two lines of context', () => {
-        const before = ['a', 'b', 'c', 'old', 'd', 'e', 'f'].join('\n');
-        const after = ['a', 'b', 'c', 'new', 'd', 'e', 'f'].join('\n');
-        expect(compactDiff(before, after)).toEqual([' b', ' c', '-old', '+new', ' d', ' e']);
-    });
-});
-describe('stories from fixes', () => {
-    it('credits a fix to the stage that first reported it, with the code change', () => {
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), "fetch(url, { headers });\n");
-        recordReviewOutcome(cwd, [finding('semantic-bugs', 'Credential header follows redirects')], ['src/a.ts'], 'edit');
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), "fetch(url, { headers, redirect: 'error' });\n");
-        recordReviewOutcome(cwd, [], ['src/a.ts'], 'stop');
-        const [story] = readStories(cwd);
-        expect(story).toMatchObject({ stage: 'edit', file: 'src/a.ts', rule: 'semantic-bugs', title: 'Credential header follows redirects' });
-        expect(story.diff).toEqual(['-fetch(url, { headers });', "+fetch(url, { headers, redirect: 'error' });", ' ']);
-    });
-    it('writes no story for a finding someone dismissed, even after its file changed', async () => {
-        const { dismissFinding, findingKey } = await import('./quiet.js');
-        const f = finding('semantic-bugs', 'Looks risky');
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'x\n');
-        recordReviewOutcome(cwd, [f], ['src/a.ts'], 'review');
-        dismissFinding(cwd, findingKey(f), 'intended');
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'y\n');
-        recordReviewOutcome(cwd, [], ['src/a.ts'], 'review');
-        expect(readStories(cwd)).toEqual([]);
-    });
-    it('writes no story while the finding is still open', () => {
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'x\n');
-        recordReviewOutcome(cwd, [finding('semantic-bugs', 'X')], ['src/a.ts'], 'review');
-        expect(readStories(cwd)).toEqual([]);
-    });
-});
-describe('learning events', () => {
-    it('records lessons served and PR catches, and nothing when there are none', () => {
-        recordLessonsServed(cwd, 'recall', []);
-        recordPrCatches(cwd, []);
-        expect(readAgentEvents(cwd)).toEqual([]);
-        recordLessonsServed(cwd, 'review', ['Never follow redirects with credentials', 'Never follow redirects with credentials']);
-        recordPrCatches(cwd, [finding('semantic-bugs', 'Unbounded query')]);
-        expect(readAgentEvents(cwd)).toEqual([
-            expect.objectContaining({ type: 'lessons_served', via: 'review', lessons: ['Never follow redirects with credentials'] }),
-            expect.objectContaining({ type: 'pr_catches', findings: [{ rule: 'semantic-bugs', title: 'Unbounded query', file: 'src/a.ts' }] }),
-        ]);
-    });
-});

package/dist/review/toolchain.test.d.ts

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

package/dist/review/toolchain.test.js

@@ -1,108 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { ConfigSchema } from '../types/index.js';
-import { runToolchain } from './toolchain.js';
-let dir;
-const config = (commands = {}) => ConfigSchema.parse({ version: 1, commands });
-/** A fake installed tool: node logic plus the sh and .cmd shims npm would create. */
-function tool(name, logic) {
-    const bin = path.join(dir, 'node_modules', '.bin');
-    fs.mkdirSync(bin, { recursive: true });
-    fs.writeFileSync(path.join(bin, `${name}.js`), `const fs = require('fs'); const args = process.argv.slice(2);\nfs.appendFileSync(${JSON.stringify(path.join(dir, 'calls.log'))}, ${JSON.stringify(name)} + ' ' + args.join(' ') + '\\n');\n${logic}\n`);
-    fs.writeFileSync(path.join(bin, name), `#!/bin/sh\nexec node "$(dirname "$0")/${name}.js" "$@"\n`, { mode: 0o755 });
-    fs.writeFileSync(path.join(bin, `${name}.cmd`), `@node "%~dp0\\${name}.js" %*\r\n`);
-}
-const calls = () => (fs.existsSync(path.join(dir, 'calls.log')) ? fs.readFileSync(path.join(dir, 'calls.log'), 'utf8') : '');
-beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'toolchain-'));
-    fs.mkdirSync(path.join(dir, 'src'));
-    fs.writeFileSync(path.join(dir, 'src/a.ts'), 'export const a = 1;\n');
-    fs.writeFileSync(path.join(dir, 'src/bad.ts'), 'BAD\n');
-});
-afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-describe('runToolchain', () => {
-    it('reports every tool the project did not install as skipped, never downloading one', async () => {
-        const results = await runToolchain(dir, ['src/a.ts'], config());
-        expect(results.map(r => [r.tool, r.status])).toEqual([['format', 'skipped'], ['lint', 'skipped'], ['overlay', 'skipped'], ['typecheck', 'skipped'], ['test', 'skipped'], ['knip', 'skipped']]);
-    });
-    it('fails, not skips, a tool the project declares but has not installed: a checkout without its dependencies proves nothing', async () => {
-        fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ devDependencies: { eslint: '^9', typescript: '^5' } }));
-        const results = await runToolchain(dir, ['src/a.ts'], config());
-        expect(results.map(r => [r.tool, r.status])).toEqual([['format', 'skipped'], ['lint', 'fail'], ['overlay', 'skipped'], ['typecheck', 'fail'], ['test', 'skipped'], ['knip', 'skipped']]);
-        expect(results.find(r => r.tool === 'lint')).toMatchObject({ command: 'eslint is in package.json but not installed', output: expect.stringContaining('install the dependencies') });
-    });
-    it('runs type-checked rules the project does not enable, blocking on changed lines only, with the project\'s own eslint and config', async () => {
-        fs.writeFileSync(path.join(dir, 'eslint.config.js'), 'export default [];\n');
-        fs.mkdirSync(path.join(dir, 'node_modules/typescript-eslint'), { recursive: true });
-        fs.writeFileSync(path.join(dir, 'node_modules/typescript-eslint/package.json'), '{"name":"typescript-eslint","main":"index.js"}');
-        fs.writeFileSync(path.join(dir, 'node_modules/typescript-eslint/index.js'), 'module.exports = {};');
-        const report = JSON.stringify([{ filePath: path.join(dir, 'src/a.ts'), messages: [
-                    { line: 2, column: 5, ruleId: '@typescript-eslint/no-unnecessary-condition', message: 'Unnecessary conditional, value is always truthy.' },
-                    { line: 9, column: 1, ruleId: '@typescript-eslint/no-floating-promises', message: 'Promises must be awaited.' },
-                ] }]);
-        tool('eslint', `if (args[0] === '--version') { console.log('v9.0.0'); process.exit(0); }\nif (args.includes('--format')) { console.log(${JSON.stringify(report)}); process.exit(1); }\nprocess.exit(0);`);
-        const results = await runToolchain(dir, ['src/a.ts'], config(), { 'src/a.ts': new Set([1, 2, 3]) });
-        const overlay = results.find(r => r.tool === 'overlay');
-        expect(overlay).toMatchObject({ status: 'fail', lines: ['src/a.ts:2:5 @typescript-eslint/no-unnecessary-condition: Unnecessary conditional, value is always truthy.'] });
-        expect(overlay.command).toContain('1 on changed lines, 1 pre-existing (not blocking)');
-        const call = calls().split('\n').find(line => line.includes('--format json'));
-        expect(call).toMatch(/eslint --config \S+eslint\.overlay\.config\.mjs --no-warn-ignored --format json src\/a\.ts/);
-        expect(fs.readdirSync(dir)).not.toContain('eslint.overlay.config.mjs'); // never written into the repository
-        // Nothing on a changed line: pass, backlog counted.
-        const clean = await runToolchain(dir, ['src/a.ts'], config(), { 'src/a.ts': new Set([7]) });
-        expect(clean.find(r => r.tool === 'overlay')).toMatchObject({ status: 'pass', command: expect.stringContaining('0 on changed lines, 2 pre-existing') });
-    });
-    it('runs knip when the project installs it, and reports only what is in the changed files', async () => {
-        const report = JSON.stringify({ files: [path.join(dir, 'src/dead.ts'), 'src/elsewhere.ts'], issues: [
-                { file: 'src/a.ts', exports: [{ name: 'spare', line: 3, col: 1 }], types: [{ name: 'Spare', line: 4, col: 1 }] },
-                { file: 'src/other.ts', exports: [{ name: 'old', line: 1, col: 1 }], types: [] },
-            ] });
-        tool('knip', `console.log(${JSON.stringify(report)}); process.exit(1);`);
-        fs.writeFileSync(path.join(dir, 'src/dead.ts'), 'export const dead = 1;\n');
-        const results = await runToolchain(dir, ['src/a.ts', 'src/dead.ts'], config());
-        expect(results.find(r => r.tool === 'knip')).toMatchObject({ status: 'fail', lines: ['src/dead.ts: nothing imports or runs this file', 'src/a.ts:3: unused export spare', 'src/a.ts:4: unused export Spare'] });
-        expect(calls()).toContain('knip --production --no-progress --reporter json');
-    });
-    it('runs the formatter on changed files only and reports what it said', async () => {
-        tool('prettier', "const bad = args.filter(a => a.endsWith('.ts') && fs.readFileSync(a, 'utf8').includes('BAD'));\nif (bad.length) { console.log('[warn] ' + bad.join(' ')); process.exit(1); }");
-        const [format] = await runToolchain(dir, ['src/a.ts', 'src/bad.ts', 'src/gone.ts'], config());
-        expect(format).toMatchObject({ tool: 'format', status: 'fail' });
-        expect(format.output).toContain('src/bad.ts');
-        expect(calls()).toContain('prettier --check --ignore-unknown src/a.ts src/bad.ts');
-        expect(calls()).not.toContain('gone.ts');
-    });
-    it('quiets ESLint 9 about ignored files, and runs a tool set under commands: as that command, whose failure fails the push', async () => {
-        tool('eslint', "if (args[0] === '--version') { console.log('v9.1.0'); process.exit(0); }");
-        tool('prettier', 'process.exit(0);');
-        const results = await runToolchain(dir, ['src/a.ts'], config({ format: 'node -e "process.exit(4)"', test: 'node -e "process.exit(0)"' }));
-        expect(results.find(r => r.tool === 'lint')).toMatchObject({ status: 'pass' });
-        expect(calls()).toContain('eslint --max-warnings=0 --no-warn-ignored src/a.ts');
-        expect(results.find(r => r.tool === 'format')).toMatchObject({ status: 'fail', command: expect.stringContaining('node -e') });
-        expect(calls()).not.toContain('prettier'); // the team's command replaces the detected tool
-        expect(results.find(r => r.tool === 'test')).toMatchObject({ status: 'pass' });
-    });
-    it("uses the project's own check script for types, and never hands a tool Rigour's own files", async () => {
-        fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ scripts: { check: 'node -e "process.exit(3)"' } }));
-        tool('prettier', 'process.exit(0);');
-        const results = await runToolchain(dir, ['src/a.ts', '.rigour/scan-cache.json', 'rigour-report.json'], config());
-        expect(results.find(r => r.tool === 'typecheck')).toMatchObject({ status: 'fail', command: expect.stringContaining('npm') });
-        expect(calls()).toContain('prettier --check --ignore-unknown src/a.ts\n');
-    });
-    it('finds svelte-check by its binary, generating SvelteKit types first, with no svelte.config file', async () => {
-        tool('svelte-kit', 'process.exit(0);');
-        tool('svelte-check', 'process.exit(0);');
-        fs.writeFileSync(path.join(dir, 'tsconfig.json'), '{}');
-        const typecheck = (await runToolchain(dir, ['src/a.ts'], config())).find(r => r.tool === 'typecheck');
-        expect(typecheck).toMatchObject({ status: 'pass', command: expect.stringContaining('svelte-check') });
-        expect(calls().indexOf('svelte-kit sync')).toBeLessThan(calls().indexOf('svelte-check'));
-    });
-    it('runs a test file that failed in the parallel run again alone, so a timing flake passes', async () => {
-        tool('vitest', "if (args[0] === 'related') { console.log(' FAIL  src/a.test.ts > flaky'); process.exit(1); }\nprocess.exit(0);");
-        const test = (await runToolchain(dir, ['src/a.ts'], config())).find(r => r.tool === 'test');
-        expect(test.status).toBe('pass');
-        expect(test.command).toContain('flaky files passed alone: src/a.test.ts');
-        expect(calls()).toContain('vitest run src/a.test.ts');
-    });
-});

package/dist/review/typed/redundancy.test.d.ts

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

package/dist/review/typed/redundancy.test.js

@@ -1,315 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import { createRequire } from 'module';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { ConfigSchema } from '../../types/index.js';
-import { reviewChange } from '../review.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const write = (rel, body) => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-const config = (redundancy = {}) => ConfigSchema.parse({ version: 1, gates: { redundancy, unused_exports: { enabled: false }, orphan_files: { enabled: false } } });
-const typescriptDir = path.dirname(createRequire(import.meta.url).resolve('typescript/package.json'));
-const DB = `export interface Row { id: string; set_id: string | null; updated_at: string }
-export class Query<T> {
-    not(_column: string, _operator: string, _value: unknown): Query<T> { return this; }
-    gte(_column: string, _value: unknown): Query<T> { return this; }
-    returns<R>(): Promise<R> { return Promise.resolve([] as unknown as R); }
-}
-export function from(_table: string): Query<unknown> { return new Query(); }
-`;
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'typed-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write('package.json', '{"name":"fixture","devDependencies":{"typescript":"*"}}\n');
-    write('tsconfig.json', '{"compilerOptions":{"strict":true,"module":"esnext","target":"es2022","moduleResolution":"bundler","skipLibCheck":true},"include":["src"]}\n');
-    write('.gitignore', 'node_modules\n');
-    fs.mkdirSync(path.join(repo, 'node_modules'));
-    fs.symlinkSync(typescriptDir, path.join(repo, 'node_modules/typescript'), 'junction'); // the project's own compiler, never downloaded
-    write('src/db.ts', DB);
-    write('src/main.ts', "export const main = 1;\n");
-    git('add', '-A');
-    git('commit', '-qm', 'base');
-    git('checkout', '-qb', 'feature');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-const review = (cfg = config()) => reviewChange({ cwd: repo, config: cfg, source: { mode: 'base', base: 'main' }, typed: true });
-describe('what a change made redundant', () => {
-    it('reports a null filter beside a range on the same column, and the nullable row type the query filters non-null', async () => {
-        write('src/scan.ts', `import { from, type Row } from './db';
-export async function scan(since: string): Promise<Row[]> {
-    return from('t').not('set_id', 'is', null).gte('set_id', since).returns<Row[]>();
-}
-`);
-        git('add', '-A');
-        git('commit', '-qm', 'scan');
-        const result = await review();
-        const found = result.findings.map(f => [f.id, f.files?.[0], f.line]);
-        expect(found).toContainEqual(['duplicate-null-filter', 'src/scan.ts', 3]);
-        expect(found).toContainEqual(['nullable-filtered-column', 'src/scan.ts', 3]); // anchored on the query the change wrote
-        expect(result.findings.find(f => f.id === 'nullable-filtered-column')?.details).toContain('declared nullable at src/db.ts:1');
-        expect(result.findings.find(f => f.id === 'duplicate-null-filter')?.details).toContain("`.gte('set_id', …)` at src/scan.ts:3");
-    }, 60_000);
-    it('reports an optional member every host supplies and a property written but never read; a spread host or a read elsewhere clears them', async () => {
-        write('src/types.ts', 'export interface Candidate { userId?: string; title: string; extra: string }\n');
-        write('src/a.ts', "import type { Candidate } from './types';\nexport const a: Candidate = { userId: 'u1', title: 'one', extra: 'x' };\n");
-        write('src/b.ts', "import type { Candidate } from './types';\nexport const b: Candidate = { userId: 'u2', title: 'two', extra: 'y' };\n");
-        write('src/use.ts', "import { a } from './a';\nimport { b } from './b';\nexport const titles = [a.title, b.title];\n");
-        git('add', '-A');
-        git('commit', '-qm', 'candidates');
-        const result = await review();
-        const found = result.findings.map(f => [f.id, f.files?.[0]]);
-        expect(found).toContainEqual(['optional-always-supplied', 'src/types.ts']);
-        expect(found).toContainEqual(['write-only-property', 'src/types.ts']);
-        const writeOnly = result.findings.filter(f => f.id === 'write-only-property').map(f => f.details.match(/`([^`]+)`/)[1]);
-        expect(writeOnly).toEqual(['Candidate.userId', 'Candidate.extra']); // userId is supplied everywhere and read nowhere: both findings hold
-        expect(found.map(([id]) => id)).not.toContain('typed-checks-unavailable');
-        // Declared as a wire contract: another service reads it, so nothing on it is write-only.
-        const wired = await review(config({ wire_contracts: ['src/types.ts'] }));
-        expect(wired.findings.map(f => f.id)).not.toContain('write-only-property');
-        // A value that leaves only through serialisation is a hint for the reviewer, not a block.
-        write('src/send.ts', "import { a } from './a';\nexport const body = JSON.stringify(a);\n");
-        git('add', '-A');
-        git('commit', '-qm', 'send');
-        const sent = await review();
-        expect(sent.findings.map(f => f.id)).not.toContain('write-only-property');
-        expect(sent.hints).toEqual([expect.stringContaining('Candidate.userId is set by 2 host(s)'), expect.stringContaining('write-only-property src/types.ts:1: Candidate.extra')]);
-        expect(sent.hints[1]).toContain('leaves only through JSON.stringify() at src/send.ts:2');
-    }, 60_000);
-    it('in a library, an exported type has consumers the program cannot see: its members are hints, a local type still blocks', async () => {
-        write('tsconfig.json', '{"compilerOptions":{"strict":true,"declaration":true,"module":"esnext","target":"es2022","moduleResolution":"bundler","skipLibCheck":true},"include":["src"]}\n');
-        write('src/types.ts', 'export interface Result { items?: string[]; cached: boolean }\ninterface Local { note: string }\nexport const local: Local = { note: "n" };\n');
-        write('src/a.ts', "import type { Result } from './types';\nexport const a: Result = { items: [], cached: true };\n");
-        write('src/b.ts', "import type { Result } from './types';\nexport const b: Result = { items: [], cached: false };\n");
-        git('add', '-A');
-        git('commit', '-qm', 'library');
-        const result = await review();
-        expect(result.findings.map(f => [f.id, f.details.match(/`([^`]+)`/)[1]])).toEqual([['write-only-property', 'Local.note']]);
-        expect(result.hints).toEqual([
-            expect.stringMatching(/^optional-always-supplied src\/types\.ts:1: `Result\.items` is optional .* consumers outside this program may read it\)$/),
-            expect.stringMatching(/^write-only-property src\/types\.ts:1: `Result\.items` is set by 2 host\(s\)/),
-            expect.stringMatching(/^write-only-property src\/types\.ts:1: `Result\.cached` is set by 2 host\(s\)/),
-        ]);
-    }, 60_000);
-    it('hints at a function that scans a collection, called once per item of another', async () => {
-        write('src/later.ts', 'export function hasLater(starts: string[], at: string): boolean {\n    return starts.some(s => s > at);\n}\nexport function plan(rows: string[], starts: string[]): boolean[] {\n    return rows.map(r => hasLater(starts, r));\n}\n');
-        git('add', '-A');
-        git('commit', '-qm', 'later');
-        const result = await review();
-        expect(result.hints).toEqual([expect.stringMatching(/^nested-scan src\/later\.ts:5: hasLater\(\) scans its `starts` argument and is called inside \.map\(\) over rows/)]);
-        expect(result.findings).toEqual([]);
-    }, 60_000);
-    it('says nothing for a project with no tsconfig, and blocks a TypeScript project whose program cannot be built', async () => {
-        write('src/x.ts', 'export const x = 1;\n');
-        git('add', '-A');
-        git('commit', '-qm', 'x');
-        fs.unlinkSync(path.join(repo, 'tsconfig.json'));
-        expect((await review()).findings).toEqual([]);
-        write('tsconfig.json', '{"extends":"./.generated/tsconfig.json"}\n');
-        const broken = await review();
-        expect(broken.status).toBe('ERROR'); // a check that could not run is a crashed gate, never a pass
-        expect(broken.gateErrors).toEqual(['typed-checks-unavailable']);
-        expect(broken.typedError).toMatch(/\.generated\/tsconfig\.json.*install the dependencies/s);
-    }, 60_000);
-});
-describe('a null guard on a column the query makes non-null', () => {
-    const SESSION = `import { from } from './db';
-export interface Session { id: string; ended_at: string | null; label: string | null }
-export async function endedSessions(): Promise<Session[]> {
-    return from('sessions').not('ended_at', 'is', null).returns<Session[]>();
-}
-`;
-    const CONSUMER = `import { endedSessions } from './sessions';
-export async function summary(): Promise<string[]> {
-    const rows = await endedSessions();
-    return rows.map(row => {
-        if (row.ended_at == null) return 'open';
-        const ended = row.ended_at ?? 'never';
-        if (!row.label) return ended;
-        return row.label;
-    });
-}
-`;
-    const guards = async () => (await review()).advisory.filter(f => f.id === 'dead-null-guard').map(f => [f.files?.[0], f.line]);
-    it('names each guard the filter made dead, and leaves a guard on a column no query filters alone', async () => {
-        write('src/sessions.ts', SESSION);
-        write('src/summary.ts', CONSUMER);
-        git('add', '-A');
-        git('commit', '-qm', 'sessions');
-        expect(await guards()).toEqual([['src/summary.ts', 5], ['src/summary.ts', 6]]);
-    });
-    it("names a truthiness test on a filtered string column with the empty-string case, and leaves a number's alone", async () => {
-        write('src/sessions.ts', `import { from } from './db';
-export interface Visit { id: string; page: string | null; seconds: number | null }
-export async function visits(): Promise<Visit[]> {
-    return from('visits').not('page', 'is', null).not('seconds', 'is', null).returns<Visit[]>();
-}
-export async function pages(): Promise<string[]> {
-    return (await visits()).filter(v => !!v.page && !v.seconds).map(v => v.page ?? '');
-}
-`);
-        git('add', '-A');
-        git('commit', '-qm', 'visits');
-        const result = (await review()).advisory.filter(f => f.id === 'dead-null-guard');
-        expect(result.map(f => f.line)).toEqual([7, 7]); // \`!v.page\` and \`v.page ?? ''\`, not \`!v.seconds\`
-        expect(result.some(f => /empty string/.test(f.details ?? ''))).toBe(true);
-    });
-    it('follows a query typed through a generic pager and an intersection, and ignores the pager\'s own type parameter', async () => {
-        write('src/pager.ts', `import { from, type Query } from './db';
-export async function readAll<Row>(page: () => Query<unknown>): Promise<Row[]> {
-    await page();
-    return from('audit').returns<Row[]>(); // the helper's own query, typed by its parameter: not a row type
-}
-`);
-        write('src/sessions.ts', `import { from } from './db';
-import { readAll } from './pager';
-export interface Session { id: string; ended_at: string | null }
-export async function endedSessions(): Promise<Session[]> {
-    return readAll<Session & Record<string, unknown>>(() => from('sessions').not('ended_at', 'is', null));
-}
-export async function summary(): Promise<string[]> {
-    return (await endedSessions()).map(row => row.ended_at ?? 'never');
-}
-`);
-        git('add', '-A');
-        git('commit', '-qm', 'pager');
-        expect(await guards()).toEqual([['src/sessions.ts', 8]]);
-    });
-    it('says nothing when another query returns the same rows unfiltered', async () => {
-        write('src/sessions.ts', `${SESSION}export async function allSessions(): Promise<Session[]> {
-    return from('sessions').returns<Session[]>();
-}
-`);
-        write('src/summary.ts', CONSUMER);
-        git('add', '-A');
-        git('commit', '-qm', 'sessions');
-        expect(await guards()).toEqual([]);
-    });
-    it('says nothing when code builds such a row with the column null', async () => {
-        write('src/sessions.ts', `${SESSION}export const draft: Session = { id: 'new', ended_at: null, label: null };
-`);
-        write('src/summary.ts', CONSUMER);
-        git('add', '-A');
-        git('commit', '-qm', 'sessions');
-        expect(await guards()).toEqual([]);
-    });
-});
-describe('an input production never varies', () => {
-    const found = async (id) => (await review()).advisory.filter(f => f.id === id).map(f => [f.files?.[0], f.line]);
-    const commit = () => { git('add', '-A'); git('commit', '-qm', 'change'); };
-    it('names a member every production object sets to the same value while code branches on it; tests do not count', async () => {
-        write('src/jobs.ts', `export interface Job { id: string; retries: number }
-export function next(job: Job): string { return job.retries > 0 ? 'retry' : 'run'; }
-export const nightly: Job = { id: 'nightly', retries: 0 };
-export const hourly: Job = { id: 'hourly', retries: 0 };
-`);
-        write('src/jobs.test.ts', `import { next } from './jobs';
-export const flaky = next({ id: 'flaky', retries: 3 });
-`);
-        commit();
-        expect(await found('constant-member')).toEqual([['src/jobs.ts', 1]]);
-    });
-    it('says nothing when production sets the member differently', async () => {
-        write('src/jobs.ts', `export interface Job { id: string; retries: number }
-export function next(job: Job): string { return job.retries > 0 ? 'retry' : 'run'; }
-export const nightly: Job = { id: 'nightly', retries: 0 };
-export const hourly: Job = { id: 'hourly', retries: 2 };
-`);
-        commit();
-        expect(await found('constant-member')).toEqual([]);
-    });
-    it('names a parameter every production call passes the same literal while the body branches on it', async () => {
-        write('src/format.ts', `export function label(text: string, upper: boolean): string { return upper ? text.toUpperCase() : text; }
-export const a = label('one', false);
-export const b = label('two', false);
-export function wrap(text: string, client: { send(t: string): string }): string { return client.send(text); }
-`);
-        write('src/send.ts', `import { wrap } from './format';
-const client = { send: (t: string) => t };
-export const x = wrap('a', client);
-export const y = wrap('b', client); // the same variable name is not the same literal
-`);
-        write('src/format.test.ts', `import { label } from './format';
-export const loud = label('three', true);
-`);
-        commit();
-        expect(await found('constant-argument')).toEqual([['src/format.ts', 1]]);
-    });
-    it('says nothing when production calls vary, or the function is passed around as a value', async () => {
-        write('src/format.ts', `export function label(text: string, upper: boolean): string { return upper ? text.toUpperCase() : text; }
-export const a = label('one', false);
-export const b = label('two', true);
-export function shout(text: string, loud: boolean): string { return loud ? text + '!' : text; }
-export const c = shout('x', false);
-export const d = shout('y', false);
-export const handlers = [shout];
-`);
-        commit();
-        expect(await found('constant-argument')).toEqual([]);
-    });
-});
-describe('a nullable row type for a NOT NULL column, from migrations in another repository', () => {
-    const SUPABASE = `export class Query<T> {
-    select(_columns: string): Query<T> { return this; }
-    returns<R>(): Promise<R> { return Promise.resolve([] as unknown as R); }
-}
-export const db = {
-    schema(_name: string) { return db; },
-    from(_table: string): Query<unknown> { return new Query(); },
-};
-`;
-    let migrations;
-    beforeEach(() => {
-        migrations = fs.mkdtempSync(path.join(os.tmpdir(), 'other-repo-migrations-'));
-        fs.writeFileSync(path.join(migrations, '20240101_sets.sql'), 'create table study_set (id uuid primary key, owner_id uuid not null, title text, archived_at timestamptz not null);');
-        write('src/sb.ts', SUPABASE);
-        git('add', '-A');
-        git('commit', '-qm', 'client');
-    });
-    afterEach(() => { fs.rmSync(migrations, { recursive: true, force: true }); });
-    it('notes the nullable member the change declared, never blocking, and skips nullable columns and aliases', async () => {
-        write('src/sets.ts', `import { db } from './sb';
-export interface SetRow { id: string; owner_id: string | null; title: string | null; done: string | null }
-export async function sets(): Promise<SetRow[]> {
-    return db.from('study_set').select('id, owner_id, title, done:archived_at').returns<SetRow[]>();
-}
-`);
-        git('add', '-A');
-        git('commit', '-qm', 'sets');
-        const result = await review(config({ schema_migrations: [migrations] }));
-        expect(result.findings.filter(f => f.id === 'nullable-not-null-column')).toEqual([]);
-        const notes = result.advisory.filter(f => f.id === 'nullable-not-null-column');
-        expect(notes.map(f => [f.files?.[0], f.line])).toEqual([['src/sets.ts', 2]]);
-        expect(notes[0].details).toContain('`owner_id` is declared nullable at src/sets.ts:2 but `study_set.owner_id` is NOT NULL');
-    });
-    it('anchors on the new query when the row type is older, and reads the schema the query names', async () => {
-        fs.writeFileSync(path.join(migrations, '20240202_app.sql'), 'create table app.study_set (id uuid, owner_id uuid);');
-        git('checkout', '-q', 'main'); // the row type is older than the branch
-        write('src/rows.ts', 'export interface SetRow { id: string; owner_id: string | null }\n');
-        git('add', '-A');
-        git('commit', '-qm', 'rows');
-        git('checkout', '-q', 'feature');
-        git('merge', '-q', '--no-edit', 'main');
-        write('src/sets.ts', `import { db } from './sb';
-import type { SetRow } from './rows';
-export async function publicSets(): Promise<SetRow[]> {
-    return db
-        .from('study_set').select('*').returns<SetRow[]>();
-}
-export async function appSets(): Promise<SetRow[]> {
-    return db.schema('app').from('study_set').select('*').returns<SetRow[]>();
-}
-`);
-        git('add', '-A');
-        git('commit', '-qm', 'sets');
-        const result = await review(config({ schema_migrations: [migrations] }));
-        expect(result.advisory.filter(f => f.id === 'nullable-not-null-column').map(f => [f.files?.[0], f.line])).toEqual([['src/sets.ts', 5]]);
-    });
-});

package/dist/review/typed/schema-nullability.test.d.ts

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

package/dist/review/typed/schema-nullability.test.js

@@ -1,63 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { describe, expect, it } from 'vitest';
-import { loadSchemaNullability, tableKey } from './schema-nullability.js';
-/** The migrations as numbered files in a folder of their own, replayed. */
-const replay = (...migrations) => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'migrations-'));
-    try {
-        migrations.forEach((sql, i) => fs.writeFileSync(path.join(dir, `${String(i).padStart(3, '0')}_step.sql`), sql));
-        return loadSchemaNullability(dir, ['.']);
-    }
-    finally {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-};
-const columns = (schema, table) => Object.fromEntries(schema.get(tableKey(table)) ?? []);
-describe('NOT NULL columns from migrations', () => {
-    it('reads column definitions, primary keys and quoted names, ignoring strings, comments and CHECK text', () => {
-        const schema = replay(`
--- a comment; with a semicolon
-create table if not exists public.study_set (
-    id uuid primary key default gen_random_uuid(),
-    "OwnerId" uuid not null references auth.users(id),
-    title text default 'not null' ,
-    archived_at timestamptz check (archived_at is not null or title is null),
-    kind text NOT NULL,
-    /* block; comment */
-    constraint study_set_title_unique unique (title)
-);`);
-        expect(columns(schema, 'study_set')).toEqual({ id: true, OwnerId: true, title: false, archived_at: false, kind: true });
-    });
-    it('follows ALTER TABLE in file order: add, set and drop NOT NULL, rename, drop column, rename table', () => {
-        const schema = replay('create table app.card (id bigint, set_id bigint, body text);', `alter table only app.card add column if not exists due_at timestamptz not null default now(),
-                alter column set_id set not null, add constraint card_pk primary key (id);`, 'alter table app.card alter column body set not null; alter table app.card alter column body drop not null;', 'alter table app.card rename column due_at to next_due_at; alter table app.card drop column if exists body;', 'alter table app.card rename to flashcard;');
-        expect(schema.has(tableKey('app.card'))).toBe(false);
-        expect(columns(schema, 'app.flashcard')).toEqual({ id: true, set_id: true, next_due_at: true });
-    });
-    it('keeps a function body whole and treats tables it cannot read as unknown', () => {
-        const schema = replay(`create function touch() returns trigger language plpgsql as $$ begin new.updated_at = now(); return new; end; $$;
-             create table copy as select * from other;
-             create table part partition of parent for values in (1);
-             create table gone (id int not null); drop table if exists gone cascade;`);
-        expect(schema.get(tableKey('copy'))).toBeNull();
-        expect(schema.get(tableKey('part'))).toBeNull();
-        expect(schema.has(tableKey('gone'))).toBe(false);
-    });
-    it('loads every folder named, in file-name order across them, skipping one that does not exist', () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-'));
-        try {
-            fs.mkdirSync(path.join(root, 'a'));
-            fs.mkdirSync(path.join(root, 'b'));
-            fs.writeFileSync(path.join(root, 'b', '20240101_create.sql'), 'create table t (id int, note text);');
-            fs.writeFileSync(path.join(root, 'a', '20240202_tighten.sql'), 'alter table t alter column note set not null;');
-            fs.writeFileSync(path.join(root, 'a', 'README.md'), 'not sql');
-            const schema = loadSchemaNullability(root, ['a', path.join(root, 'b'), 'missing']);
-            expect(columns(schema, 't')).toEqual({ id: false, note: true });
-        }
-        finally {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    });
-});

package/dist/review-learning/human-edits.test.d.ts

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

package/dist/review-learning/human-edits.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 } from 'vitest';
-import { captureHumanEdits, recordAgentWrites } from './human-edits.js';
-import { readLessons } from './lessons.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const write = (body) => fs.writeFileSync(path.join(repo, 'src/job.ts'), body);
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'human-edits-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.mkdirSync(path.join(repo, 'src'));
-    write('export function job(rows) {\n  return rows.map(r => r.id);\n}\n');
-    git('add', '-A');
-    git('commit', '-qm', 'base');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('a person editing what the agent wrote', () => {
-    it('becomes a lesson with correction evidence, taken once', () => {
-        write('export function job(rows) {\n  return rows.slice(0, 10000).map(r => r.id);\n}\n'); // the agent's write
-        recordAgentWrites(repo, ['src/job.ts']);
-        write('export function job(rows, after) {\n  return rows.filter(r => r.id > after).slice(0, 500).map(r => r.id);\n}\n'); // the person's fix
-        expect(captureHumanEdits(repo, 'lead@acme')).toBe(1);
-        const [lesson] = readLessons(repo);
-        expect(lesson).toMatchObject({ file: 'src/job.ts', state: 'verified', promotedBy: 'correction' });
-        expect(lesson.text).toContain('a person changed what the agent wrote');
-        expect(lesson.text).toContain('+  return rows.filter(r => r.id > after).slice(0, 500).map(r => r.id);');
-        expect(lesson.evidence[0]).toMatchObject({ kind: 'correction', author: 'lead@acme' });
-        expect(captureHumanEdits(repo, 'lead@acme')).toBe(0); // taken once
-    });
-    it('is not a correction when only whitespace moved, or the change came from git', () => {
-        recordAgentWrites(repo, ['src/job.ts']);
-        write('export function job(rows) {\n    return rows.map(r => r.id);\n}\n'); // a formatter
-        expect(captureHumanEdits(repo)).toBe(0);
-        recordAgentWrites(repo, ['src/job.ts']);
-        git('checkout', '-q', '-b', 'other');
-        write('export const job = (rows) => rows.map(r => r.id);\n');
-        git('commit', '-qam', 'someone else\'s branch');
-        expect(captureHumanEdits(repo)).toBe(0); // a checkout brought it, not a person correcting the agent
-        expect(readLessons(repo)).toEqual([]);
-    });
-});

package/dist/review-learning/repo-rules.test.d.ts

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