@rigour-labs/core 6.7.1 → 6.7.4

package/dist/review-learning/rules-from-reviews.js

@@ -0,0 +1,86 @@
+/**
+ * Turning reviews into rules: a frontier model rewrites each point a person made, which the pull
+ * request then acted on, as the plain-language rule behind it, or says it is not a rule (a test
+ * report, a status note, a one-off fix). Memory, never training: the rule is text the next judge and
+ * agent read, it keeps the person's own words as evidence, and it stays a candidate until the same
+ * rule recurs in two or more pull requests or a person promotes it.
+ */
+import crypto from 'crypto';
+/** Points per call: enough to share the context, few enough that every one gets an answer. */
+const BATCH = 20;
+const MAX_RULE = 200;
+function rulesPrompt(lessons) {
+    const points = lessons.map(l => ({ id: l.id, pr: l.evidence[0]?.pr, file: l.file || null, said: l.text }));
+    return `A team's senior reviewers teach through code review. Below are points people made in reviews of
+this repository, each of which the pull request then acted on. For each point, decide whether it
+teaches a rule the team would want applied to future changes, beyond this one pull request.
+
+- If it does, write that rule as one plain imperative sentence of at most ${MAX_RULE} characters
+  ("Apply every filter known before a read in the query itself."). Keep a name only when the rule is
+  about that code. Give "file" when the rule is about one file, else null.
+- If it is a test or check report, a status note, praise, a question, or a fix of one specific bug that
+  teaches nothing general, give "rule": null.
+
+Do not read or change any file; answer from the points alone. Your final message must be ONLY this
+JSON: {"rules":[{"id":"<the point's id>","rule":"..." | null,"file":"<path>" | null}]}
+
+Points:
+${JSON.stringify(points, null, 1)}`;
+}
+/**
+ * The points as the rules the model wrote: a point it called no rule is kept and marked so (never
+ * promoted again), a point it did not answer is kept as it was (a failed call never loses evidence), and
+ * the person's words stay in the evidence. A rule about a file keeps that file only when the point was already about it.
+ */
+export async function rulesFromReviews(lessons, write) {
+    const out = [];
+    let rules = 0, dropped = 0, unanswered = 0;
+    for (let i = 0; i < lessons.length; i += BATCH) {
+        const batch = lessons.slice(i, i + BATCH);
+        const answers = parseRules(await write(rulesPrompt(batch)));
+        for (const lesson of batch) {
+            const answer = answers.get(lesson.id);
+            if (!answer) {
+                unanswered++;
+                out.push(lesson);
+            }
+            else if (!answer.rule) {
+                // Kept, marked: a point the writer found no rule in is never promoted, or paid for, again.
+                dropped++;
+                out.push({ ...lesson, evidence: [...lesson.evidence, { kind: 'norule', pr: lesson.evidence[0]?.pr ?? 0, comment: `norule-${lesson.id}`, author: '', detail: 'the rule writer found no rule in it' }] });
+            }
+            else {
+                rules++;
+                const file = answer.file && answer.file === lesson.file ? lesson.file : '';
+                out.push({
+                    ...lesson, text: answer.rule, file,
+                    id: crypto.createHash('sha256').update(`${file}\u0000${answer.rule.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim()}`).digest('hex').slice(0, 12),
+                    evidence: lesson.evidence.map(e => ({ ...e, said: e.said ?? lesson.text })),
+                });
+            }
+        }
+    }
+    return { lessons: out, rules, dropped, unanswered };
+}
+function parseRules(text) {
+    const found = new Map();
+    if (!text)
+        return found;
+    const start = text.indexOf('{"rules"') >= 0 ? text.indexOf('{"rules"') : text.indexOf('{');
+    for (let end = text.lastIndexOf('}'); start >= 0 && end > start; end = text.lastIndexOf('}', end - 1)) {
+        try {
+            const parsed = JSON.parse(text.slice(start, end + 1));
+            for (const r of Array.isArray(parsed?.rules) ? parsed.rules : []) {
+                if (typeof r?.id !== 'string')
+                    continue;
+                const rule = typeof r.rule === 'string' && r.rule.trim().length >= 12 ? r.rule.trim().slice(0, MAX_RULE) : null;
+                found.set(r.id, { rule, file: typeof r.file === 'string' ? r.file : null });
+            }
+            return found;
+        }
+        catch {
+            // not a whole object yet: try a shorter one
+        }
+    }
+    return found;
+}

