@rigour-labs/core 6.5.3 → 6.6.0

package/dist/storage/cache-cleanup.d.ts

@@ -0,0 +1,19 @@
+/** Layers no reader uses (context/cache-engine.ts keeps only semantic and checkpoint). */
+export declare const DEAD_CACHE_TYPES: readonly ["static", "component"];
+export interface CacheCleanupReport {
+    removed: number;
+    kept: number;
+    sizeBefore: number;
+    sizeAfter: number;
+    vacuumed: boolean;
+    /** Why the file was not shrunk, when it was not. */
+    vacuumSkipped?: string;
+}
+/** How many dead rows the database holds, and its size on disk; null when there is no database. */
+export declare function deadCacheRows(dbPath?: string): Promise<{
+    rows: number;
+    bytes: number;
+} | null>;
+export declare function cleanContextCache(dbPath?: string, freeBytes?: typeof freeSpace): Promise<CacheCleanupReport>;
+declare function freeSpace(dir: string): number;
+export {};

package/dist/storage/cache-cleanup.js

@@ -0,0 +1,90 @@
+/**
+ * Removing context-cache rows nothing reads: the static and component layers that index sync wrote
+ * on every edit until it was removed (millions of rows, gigabytes, in real use).
+ *
+ * Built for a database that is large and a disk that is nearly full. Deleting the rows one by one
+ * would copy every changed page into the write-ahead log (as much again on disk); instead the rows
+ * worth keeping are set aside, the table is dropped (its pages are freed, not rewritten) and
+ * recreated. VACUUM, which hands the freed space back to the disk, needs room for a copy of what
+ * remains, so it runs only when that room exists.
+ */
+import fs from 'fs';
+import path from 'path';
+import { DB_PATH, openDatabase } from './db.js';
+/** Layers no reader uses (context/cache-engine.ts keeps only semantic and checkpoint). */
+export const DEAD_CACHE_TYPES = ['static', 'component'];
+const DEAD_LIST = DEAD_CACHE_TYPES.map(t => `'${t}'`).join(', ');
+/** VACUUM writes a copy of the live data; ask for that much free space, with headroom. */
+const VACUUM_HEADROOM = 1.2;
+/** How many dead rows the database holds, and its size on disk; null when there is no database. */
+export async function deadCacheRows(dbPath = DB_PATH) {
+    if (!fs.existsSync(dbPath))
+        return null;
+    const db = await openDatabase(dbPath);
+    if (!db)
+        return null;
+    try {
+        const row = await db.get(`SELECT COUNT(*) AS n FROM context_cache WHERE cache_type IN (${DEAD_LIST})`);
+        return { rows: Number(row?.n ?? 0), bytes: fileBytes(dbPath) };
+    }
+    finally {
+        await db.close();
+    }
+}
+export async function cleanContextCache(dbPath = DB_PATH, freeBytes = freeSpace) {
+    const sizeBefore = fileBytes(dbPath);
+    const db = await openDatabase(dbPath);
+    if (!db)
+        return { removed: 0, kept: 0, sizeBefore, sizeAfter: sizeBefore, vacuumed: false, vacuumSkipped: 'SQLite is not available' };
+    try {
+        const { removed, kept } = await dropDeadRows(db);
+        if (removed === 0)
+            return { removed, kept, sizeBefore, sizeAfter: sizeBefore, vacuumed: false, vacuumSkipped: 'nothing to remove' };
+        const live = await liveBytes(db);
+        const available = freeBytes(path.dirname(dbPath));
+        if (available < live * VACUUM_HEADROOM) {
+            return { removed, kept, sizeBefore, sizeAfter: fileBytes(dbPath), vacuumed: false,
+                vacuumSkipped: `needs about ${mb(live * VACUUM_HEADROOM)} free to shrink the file, ${mb(available)} available; the space is reused by Rigour either way` };
+        }
+        await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        await db.exec('VACUUM');
+        await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        return { removed, kept, sizeBefore, sizeAfter: fileBytes(dbPath), vacuumed: true };
+    }
+    finally {
+        await db.close();
+    }
+}
+/** Set the readable rows aside, drop the table, recreate it with its indexes, put them back. */
+async function dropDeadRows(db) {
+    return db.transaction(async (tx) => {
+        const removed = Number((await tx.get(`SELECT COUNT(*) AS n FROM context_cache WHERE cache_type IN (${DEAD_LIST})`))?.n ?? 0);
+        if (removed === 0)
+            return { removed, kept: 0 };
+        const schema = await tx.all(`SELECT sql FROM sqlite_master WHERE tbl_name = 'context_cache' AND sql IS NOT NULL ORDER BY type DESC`);
+        await tx.exec(`CREATE TEMP TABLE context_cache_keep AS SELECT * FROM context_cache WHERE cache_type NOT IN (${DEAD_LIST})`);
+        await tx.exec('DROP TABLE context_cache');
+        for (const { sql } of schema)
+            await tx.exec(sql); // the table first (type 'table' sorts after 'index' descending), then its indexes
+        await tx.exec('INSERT INTO context_cache SELECT * FROM context_cache_keep');
+        const kept = Number((await tx.get('SELECT COUNT(*) AS n FROM context_cache'))?.n ?? 0);
+        await tx.exec('DROP TABLE context_cache_keep');
+        return { removed, kept };
+    });
+}
+async function liveBytes(db) {
+    const pages = Number((await db.get('PRAGMA page_count'))?.page_count ?? 0);
+    const free = Number((await db.get('PRAGMA freelist_count'))?.freelist_count ?? 0);
+    const size = Number((await db.get('PRAGMA page_size'))?.page_size ?? 4096);
+    return (pages - free) * size;
+}
+function fileBytes(dbPath) {
+    return [dbPath, `${dbPath}-wal`].reduce((n, f) => n + (fs.existsSync(f) ? fs.statSync(f).size : 0), 0);
+}
+function freeSpace(dir) {
+    const stats = fs.statfsSync(dir);
+    return Number(stats.bavail) * Number(stats.bsize);
+}
+function mb(bytes) {
+    return bytes >= 1024 ** 3 ? `${(bytes / 1024 ** 3).toFixed(1)} GB` : `${Math.round(bytes / 1024 ** 2)} MB`;
+}

