@rigour-labs/core 6.6.6 → 6.7.1

package/dist/review/toolchain.test.js

@@ -73,12 +73,15 @@ describe('runToolchain', () => {
         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 leaves a tool set under commands: to that command', async () => {
+    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); }");
-        const results = await runToolchain(dir, ['src/a.ts'], config({ format: 'npm run fmt' }));
+        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: 'skipped', command: 'commands.format runs it' });
+        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)"' } }));

package/dist/review/typed/program.d.ts

@@ -16,7 +16,6 @@ export interface TypedProgram {
     textFiles: TextFile[];
     inProgram: Set<string>;
 }
-export declare const TEST_FILE: RegExp;
 /** The program, `skip` when this is not a TypeScript project, or `error` when it is one that cannot be loaded. */
 export declare function loadProgram(root: string): {
     program: TypedProgram;

package/dist/review/typed/program.js

@@ -12,7 +12,7 @@ import { createRequire } from 'module';
 import path from 'path';
 import ownTs from 'typescript';
 import { installedBin } from '../../utils/installed-bin.js';
-export const TEST_FILE = /\.(test|spec|e2e)\.[cm]?[jt]sx?$|(^|\/)(tests?|e2e|__tests__|__mocks__)\//;
+import { isTestFile } from '../test-files.js';
 const GIT_TIMEOUT_MS = 10_000;
 /** The program, `skip` when this is not a TypeScript project, or `error` when it is one that cannot be loaded. */
 export function loadProgram(root) {
@@ -32,7 +32,7 @@ export function loadProgram(root) {
     return {
         program: {
             ts, program, checker: program.getTypeChecker(), root, rel,
-            appSources: sources.filter(sf => !TEST_FILE.test(rel(sf))),
+            appSources: sources.filter(sf => !isTestFile(rel(sf))),
             textFiles: textFiles(root, inProgram),
             inProgram,
         },
@@ -77,7 +77,7 @@ function textFiles(root, inProgram) {
         return [];
     const files = [];
     for (const file of listed.stdout.split('\n')) {
-        if (!file || inProgram.has(file) || file.endsWith('.d.ts') || TEST_FILE.test(file))
+        if (!file || inProgram.has(file) || file.endsWith('.d.ts') || isTestFile(file))
             continue;
         try {
             files.push({ file, text: fs.readFileSync(path.join(root, file), 'utf8') });

package/dist/review/typed/redundancy.js

@@ -9,17 +9,22 @@
  *   write-only-property       a property the hosts set and nothing reads. When the value only
  *                             leaves through serialisation to a callee the program does not declare
  *                             (a wire payload), that is a hint for the reviewer, not a block.
+ * Plus a note, not yet proven on merged pull requests so it never blocks:
+ *   nullable-not-null-column  the row type of `.from('t')` says `| null` for a column the
+ *                             migrations make NOT NULL (`schema_migrations`, schema-nullability.ts).
  * Plus a hint: a function that scans a collection, called once per item of another (nested-scan).
  * Scoped to lines the change touched and members it declared, or whose every host it wrote; a
  * pre-existing member with one touched writer is the team's backlog, not this change's.
  */
 import micromatch from 'micromatch';
 import { emitsDeclarations } from '../package-layout.js';
-import { loadProgram, TEST_FILE } from './program.js';
+import { isTestFile } from '../test-files.js';
+import { loadProgram } from './program.js';
+import { loadSchemaNullability, tableKey } from './schema-nullability.js';
 export const TYPED_CHECKS = 'typed-checks-unavailable';
 /** The typed checks on a change: nothing when it touches no TypeScript or the project has no tsconfig. */
 export function typedChecks(cwd, changedLines, config) {
-    if (!config.gates.redundancy?.enabled || !Object.keys(changedLines).some(file => /\.[cm]?ts$/.test(file) && !TEST_FILE.test(file)))
+    if (!config.gates.redundancy?.enabled || !Object.keys(changedLines).some(file => /\.[cm]?ts$/.test(file) && !isTestFile(file)))
         return { failures: [], hints: [] };
     const loaded = loadProgram(cwd);
     if ('skip' in loaded)
@@ -35,7 +40,7 @@ function redundancyFailures(typed, changedLines, config) {
     if (!settings?.enabled)
         return { failures: [], hints: [] };
     const { ts, checker, rel } = typed;
-    const changed = Object.keys(changedLines).filter(file => /\.[cm]?ts$/.test(file) && !file.endsWith('.d.ts') && !TEST_FILE.test(file));
+    const changed = Object.keys(changedLines).filter(file => /\.[cm]?ts$/.test(file) && !file.endsWith('.d.ts') && !isTestFile(file));
     const failures = [];
     const hints = [];
     const line = (node) => node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1;
@@ -83,13 +88,47 @@ function redundancyFailures(typed, changedLines, config) {
         return undefined;
     };
     const isNullable = (t) => t.isUnion() && t.types.some(m => !!(m.flags & ts.TypeFlags.Null));
-    // duplicate-null-filter and nullable-filtered-column
+    // nullable-not-null-column: read once, and only when a changed file queries a table.
+    let schema;
+    const reportedDecls = new Set();
+    const notNullColumns = (chain, outer, filtered) => {
+        const from = chain.find(c => c.name === 'from' && strArg(c.call, 0));
+        if (!from)
+            return;
+        const schemaCall = chain.find(c => c.name === 'schema' && strArg(c.call, 0));
+        const table = `${schemaCall ? `${strArg(schemaCall.call, 0)}.` : ''}${strArg(from.call, 0)}`;
+        schema ??= loadSchemaNullability(typed.root, settings.schema_migrations);
+        const columns = schema.get(tableKey(table));
+        const row = columns && rowTypeOf(chain, outer);
+        if (!columns || !row)
+            return;
+        const select = chain.find(c => c.name === 'select');
+        const selected = select ? strArg(select.call, 0) ?? '' : '';
+        // The query's own line the change touched: a call's start is the start of the whole chain, so its method name.
+        const queryLine = chain.map(c => c.call.expression.name).find(touched);
+        for (const prop of checker.getPropertiesOfType(row)) {
+            const decl = prop.declarations?.[0];
+            const name = prop.name;
+            if (!decl || !ts.isPropertySignature(decl) || !decl.type || reportedDecls.has(decl) || filtered.has(name))
+                continue;
+            // An alias (`name:other_column`) maps another column onto this property.
+            if (columns.get(name) !== true || new RegExp(`(^|[\\s,(])${name.replace(/[$]/g, '\\$')}\\s*:`).test(selected) || !isNullable(checker.getTypeFromTypeNode(decl.type)))
+                continue;
+            const anchor = touched(decl) ? decl : queryLine;
+            if (!anchor)
+                continue;
+            reportedDecls.add(decl);
+            report('nullable-not-null-column', 'Nullable type for a NOT NULL column', anchor, `\`${name}\` is declared nullable at ${at(decl)} but \`${table}.${name}\` is NOT NULL in the migrations, so every guard on it is dead.`, 'Narrow the row type and delete the guards on it. If the migrations Rigour read are not the ones this code runs against, point gates.redundancy.schema_migrations at them.');
+        }
+    };
+    // duplicate-null-filter, nullable-filtered-column and nullable-not-null-column
     for (const sf of changedSources) {
         walk(sf, node => {
             if (!ts.isCallExpression(node) || !outermost(node))
                 return;
             const chain = chainOf(node);
             const nots = chain.filter(c => c.name === 'not' && strArg(c.call, 1) === 'is' && isNullLiteral(c.call.arguments[2]) && strArg(c.call, 0));
+            notNullColumns(chain, node, new Set(nots.map(n => strArg(n.call, 0))));
             if (nots.length === 0 || !spanTouched(node))
                 return;
             for (const n of nots) {

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

@@ -119,3 +119,61 @@ export async function scan(since: string): Promise<Row[]> {
         expect(broken.typedError).toMatch(/\.generated\/tsconfig\.json.*install the dependencies/s);
     }, 60_000);
 });
+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.d.ts

@@ -0,0 +1,6 @@
+/** `schema.table` → column → NOT NULL. A table mapped to `null` is one whose columns cannot be known. */
+export type SchemaNullability = Map<string, Map<string, boolean> | null>;
+/** The migrations in `dirs` (relative to the repository, absolute, or `~/`), replayed in file-name order. Missing folders are skipped. */
+export declare function loadSchemaNullability(root: string, dirs: string[]): SchemaNullability;
+/** `schema.table` with Postgres's folding: unquoted names lower-cased, the schema `public` by default. */
+export declare function tableKey(name: string): string;

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

@@ -0,0 +1,218 @@
+/**
+ * Which table columns are NOT NULL, replayed from SQL migrations in file order, so a row type that
+ * says `| null` for one can be called out: every guard on it is dead. The migrations may live in
+ * another repository (`gates.redundancy.schema_migrations`), read only.
+ *
+ * Conservative by construction: a column is NOT NULL only when a statement Rigour understands made
+ * it so (a column definition, a primary key, `SET NOT NULL`). A table created any other way
+ * (`AS SELECT`, `LIKE`, `PARTITION OF`) or altered in a way not followed here is unknown, and an
+ * unknown table or column is never reported.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+const DEFAULT_SCHEMA = 'public';
+/** The migrations in `dirs` (relative to the repository, absolute, or `~/`), replayed in file-name order. Missing folders are skipped. */
+export function loadSchemaNullability(root, dirs) {
+    const files = [];
+    for (const dir of dirs) {
+        const full = dir.startsWith('~/') ? path.join(os.homedir(), dir.slice(2)) : path.resolve(root, dir);
+        let names;
+        try {
+            names = fs.readdirSync(full).filter(name => name.endsWith('.sql'));
+        }
+        catch {
+            continue;
+        }
+        files.push(...names.map(name => path.join(full, name)));
+    }
+    files.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+    const schema = new Map();
+    for (const file of files)
+        applyMigration(schema, fs.readFileSync(file, 'utf8'));
+    return schema;
+}
+/** Applies one migration's statements to the schema in place. */
+function applyMigration(schema, sql) {
+    for (const statement of statements(sql)) {
+        const create = /^create\s+(?:(?:global|local)\s+)?(?:(?:temp|temporary|unlogged)\s+)?table\s+(?:if\s+not\s+exists\s+)?([\w."]+)\s*([\s\S]*)$/i.exec(statement);
+        if (create) {
+            createTable(schema, tableKey(create[1]), create[2]);
+            continue;
+        }
+        const alter = /^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?([\w."]+)\s+([\s\S]*)$/i.exec(statement);
+        if (alter) {
+            alterTable(schema, tableKey(alter[1]), alter[2]);
+            continue;
+        }
+        const drop = /^drop\s+table\s+(?:if\s+exists\s+)?([\w.",\s]+?)(?:\s+(?:cascade|restrict))?$/i.exec(statement);
+        if (drop)
+            for (const name of splitTopLevel(drop[1]))
+                schema.delete(tableKey(name));
+    }
+}
+function createTable(schema, key, rest) {
+    const body = /^\(([\s\S]*)\)/.exec(rest.trim());
+    if (!body || /^\(\s*like\s/i.test(rest.trim()) || /partition\s+of/i.test(rest)) {
+        schema.set(key, null);
+        return;
+    }
+    const columns = new Map();
+    for (const part of splitTopLevel(matchingParen(rest.trim()))) {
+        const primary = /^(?:constraint\s+[\w"]+\s+)?primary\s+key\s*\(([^)]*)\)/i.exec(part);
+        if (primary) {
+            for (const col of primary[1].split(','))
+                columns.set(ident(col), true);
+            continue;
+        }
+        if (/^(?:constraint|unique|check|foreign\s+key|exclude|like)\b/i.test(part))
+            continue;
+        const column = columnDefinition(part);
+        if (column)
+            columns.set(column.name, column.notNull);
+    }
+    schema.set(key, columns);
+}
+function alterTable(schema, key, actions) {
+    const rename = /^rename\s+to\s+([\w."]+)$/i.exec(actions.trim());
+    if (rename) {
+        const table = schema.get(key);
+        schema.delete(key);
+        schema.set(`${key.split('.')[0]}.${ident(rename[1].split('.').pop())}`, table ?? null);
+        return;
+    }
+    const columns = schema.get(key);
+    if (!columns)
+        return; // unknown table: stays unknown
+    for (const action of splitTopLevel(actions)) {
+        const add = /^add\s+(?:column\s+)?(?:if\s+not\s+exists\s+)?([\s\S]+)$/i.exec(action);
+        if (add && !/^(?:constraint|primary|unique|check|foreign)\b/i.test(add[1])) {
+            const column = columnDefinition(add[1]);
+            if (column)
+                columns.set(column.name, column.notNull);
+            continue;
+        }
+        const primary = /^add\s+(?:constraint\s+[\w"]+\s+)?primary\s+key\s*\(([^)]*)\)/i.exec(action);
+        if (primary) {
+            for (const col of primary[1].split(','))
+                columns.set(ident(col), true);
+            continue;
+        }
+        const nullability = /^alter\s+(?:column\s+)?([\w"]+)\s+(set|drop)\s+not\s+null$/i.exec(action);
+        if (nullability) {
+            columns.set(ident(nullability[1]), nullability[2].toLowerCase() === 'set');
+            continue;
+        }
+        const dropColumn = /^drop\s+(?:column\s+)?(?:if\s+exists\s+)?([\w"]+)/i.exec(action);
+        if (dropColumn && !/^drop\s+constraint\b/i.test(action)) {
+            columns.delete(ident(dropColumn[1]));
+            continue;
+        }
+        const renameColumn = /^rename\s+(?:column\s+)?([\w"]+)\s+to\s+([\w"]+)$/i.exec(action);
+        if (renameColumn && columns.has(ident(renameColumn[1]))) {
+            columns.set(ident(renameColumn[2]), columns.get(ident(renameColumn[1])));
+            columns.delete(ident(renameColumn[1]));
+        }
+    }
+}
+function columnDefinition(text) {
+    const match = /^("(?:[^"]|"")+"|[a-z_][\w$]*)\s+([\s\S]+)$/i.exec(text.trim());
+    if (!match)
+        return undefined;
+    // Strings and parenthesised expressions (a CHECK, a default, a generated column) say nothing about this column's own constraint.
+    let rest = match[2].replace(/'(?:[^']|'')*'/g, "''");
+    while (/\([^()]*\)/.test(rest))
+        rest = rest.replace(/\([^()]*\)/g, '');
+    return { name: ident(match[1]), notNull: /\bnot\s+null\b|\bprimary\s+key\b/i.test(rest) };
+}
+/** `schema.table` with Postgres's folding: unquoted names lower-cased, the schema `public` by default. */
+export function tableKey(name) {
+    const parts = name.trim().match(/"(?:[^"]|"")+"|[^.]+/g) ?? [];
+    const table = parts.at(-1) ?? '';
+    const schema = (parts.length > 1 && parts[0]) || DEFAULT_SCHEMA;
+    return `${ident(schema)}.${ident(table)}`;
+}
+function ident(name) {
+    const trimmed = name.trim();
+    return trimmed.startsWith('"') ? trimmed.slice(1, -1).replace(/""/g, '"') : trimmed.toLowerCase();
+}
+/** The text inside the parenthesis that opens `text`. */
+function matchingParen(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '(')
+            depth++;
+        else if (text[i] === ')' && --depth === 0)
+            return text.slice(1, i);
+    }
+    return text.slice(1);
+}
+/** Splits on commas outside parentheses and quotes. */
+function splitTopLevel(text) {
+    const parts = [];
+    let depth = 0;
+    let quote = '';
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === quote)
+                quote = '';
+        }
+        else if (c === "'" || c === '"')
+            quote = c;
+        else if (c === '(')
+            depth++;
+        else if (c === ')')
+            depth--;
+        else if (c === ',' && depth === 0) {
+            parts.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start).trim());
+    return parts.filter(Boolean);
+}
+/** The statements of a migration, comments removed, function bodies and strings kept whole. */
+function statements(sql) {
+    const out = [];
+    let current = '';
+    let i = 0;
+    while (i < sql.length) {
+        const rest = sql.slice(i);
+        const dollar = /^\$[\w]*\$/.exec(rest);
+        if (rest.startsWith('--')) {
+            const end = sql.indexOf('\n', i);
+            i = end === -1 ? sql.length : end;
+        }
+        else if (rest.startsWith('/*')) {
+            const end = sql.indexOf('*/', i + 2);
+            i = end === -1 ? sql.length : end + 2;
+        }
+        else if (dollar) {
+            const end = sql.indexOf(dollar[0], i + dollar[0].length);
+            const stop = end === -1 ? sql.length : end + dollar[0].length;
+            current += sql.slice(i, stop);
+            i = stop;
+        }
+        else if (sql[i] === "'" || sql[i] === '"') {
+            let j = i + 1;
+            while (j < sql.length && !(sql[j] === sql[i] && sql[j + 1] !== sql[i]))
+                j += sql[j] === sql[i] ? 2 : 1;
+            current += sql.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (sql[i] === ';') {
+            out.push(current.trim().replace(/\s+/g, ' '));
+            current = '';
+            i++;
+        }
+        else {
+            current += sql[i];
+            i++;
+        }
+    }
+    if (current.trim())
+        out.push(current.trim().replace(/\s+/g, ' '));
+    return out.filter(Boolean);
+}

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

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

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

@@ -0,0 +1,63 @@
+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/unused-exports.js

@@ -14,11 +14,10 @@ import { spawnSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { emitsDeclarations, isPackageEntry } from './package-layout.js';
+import { isTestFile } from './test-files.js';
 const GIT_TIMEOUT_MS = 10_000;
 const CODE = /\.(ts|tsx|js|jsx|mjs|svelte)$/;
-const SKIPPED = /\.(test|spec)\.|\.d\.ts$|(^|\/)(dist|build|out|coverage|\.next|[\w-]+-dist)\//;
-/** A test is not a consumer: production code must use the export. */
-const TEST = /\.(test|spec|e2e)\.[cm]?[jt]sx?$|(^|\/)(tests?|e2e|__tests__|__mocks__)\//;
+const SKIPPED = /\.d\.ts$|(^|\/)(dist|build|out|coverage|\.next|[\w-]+-dist)\//;
 /** What a route or hook module exports for its framework, not for an importer. */
 const FRAMEWORK_EXPORTS = new Set([
     'load', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'fallback', 'actions',
@@ -63,7 +62,7 @@ function addedExports(diff) {
         if (!file || text.startsWith('-'))
             continue;
         if (text.startsWith('+')) {
-            if (CODE.test(file) && !SKIPPED.test(file))
+            if (CODE.test(file) && !SKIPPED.test(file) && !isTestFile(file))
                 found.push(...exportsOn(text.slice(1), file, line));
             line++;
         }
@@ -113,7 +112,7 @@ export function unusedExportFailures(cwd, diff, config) {
         return []; // git could not answer: say nothing rather than guess
     const points = pointsAtCache(cwd);
     return candidates
-        .filter(exp => ![...(users.get(exp.name) ?? [])].some(user => !isOwnFile(user, exp) && !TEST.test(user) && points(user, exp.file)))
+        .filter(exp => ![...(users.get(exp.name) ?? [])].some(user => !isOwnFile(user, exp) && !isTestFile(user) && points(user, exp.file)))
         .map(unused);
 }
 /**
@@ -182,7 +181,7 @@ function filesNaming(cwd, names, excluded) {
 function unused(exp) {
     return {
         id: 'unused-export',
-        title: 'Unused export',
+        title: `Unused export \`${exp.name}\``,
         details: `\`${exp.name}\` is exported but no other file uses it (a test is not a consumer). An export nothing imports is dead code that readers and agents treat as part of the module's contract.`,
         severity: 'medium',
         provenance: 'traditional',

package/dist/semantic/learn/types.d.ts

@@ -384,7 +384,6 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         maxHits: number;
         repoHits: string[];
     };
-    version: 1;
     id: string;
     severity: "high" | "medium" | "low";
     source: {
@@ -392,6 +391,7 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         file: string;
         commit?: string | undefined;
     };
+    version: 1;
     pattern: {
         template: "require-option";
         callee: {
@@ -427,7 +427,6 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         maxHits: number;
         repoHits: string[];
     };
-    version: 1;
     id: string;
     severity: "high" | "medium" | "low";
     source: {
@@ -435,6 +434,7 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         file: string;
         commit?: string | undefined;
     };
+    version: 1;
     pattern: {
         template: "require-option";
         callee: {

package/dist/services/adaptive-thresholds.d.ts

@@ -1,45 +1,8 @@
 /**
- * Adaptive Thresholds Service (v2)
- *
- * Dynamically adjusts quality gate thresholds based on:
- * - Project maturity (age, commit count, file count)
- * - Historical failure rates with Z-score anomaly detection
- * - Complexity tier (hobby/startup/enterprise)
- * - Per-provenance trend analysis (ai-drift, structural, security separate)
- *
- * v2 upgrades:
- * - Z-score replaces naive delta comparison for trend detection
- * - Per-provenance failure tracking (AI drift vs structural vs security)
- * - Statistical anomaly detection normalizes across project sizes
- *
+ * Quality history: every gate run's failures by provenance, kept in .rigour/adaptive-history.json, and the
+ * trends read from it (Z-score of recent runs against the earlier baseline), overall and per provenance.
  */
-export type ComplexityTier = 'hobby' | 'startup' | 'enterprise';
 export type QualityTrend = 'improving' | 'stable' | 'degrading';
-export interface ProjectMetrics {
-    fileCount: number;
-    commitCount?: number;
-    ageInDays?: number;
-    testCoverage?: number;
-    recentFailureRate?: number;
-}
-export interface AdaptiveConfig {
-    enabled?: boolean;
-    base_coverage_threshold?: number;
-    base_quality_threshold?: number;
-    auto_detect_tier?: boolean;
-    forced_tier?: ComplexityTier;
-}
-export interface ThresholdAdjustments {
-    tier: ComplexityTier;
-    trend: QualityTrend;
-    coverageThreshold: number;
-    qualityThreshold: number;
-    securityBlockLevel: 'critical' | 'high' | 'medium' | 'low';
-    leniencyFactor: number;
-    reasoning: string[];
-    /** Per-provenance trend breakdown (new in v5) */
-    provenanceTrends?: ProvenanceTrends;
-}
 export interface ProvenanceRunData {
     aiDriftFailures: number;
     structuralFailures: number;
@@ -88,20 +51,7 @@ export declare function getQualityTrend(cwd: string): QualityTrend;
  * Falls back gracefully for legacy history data without provenance.
  */
 export declare function getProvenanceTrends(cwd: string): ProvenanceTrends;
-/**
- * Detect project complexity tier based on metrics
- */
-export declare function detectComplexityTier(metrics: ProjectMetrics): ComplexityTier;
-/**
- * Calculate adaptive thresholds based on project state.
- * v5: Uses Z-score trending and per-provenance analysis.
- */
-export declare function calculateAdaptiveThresholds(cwd: string, metrics: ProjectMetrics, config?: AdaptiveConfig): ThresholdAdjustments;
 /**
  * Clear adaptive history (for testing)
  */
 export declare function clearAdaptiveHistory(cwd: string): void;
-/**
- * Get summary of adaptive thresholds for logging
- */
-export declare function getAdaptiveSummary(adjustments: ThresholdAdjustments): string;