package/dist/review-learning/team-lessons.d.ts

@@ -4,5 +4,21 @@ export type LessonMode = 'verified' | 'all' | 'off';
 export declare const DEFAULT_LESSON_MODE: LessonMode;
 /** The team's review lessons in play for this mode: none when off, verified ones by default. */
 export declare function activeLessons(cwd: string, mode?: LessonMode): ReviewLesson[];
-export declare function lessonsForDiff(cwd: string, diff: string, mode?: LessonMode): ReviewLesson[];
+/** `standards`: how many team standards may come with the file lessons (a judge reading a whole pull request takes more than an agent's one question). */
+export declare function lessonsForDiff(cwd: string, diff: string, mode?: LessonMode, standards?: number): ReviewLesson[];
+/** The points this team rejected that a change touches: what the judges are told is settled. */
+export declare function rejectedForDiff(cwd: string, diff: string): ReviewLesson[];
+/** A lesson as a judge or agent sees it, in one place. */
+export interface LessonView {
+    file: string;
+    text: string;
+    prs: number[];
+    said?: string;
+}
+export declare function lessonView(l: ReviewLesson): LessonView;
+/**
+ * One line per lesson: where it applies, the rule, and, when a model wrote the rule from a person's
+ * point, their own words, so anyone can see when the rule went beyond what was said.
+ */
+export declare function describeLesson(l: LessonView): string;
 export declare function lessonsSection(lessons: ReviewLesson[]): string;

package/dist/review-learning/team-lessons.js

@@ -13,20 +13,44 @@ export function activeLessons(cwd, mode = DEFAULT_LESSON_MODE) {
         return [];
     return readLessons(cwd).filter(l => mode === 'all' || l.state === 'verified');
 }