package/dist/storage/cache-cleanup.test.d.ts

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

package/dist/storage/cache-cleanup.test.js

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { cleanContextCache, deadCacheRows } from './cache-cleanup.js';
+import { openDatabase } from './db.js';
+let dir;
+let dbPath;
+async function seed(rows) {
+    const db = (await openDatabase(dbPath));
+    // One transaction: row-at-a-time commits are slow enough on Windows to time the test out.
+    await db.exec('BEGIN');
+    for (const [key, type] of rows) {
+        await db.run(`INSERT INTO context_cache (cache_key, cache_type, repo, branch, dependency_fingerprint, payload_json, payload_tokens, created_at)
+             VALUES (?, ?, 'r', 'main', 'f', ?, 1, 0)`, key, type, JSON.stringify({ padding: 'x'.repeat(2000) }));
+    }
+    await db.exec('COMMIT');
+    await db.close();
+}
+beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cache-cleanup-')); // a temporary database: never ~/.rigour
+    dbPath = path.join(dir, 'rigour.db');
+});
+// Windows keeps a just-closed SQLite file locked for a moment: retry the removal instead of failing.
+afterEach(() => fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }));
+// Real SQLite files on disk: slower on Windows runners than the 5 s default allows.
+describe('cleanContextCache', { timeout: 30_000 }, () => {
+    it('removes the unread layers, keeps the readable rows and the indexes, and shrinks the file', async () => {
+        await seed([
+            ...Array.from({ length: 200 }, (_, i) => [`static:${i}`, 'static']),
+            ...Array.from({ length: 200 }, (_, i) => [`component:${i}`, 'component']),
+            ['semantic:a', 'semantic'], ['checkpoint:b', 'checkpoint'],
+        ]);
+        expect(await deadCacheRows(dbPath)).toMatchObject({ rows: 400 });
+        const report = await cleanContextCache(dbPath, () => Number.MAX_SAFE_INTEGER);
+        expect(report).toMatchObject({ removed: 400, kept: 2, vacuumed: true });
+        expect(report.sizeAfter).toBeLessThan(report.sizeBefore);
+        const db = (await openDatabase(dbPath));
+        expect((await db.all('SELECT cache_key FROM context_cache ORDER BY cache_key')).map(r => r.cache_key)).toEqual(['checkpoint:b', 'semantic:a']);
+        expect((await db.all("SELECT name FROM sqlite_master WHERE tbl_name = 'context_cache' AND type = 'index'")).map(r => r.name)).toContain('idx_context_cache_type');
+        await db.close();
+        expect(await deadCacheRows(dbPath)).toMatchObject({ rows: 0 });
+    });
+    it('still removes the rows but leaves the file size alone when the disk lacks room to shrink it', async () => {
+        await seed([['static:1', 'static'], ['semantic:a', 'semantic']]);
+        const report = await cleanContextCache(dbPath, () => 0);
+        expect(report).toMatchObject({ removed: 1, kept: 1, vacuumed: false });
+        expect(report.vacuumSkipped).toContain('free to shrink the file');
+    });
+    it('does nothing when there is nothing to remove', async () => {
+        await seed([['semantic:a', 'semantic']]);
+        expect(await cleanContextCache(dbPath, () => 0)).toMatchObject({ removed: 0, vacuumed: false, vacuumSkipped: 'nothing to remove' });
+    });
+});