-export function lessonsForDiff(cwd, diff, mode = DEFAULT_LESSON_MODE) {
+/** `standards`: how many team standards may come with the file lessons (a judge reading a whole pull request takes more than an agent's one question). */
+export function lessonsForDiff(cwd, diff, mode = DEFAULT_LESSON_MODE, standards) {
     if (mode === 'off')
         return [];
     const lessons = readLessons(cwd);
     if (lessons.length === 0)
         return [];
-    const files = Object.keys(parseDiff(diff));
+    return matchLessons(lessons, changeShape(diff), { includeCandidates: mode === 'all', ...(standards !== undefined ? { standards } : {}) });
+}
+/** The points this team rejected that a change touches: what the judges are told is settled. */
+export function rejectedForDiff(cwd, diff) {
+    const rejected = readLessons(cwd).filter(l => l.state === 'rejected');
+    if (rejected.length === 0)
+        return [];
+    const matched = new Set(matchLessons(rejected.map(l => ({ ...l, state: 'verified' })), changeShape(diff), { standards: 5 }).map(l => l.id));
+    return rejected.filter(l => matched.has(l.id));
+}
+function changeShape(diff) {
     const added = diff.split('\n').filter(line => line.startsWith('+') && !line.startsWith('+++')).join('\n');
-    const symbols = new Set(added.match(/[A-Za-z_$][\w$]{3,}/g) ?? []);
-    return matchLessons(lessons, { files, symbols }, { includeCandidates: mode === 'all' });
+    return { files: Object.keys(parseDiff(diff)), symbols: new Set(added.match(/[A-Za-z_$][\w$]{3,}/g) ?? []) };
+}
+export function lessonView(l) {
+    const said = l.evidence.find(e => e.said && e.said !== l.text)?.said;
+    return { file: l.file, text: l.text, prs: [...new Set(l.evidence.map(e => e.pr))], ...(said ? { said } : {}) };
+}
+/**
+ * One line per lesson: where it applies, the rule, and, when a model wrote the rule from a person's
+ * point, their own words, so anyone can see when the rule went beyond what was said.
+ */
+export function describeLesson(l) {
+    const where = l.file ? `${l.file}: ` : 'team standard: ';
+    const said = l.said ? ` (in their words: "${l.said}")` : '';
+    const prs = l.prs.length ? ` (acted on in PR ${l.prs.map(p => `#${p}`).join(', ')})` : '';
+    return `${where}${l.text}${said}${prs}`;
 }
 export function lessonsSection(lessons) {
     if (lessons.length === 0)
         return '';
-    const lines = lessons.map(l => `- ${l.file}: ${l.text} (acted on in PR ${[...new Set(l.evidence.map(e => `#${e.pr}`))].join(', ')})`);
+    const lines = lessons.map(l => `- ${describeLesson(lessonView(l))}`);
     return `TEAM LESSONS (this team asked for these in past reviews; check whether the change repeats any):\n${lines.join('\n')}`;
 }

package/dist/services/temporal-drift.js

@@ -94,7 +94,7 @@ export async function generateTemporalDriftReport(cwd, maxScans = 200) {
     if (!db) {
         if (!_sqliteWarningShown) {
             _sqliteWarningShown = true;
-            Logger.warn('Temporal drift: SQLite not available — install sqlite3 to enable scan history');
+            Logger.warn('Temporal drift: SQLite not available (it is built into Node 22.13 and later), so there is no scan history');
         }
         return null;
     }

package/dist/storage/db.d.ts

@@ -1,8 +1,8 @@
 declare const RIGOUR_DIR: string;
 declare const DB_PATH: string;
 /**
- * Promisified wrapper around a node-sqlite3 Database instance.
- * Provides run/get/all/exec methods that return Promises.
+ * The database behind a promise API: run/get/all/exec return Promises, so callers do not change
+ * with the driver, and a later move to a worker or an async driver stays inside this file.
  */
 export interface RigourDB {
     /** Execute a write statement (INSERT/UPDATE/DELETE). Returns { changes }. */
@@ -23,7 +23,7 @@ export interface RigourDB {
 }
 /**
  * Open (or create) the Rigour SQLite database.
- * Returns null if sqlite3 is not available.
+ * Returns null where this Node has no node:sqlite.
  */
 export declare function openDatabase(dbPath?: string): Promise<RigourDB | null>;
 /**
@@ -44,8 +44,6 @@ export declare function getDatabaseSize(): number;
  * Reset the database — delete and recreate from scratch.
  */
 export declare function resetDatabase(): void;
-/**
- * Check if SQLite is available (sqlite3 installed)
- */
+/** Whether this Node has SQLite (node:sqlite, Node 22.13 or later). */
 export declare function isSQLiteAvailable(): boolean;
 export { RIGOUR_DIR, DB_PATH };

package/dist/storage/db.js

@@ -3,44 +3,38 @@
  * Single file at ~/.rigour/rigour.db stores all scan history, findings,
  * learned patterns, and feedback. ACID-safe, portable, queryable.
  *
- * Uses node-sqlite3 (async, widely supported, no native build issues).
- * All public APIs are async. Graceful degradation if sqlite3 not installed.
+ * Uses Node's built-in SQLite (node:sqlite): nothing to install or compile, and no native addon to
+ * crash a worker thread. All public APIs are async. Where node:sqlite is missing (Node before
+ * 22.13), storage is off and every caller degrades as before.
  */
 import path from 'path';
 import fs from 'fs-extra';
 import { createRequire } from 'module';
 import { rigourUserDir } from '../utils/user-state.js';
-// ---------------------------------------------------------------------------
-// Optional dynamic import of sqlite3
-// ---------------------------------------------------------------------------
-let sqlite3Module = null;
-let _resolved = false;
-function loadSqlite3() {
-    if (_resolved)
-        return sqlite3Module;
-    _resolved = true;
-    // Try multiple resolution paths:
-    // 1. Relative to this package (works when sqlite3 is installed in monorepo)
-    // 2. Relative to cwd (works when user installs sqlite3 in their project)
-    // 3. Relative to global node_modules (works for global installs)
-    const searchPaths = [
-        import.meta.url,
-        `file://${process.cwd()}/package.json`,
-        `file://${path.join(rigourUserDir(), 'package.json')}`,
-    ];
-    for (const base of searchPaths) {
-        try {
-            const req = createRequire(base);
-            sqlite3Module = req('sqlite3');
-            if (sqlite3Module)
-                return sqlite3Module;
-        }
-        catch {
-            // Try next path
-        }
+let sqliteModule;
+/**
+ * node:sqlite, or null where this Node has none. Node 22 prints an "experimental feature" warning on
+ * the first load; it says nothing a Rigour user can act on, so that one warning is not shown.
+ */
+function loadSqlite() {
+    if (sqliteModule !== undefined)
+        return sqliteModule;
+    const emitWarning = process.emitWarning;
+    process.emitWarning = ((warning, ...rest) => {
+        if (String(warning?.message ?? warning).startsWith('SQLite is an experimental feature'))
+            return;
+        return emitWarning.call(process, warning, ...rest);
+    });
+    try {
+        sqliteModule = createRequire(import.meta.url)('node:sqlite');
+    }
+    catch {
+        sqliteModule = null;
+    }
+    finally {
+        process.emitWarning = emitWarning;
     }
-    sqlite3Module = null;
-    return sqlite3Module;
+    return sqliteModule;
 }
 // RIGOUR_HOME when set (tests, sandboxes) so nothing but a real run touches ~/.rigour.
 const RIGOUR_DIR = rigourUserDir();
@@ -254,52 +248,41 @@ CREATE INDEX IF NOT EXISTS idx_repositories_last_seen ON repositories(last_seen)
 CREATE INDEX IF NOT EXISTS idx_interaction_events_repo_created ON interaction_events(repository_id, created_at);
 CREATE INDEX IF NOT EXISTS idx_interaction_events_request ON interaction_events(request_id);
 `;
+/**
+ * A value as SQLite stores it. node:sqlite refuses what sqlite3 converted silently, so the same
+ * conversions happen here: undefined is NULL, a boolean is 1 or 0, a Date is its epoch milliseconds.
+ */
+function bindable(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (value instanceof Date)
+        return value.getTime();
+    return value;
+}
+/** Rows as plain objects (node:sqlite returns them without a prototype). */
+function plain(row) {
+    return row && typeof row === 'object' ? { ...row } : row;
+}
 function wrapDatabase(raw) {
+    const prepare = (sql) => raw.prepare(sql);
     const db = {
-        run(sql, ...params) {
-            return new Promise((resolve, reject) => {
-                raw.run(sql, ...params, function (err) {
-                    if (err)
-                        return reject(err);
-                    resolve({ changes: this.changes, lastID: this.lastID });
-                });
-            });
+        async run(sql, ...params) {
+            const result = prepare(sql).run(...params.map(bindable));
+            return { changes: Number(result.changes), lastID: Number(result.lastInsertRowid) };
         },
-        get(sql, ...params) {
-            return new Promise((resolve, reject) => {
-                raw.get(sql, ...params, (err, row) => {
-                    if (err)
-                        return reject(err);
-                    resolve(row);
-                });
-            });
+        async get(sql, ...params) {
+            return plain(prepare(sql).get(...params.map(bindable)));
         },
-        all(sql, ...params) {
-            return new Promise((resolve, reject) => {
-                raw.all(sql, ...params, (err, rows) => {
-                    if (err)
-                        return reject(err);
-                    resolve(rows || []);
-                });
-            });
+        async all(sql, ...params) {
+            return prepare(sql).all(...params.map(bindable)).map(plain);
         },
-        exec(sql) {
-            return new Promise((resolve, reject) => {
-                raw.exec(sql, (err) => {
-                    if (err)
-                        return reject(err);
-                    resolve();
-                });
-            });
+        async exec(sql) {
+            raw.exec(sql);
         },
-        close() {
-            return new Promise((resolve, reject) => {
-                raw.close((err) => {
-                    if (err)
-                        return reject(err);
-                    resolve();
-                });
-            });
+        async close() {
+            raw.close();
         },
         async transaction(fn) {
             await db.exec('BEGIN TRANSACTION');
@@ -318,22 +301,15 @@ function wrapDatabase(raw) {
 }
 /**
  * Open (or create) the Rigour SQLite database.
- * Returns null if sqlite3 is not available.
+ * Returns null where this Node has no node:sqlite.
  */
 export async function openDatabase(dbPath) {
-    const sqlite3 = loadSqlite3();
-    if (!sqlite3)
+    const sqlite = loadSqlite();
+    if (!sqlite)
         return null;
     const resolvedPath = dbPath || DB_PATH;
     fs.ensureDirSync(path.dirname(resolvedPath));
-    const raw = await new Promise((resolve, reject) => {
-        const instance = new sqlite3.Database(resolvedPath, (err) => {
-            if (err)
-                return reject(err);
-            resolve(instance);
-        });
-    });
-    const db = wrapDatabase(raw);
+    const db = wrapDatabase(new sqlite.DatabaseSync(resolvedPath));
     // Wait for a lock instead of failing at once: a hook and an MCP server often open the database
     // at the same moment, and without this the second open fails with SQLITE_BUSY.
     await db.exec('PRAGMA busy_timeout = 5000');
@@ -528,7 +504,7 @@ async function enableWal(db, attempts = 10) {
             return;
         }
         catch (error) {
-            if (!/SQLITE_BUSY/.test(String(error)) || attempt >= attempts)
+            if (!/SQLITE_BUSY|database is locked/i.test(String(error)) || attempt >= attempts)
                 throw error;
             await new Promise(resolve => setTimeout(resolve, 25 * attempt));
         }
@@ -555,8 +531,7 @@ async function addColumnIfMissing(db, table, column, alterSql) {
  * Compact the database — prune old data, reclaim disk space.
  */
 export async function compactDatabase(retainDays = 90) {
-    const sqlite3 = loadSqlite3();
-    if (!sqlite3)
+    if (!loadSqlite())
         return { pruned: 0, patternsDecayed: 0, sizeBefore: 0, sizeAfter: 0 };
     const resolvedPath = DB_PATH;
     const sizeBefore = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath).size : 0;
@@ -604,10 +579,8 @@ export function resetDatabase() {
     if (fs.existsSync(DB_PATH + '-shm'))
         fs.removeSync(DB_PATH + '-shm');
 }
-/**
- * Check if SQLite is available (sqlite3 installed)
- */
+/** Whether this Node has SQLite (node:sqlite, Node 22.13 or later). */
 export function isSQLiteAvailable() {
-    return loadSqlite3() !== null;
+    return loadSqlite() !== null;
 }
 export { RIGOUR_DIR, DB_PATH };

package/dist/storage/db.test.d.ts

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

package/dist/storage/db.test.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { isSQLiteAvailable, openDatabase } from './db.js';
+let dir;
+let db;
+beforeEach(async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-db-'));
+    db = (await openDatabase(path.join(dir, 'rigour.db')));
+});
+afterEach(async () => {
+    await db?.close();
+    fs.rmSync(dir, { recursive: true, force: true });
+});
+describe('the database (node:sqlite)', () => {
+    it('is built in: no package to install', () => {
+        expect(isSQLiteAvailable()).toBe(true);
+        expect(db).not.toBeNull();
+    });
+    it('stores what callers pass the way sqlite3 did: undefined as NULL, booleans as 1 or 0, a Date as epoch ms', async () => {
+        await db.exec('CREATE TABLE t (a, b, c, d)');
+        const when = new Date('2026-01-02T03:04:05Z');
+        const written = await db.run('INSERT INTO t VALUES (?, ?, ?, ?)', undefined, true, false, when);
+        expect(written).toEqual({ changes: 1, lastID: 1 });
+        const row = await db.get('SELECT * FROM t');
+        expect(row).toEqual({ a: null, b: 1, c: 0, d: when.getTime() });
+        expect(Object.getPrototypeOf(row)).toBe(Object.prototype); // a plain object, as callers spread and compare
+        expect(await db.get('SELECT * FROM t WHERE a = 1')).toBeUndefined();
+    });
+    it('rolls a failed transaction back whole', async () => {
+        await db.exec('CREATE TABLE t (a UNIQUE)');
+        await expect(db.transaction(async (tx) => {
+            await tx.run('INSERT INTO t VALUES (?)', 1);
+            await tx.run('INSERT INTO t VALUES (?)', 1); // violates UNIQUE
+        })).rejects.toThrow(/UNIQUE/);
+        expect(await db.all('SELECT * FROM t')).toEqual([]);
+    });
+    it('opens an existing database again with its schema and data, in WAL mode', async () => {
+        await db.run("INSERT INTO meta (key, value) VALUES ('probe', 'kept')");
+        await db.close();
+        db = (await openDatabase(path.join(dir, 'rigour.db')));
+        expect(await db.get("SELECT value FROM meta WHERE key = 'probe'")).toEqual({ value: 'kept' });
+        expect(await db.get('PRAGMA journal_mode')).toEqual({ journal_mode: 'wal' });
+    });
+});

package/dist/templates/universal-config.js

@@ -211,10 +211,12 @@ export const UNIVERSAL_CONFIG = {
         unused_exports: {
             enabled: true,
             allow: [],
+            block: false,
         },
         orphan_files: {
             enabled: true,
             allow: [],
+            block: false,
         },
         query_patterns: {
             enabled: true,
@@ -290,6 +292,7 @@ export const UNIVERSAL_CONFIG = {
             judges: 2,
             escalate: 'always',
             cross_models: {},
+            judge_env: {},
         },
     },
     ignore: [],