package/dist/storage/db.js

@@ -10,6 +10,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { createRequire } from 'module';
+import { rigourUserDir } from '../utils/user-state.js';
 // ---------------------------------------------------------------------------
 // Optional dynamic import of sqlite3
 // ---------------------------------------------------------------------------
@@ -42,7 +43,8 @@ function loadSqlite3() {
     sqlite3Module = null;
     return sqlite3Module;
 }
-const RIGOUR_DIR = path.join(os.homedir(), '.rigour');
+// RIGOUR_HOME when set (tests, sandboxes) so nothing but a real run touches ~/.rigour.
+const RIGOUR_DIR = rigourUserDir();
 const DB_PATH = path.join(RIGOUR_DIR, 'rigour.db');
 /** Current schema version — bump when adding migrations. */
 const SCHEMA_VERSION = 7;

package/dist/storage/index.d.ts

@@ -3,6 +3,7 @@
  * Everything in one file: ~/.rigour/rigour.db
  */
 export { openDatabase, isSQLiteAvailable, compactDatabase, getDatabaseSize, resetDatabase, RIGOUR_DIR, DB_PATH } from './db.js';
+export { cleanContextCache, deadCacheRows, DEAD_CACHE_TYPES, type CacheCleanupReport } from './cache-cleanup.js';
 export type { RigourDB, CompactResult } from './db.js';
 export { insertScan, getRecentScans, getScoreTrendFromDB, getTopIssues } from './scans.js';
 export { insertFindings, getFindingsForScan, getDeepFindings } from './findings.js';

package/dist/storage/index.js

@@ -3,6 +3,7 @@
  * Everything in one file: ~/.rigour/rigour.db
  */
 export { openDatabase, isSQLiteAvailable, compactDatabase, getDatabaseSize, resetDatabase, RIGOUR_DIR, DB_PATH } from './db.js';
+export { cleanContextCache, deadCacheRows, DEAD_CACHE_TYPES } from './cache-cleanup.js';
 export { insertScan, getRecentScans, getScoreTrendFromDB, getTopIssues } from './scans.js';
 export { insertFindings, getFindingsForScan, getDeepFindings } from './findings.js';
 export { reinforcePattern, decayPatterns, getStrongPatterns, getPatterns, getHardRules } from './patterns.js';

package/dist/storage/local-encryption.js

@@ -1,9 +1,9 @@
 import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
 import { chmod, link, readFile, unlink, writeFile } from 'node:fs/promises';
 import fs from 'fs-extra';
-import os from 'os';
 import path from 'path';
-const KEY_PATH = path.join(os.homedir(), '.rigour', 'team-cache.key');
+import { rigourUserDir } from '../utils/user-state.js';
+const KEY_PATH = path.join(rigourUserDir(), 'team-cache.key');
 let fileKeyPromise;
 function decodeKey(value, source) {
     const normalized = value.trim();

package/dist/storage/team-store.js

@@ -1,17 +1,17 @@
 import fs from 'fs-extra';
-import os from 'os';
 import path from 'path';
 import { openDatabase } from './db.js';
 import { decryptLocalPayload, encryptLocalPayload } from './local-encryption.js';
 import { TEAM_SCHEMA } from './team-schema.js';
 import { diagnoseMissingMembership, explainTeamConnectionError } from './team-diagnostics.js';
+import { rigourUserDir } from '../utils/user-state.js';
 import { TEAM_VECTOR_SCHEMA, backfillConfiguredTeamEmbeddings, getTeamSemanticHealth, searchConfiguredTeamKnowledge, upsertTeamLessonEmbedding, } from './team-vector-store.js';
 const DEFAULT_SEMANTIC = {
     provider: 'pgvector',
     model: 'Xenova/all-MiniLM-L6-v2',
     dimensions: 384,
 };
-export const TEAM_CONFIG_PATH = path.join(os.homedir(), '.rigour', 'team.json');
+export const TEAM_CONFIG_PATH = path.join(rigourUserDir(), 'team.json');
 function nonEmpty(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }

package/dist/types/index.d.ts

@@ -3643,6 +3643,11 @@ export interface DeepOptions {
     }>>;
     /** What the change intends (a PR description): reference for the stronger tiers. */
     prBody?: string;
+    /**
+     * Review every risky changed function, ignoring the review ledger and reviewed.json. Those
+     * record what an agent said it reviewed; an enforcing check reviews independently.
+     */
+    independent?: boolean;
     /** The change's unified diff (from reviewChange): a cloud agentic review reads the PR as a whole. */
     diff?: string;
 }

package/dist/utils/user-state.d.ts

@@ -0,0 +1,7 @@
+/** The user's Rigour directory: RIGOUR_HOME/.rigour when set (tests, sandboxes), else ~/.rigour. */
+export declare function rigourUserDir(): string;
+/**
+ * Per-repository state kept outside the workspace, where an agent editing the repository
+ * cannot rewrite it: arbitration tokens, stop-hook attempt counts. Keyed by the real path.
+ */
+export declare function repoStateDir(cwd: string): string;

package/dist/utils/user-state.js

@@ -0,0 +1,21 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+/** The user's Rigour directory: RIGOUR_HOME/.rigour when set (tests, sandboxes), else ~/.rigour. */
+export function rigourUserDir() {
+    return path.join(process.env.RIGOUR_HOME || os.homedir(), '.rigour');
+}
+/**
+ * Per-repository state kept outside the workspace, where an agent editing the repository
+ * cannot rewrite it: arbitration tokens, stop-hook attempt counts. Keyed by the real path.
+ */
+export function repoStateDir(cwd) {
+    let root = path.resolve(cwd);
+    try {
+        root = fs.realpathSync.native(root);
+    }
+    catch { /* not created yet: the resolved path is the key */ }
+    const key = crypto.createHash('sha256').update(root).digest('hex').slice(0, 16);
+    return path.join(rigourUserDir(), 'repos', key);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.5.3",
+  "version": "6.6.0",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22"
@@ -70,11 +70,11 @@
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "6.5.3",
-    "@rigour-labs/brain-darwin-x64": "6.5.3",
-    "@rigour-labs/brain-linux-x64": "6.5.3",
-    "@rigour-labs/brain-linux-arm64": "6.5.3",
-    "@rigour-labs/brain-win-x64": "6.5.3"
+    "@rigour-labs/brain-darwin-arm64": "6.6.0",
+    "@rigour-labs/brain-darwin-x64": "6.6.0",
+    "@rigour-labs/brain-linux-arm64": "6.6.0",
+    "@rigour-labs/brain-linux-x64": "6.6.0",
+    "@rigour-labs/brain-win-x64": "6.6.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",