@rigour-labs/core 5.0.1 → 5.1.1

package/dist/storage/db.js

@@ -2,27 +2,31 @@
  * SQLite storage layer for Rigour Brain.
  * 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.
  */
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { createRequire } from 'module';
-// better-sqlite3 is optional — graceful degradation if not installed.
-// It's a native C++ addon that uses require() semantics, so we use createRequire.
-let Database = null;
-let _dbResolved = false;
-function loadDatabase() {
-    if (_dbResolved)
-        return Database;
-    _dbResolved = true;
+// ---------------------------------------------------------------------------
+// Optional dynamic import of sqlite3
+// ---------------------------------------------------------------------------
+let sqlite3Module = null;
+let _resolved = false;
+function loadSqlite3() {
+    if (_resolved)
+        return sqlite3Module;
+    _resolved = true;
     try {
         const require = createRequire(import.meta.url);
-        Database = require('better-sqlite3');
+        sqlite3Module = require('sqlite3');
     }
     catch {
-        Database = null;
+        sqlite3Module = null;
     }
-    return Database;
+    return sqlite3Module;
 }
 const RIGOUR_DIR = path.join(os.homedir(), '.rigour');
 const DB_PATH = path.join(RIGOUR_DIR, 'rigour.db');
@@ -108,87 +112,144 @@ CREATE INDEX IF NOT EXISTS idx_findings_category ON findings(category);
 CREATE INDEX IF NOT EXISTS idx_patterns_repo ON patterns(repo);
 CREATE INDEX IF NOT EXISTS idx_patterns_strength ON patterns(strength);
 `;
+function wrapDatabase(raw) {
+    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 });
+                });
+            });
+        },
+        get(sql, ...params) {
+            return new Promise((resolve, reject) => {
+                raw.get(sql, ...params, (err, row) => {
+                    if (err)
+                        return reject(err);
+                    resolve(row);
+                });
+            });
+        },
+        all(sql, ...params) {
+            return new Promise((resolve, reject) => {
+                raw.all(sql, ...params, (err, rows) => {
+                    if (err)
+                        return reject(err);
+                    resolve(rows || []);
+                });
+            });
+        },
+        exec(sql) {
+            return new Promise((resolve, reject) => {
+                raw.exec(sql, (err) => {
+                    if (err)
+                        return reject(err);
+                    resolve();
+                });
+            });
+        },
+        close() {
+            return new Promise((resolve, reject) => {
+                raw.close((err) => {
+                    if (err)
+                        return reject(err);
+                    resolve();
+                });
+            });
+        },
+        async transaction(fn) {
+            await db.exec('BEGIN TRANSACTION');
+            try {
+                const result = await fn(db);
+                await db.exec('COMMIT');
+                return result;
+            }
+            catch (err) {
+                await db.exec('ROLLBACK');
+                throw err;
+            }
+        },
+    };
+    return db;
+}
 /**
  * Open (or create) the Rigour SQLite database.
- * Returns null if better-sqlite3 is not available.
+ * Returns null if sqlite3 is not available.
  */
-export function openDatabase(dbPath) {
-    const Db = loadDatabase();
-    if (!Db)
+export async function openDatabase(dbPath) {
+    const sqlite3 = loadSqlite3();
+    if (!sqlite3)
         return null;
     const resolvedPath = dbPath || DB_PATH;
     fs.ensureDirSync(path.dirname(resolvedPath));
-    const db = new Db(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);
     // WAL mode for better concurrent read performance
-    db.pragma('journal_mode = WAL');
-    db.pragma('foreign_keys = ON');
+    await db.exec('PRAGMA journal_mode = WAL');
+    await db.exec('PRAGMA foreign_keys = ON');
     // Run schema creation + migrations
-    db.exec(SCHEMA_SQL);
-    runMigrations(db);
-    return {
-        db,
-        close() {
-            db.close();
-        },
-    };
+    await db.exec(SCHEMA_SQL);
+    await runMigrations(db);
+    return db;
 }
 /**
  * Run incremental schema migrations based on stored version.
  */
-function runMigrations(db) {
-    const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+async function runMigrations(db) {
+    const row = await db.get("SELECT value FROM meta WHERE key = 'schema_version'");
     const current = row ? parseInt(row.value, 10) : 0;
     if (current < 1) {
-        // v1: base schema (already created by SCHEMA_SQL)
-        db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '1')").run();
+        await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '1')");
     }
     if (current < 2) {
-        // v2: retention indexes for compaction queries
-        db.exec(`
+        await db.exec(`
             CREATE INDEX IF NOT EXISTS idx_findings_file ON findings(file);
             CREATE INDEX IF NOT EXISTS idx_scans_repo_ts ON scans(repo, timestamp);
         `);
-        db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '2')").run();
+        await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '2')");
     }
     // Future: if (current < 3) { ... ALTER TABLE ... }
 }
 /**
  * Compact the database — prune old data, reclaim disk space.
- * Retention policy: keep last `retainDays` of findings, merge old patterns.
  */
-export function compactDatabase(retainDays = 90) {
-    const Db = loadDatabase();
-    if (!Db)
+export async function compactDatabase(retainDays = 90) {
+    const sqlite3 = loadSqlite3();
+    if (!sqlite3)
         return { pruned: 0, patternsDecayed: 0, sizeBefore: 0, sizeAfter: 0 };
     const resolvedPath = DB_PATH;
     const sizeBefore = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath).size : 0;
-    const db = new Db(resolvedPath);
-    db.pragma('journal_mode = WAL');
+    const db = await openDatabase(resolvedPath);
+    if (!db)
+        return { pruned: 0, patternsDecayed: 0, sizeBefore, sizeAfter: sizeBefore };
     const cutoff = Date.now() - (retainDays * 24 * 60 * 60 * 1000);
     let pruned = 0;
     let patternsDecayed = 0;
     try {
-        db.transaction(() => {
-            // 1. Delete old findings (keep scan records for trend lines)
-            const r1 = db.prepare(`
+        await db.transaction(async (tx) => {
+            const r1 = await tx.run(`
                 DELETE FROM findings WHERE scan_id IN (
                     SELECT id FROM scans WHERE timestamp < ?
                 )
-            `).run(cutoff);
+            `, cutoff);
             pruned += r1.changes;
-            // 2. Prune weak patterns (never grew, seen < 3 times)
-            const r2 = db.prepare("DELETE FROM patterns WHERE strength < 0.3 AND times_seen < 3").run();
+            const r2 = await tx.run("DELETE FROM patterns WHERE strength < 0.3 AND times_seen < 3");
             patternsDecayed += r2.changes;
-            // 3. Prune orphaned feedback
-            db.prepare("DELETE FROM feedback WHERE finding_id NOT IN (SELECT id FROM findings)").run();
-            // 4. Prune old codebase index entries
-            db.prepare("DELETE FROM codebase WHERE last_indexed < ?").run(cutoff);
-        })();
-        // 5. Reclaim disk space
-        db.exec('VACUUM');
+            await tx.run("DELETE FROM feedback WHERE finding_id NOT IN (SELECT id FROM findings)");
+            await tx.run("DELETE FROM codebase WHERE last_indexed < ?", cutoff);
+        });
+        await db.exec('VACUUM');
     }
     finally {
-        db.close();
+        await db.close();
     }
     const sizeAfter = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath).size : 0;
     return { pruned, patternsDecayed, sizeBefore, sizeAfter };
@@ -211,9 +272,9 @@ export function resetDatabase() {
         fs.removeSync(DB_PATH + '-shm');
 }
 /**
- * Check if SQLite is available (better-sqlite3 installed)
+ * Check if SQLite is available (sqlite3 installed)
  */
 export function isSQLiteAvailable() {
-    return loadDatabase() !== null;
+    return loadSqlite3() !== null;
 }
 export { RIGOUR_DIR, DB_PATH };

package/dist/storage/findings.d.ts

@@ -2,14 +2,15 @@ import type { RigourDB } from './db.js';
 import type { Failure } from '../types/index.js';
 /**
  * Insert findings from a scan report into SQLite.
+ * Uses a transaction for atomicity on bulk inserts.
  */
-export declare function insertFindings(store: RigourDB, scanId: string, failures: Failure[]): void;
+export declare function insertFindings(store: RigourDB, scanId: string, failures: Failure[]): Promise<void>;
 /**
  * Get findings for a specific scan.
  */
-export declare function getFindingsForScan(store: RigourDB, scanId: string): any[];
+export declare function getFindingsForScan(store: RigourDB, scanId: string): Promise<any[]>;
 /**
  * Get deep analysis and high-confidence AST findings for a repo.
  * Used by local memory to match known patterns against new scans.
  */
-export declare function getDeepFindings(store: RigourDB, repo: string, limit?: number): any[];
+export declare function getDeepFindings(store: RigourDB, repo: string, limit?: number): Promise<any[]>;

package/dist/storage/findings.js

@@ -4,36 +4,29 @@
 import { randomUUID } from 'crypto';
 /**
  * Insert findings from a scan report into SQLite.
+ * Uses a transaction for atomicity on bulk inserts.
  */
-export function insertFindings(store, scanId, failures) {
-    const stmt = store.db.prepare(`
-        INSERT INTO findings (id, scan_id, file, line, category, severity, source, provenance, description, suggestion, confidence, verified)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const insertMany = store.db.transaction((items) => {
-        for (const f of items) {
-            stmt.run(randomUUID(), scanId, f.files?.[0] || 'unknown', f.line ?? null, f.category || f.id, f.severity || 'medium', f.source || 'ast', f.provenance || 'traditional', f.details, f.hint ?? null, f.confidence ?? null, f.verified ? 1 : 0);
+export async function insertFindings(store, scanId, failures) {
+    await store.transaction(async (tx) => {
+        for (const f of failures) {
+            await tx.run(`INSERT INTO findings (id, scan_id, file, line, category, severity, source, provenance, description, suggestion, confidence, verified)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, randomUUID(), scanId, f.files?.[0] || 'unknown', f.line ?? null, f.category || f.id, f.severity || 'medium', f.source || 'ast', f.provenance || 'traditional', f.details, f.hint ?? null, f.confidence ?? null, f.verified ? 1 : 0);
         }
     });
-    insertMany(failures);
 }
 /**
  * Get findings for a specific scan.
  */
-export function getFindingsForScan(store, scanId) {
-    const stmt = store.db.prepare('SELECT * FROM findings WHERE scan_id = ? ORDER BY severity ASC');
-    return stmt.all(scanId);
+export async function getFindingsForScan(store, scanId) {
+    return store.all('SELECT * FROM findings WHERE scan_id = ? ORDER BY severity ASC', scanId);
 }
 /**
  * Get deep analysis and high-confidence AST findings for a repo.
  * Used by local memory to match known patterns against new scans.
  */
-export function getDeepFindings(store, repo, limit = 50) {
-    const stmt = store.db.prepare(`
-        SELECT f.* FROM findings f
-        JOIN scans s ON f.scan_id = s.id
-        WHERE s.repo = ? AND (f.source = 'llm' OR f.source = 'hybrid' OR f.confidence >= 0.7)
-        ORDER BY f.confidence DESC LIMIT ?
-    `);
-    return stmt.all(repo, limit);
+export async function getDeepFindings(store, repo, limit = 50) {
+    return store.all(`SELECT f.* FROM findings f
+         JOIN scans s ON f.scan_id = s.id
+         WHERE s.repo = ? AND (f.source = 'llm' OR f.source = 'hybrid' OR f.confidence >= 0.7)
+         ORDER BY f.confidence DESC LIMIT ?`, repo, limit);
 }

package/dist/storage/local-memory.d.ts

@@ -7,10 +7,10 @@ import type { DeepFinding } from '../inference/types.js';
  * @param cwd     - Absolute project root path
  * @param fileList - Relative file paths (from FileFacts.path or globby)
  */
-export declare function checkLocalPatterns(cwd: string, fileList: string[]): DeepFinding[];
+export declare function checkLocalPatterns(cwd: string, fileList: string[]): Promise<DeepFinding[]>;
 /**
  * Post-scan: persist findings and reinforce patterns.
- * Wrapped in a single transaction for atomicity.
+ * Uses a transaction for atomicity.
  * Called after every scan (check, scan, scan --deep).
  */
 export declare function persistAndReinforce(cwd: string, report: {
@@ -20,11 +20,11 @@ export declare function persistAndReinforce(cwd: string, report: {
 }, meta?: {
     deepTier?: string;
     deepModel?: string;
-}): void;
+}): Promise<void>;
 /**
  * Get project learning stats (for display in scan output).
  */
-export declare function getProjectStats(cwd: string): ProjectStats | null;
+export declare function getProjectStats(cwd: string): Promise<ProjectStats | null>;
 export interface ProjectStats {
     totalScans: number;
     learnedPatterns: number;

package/dist/storage/local-memory.js

@@ -36,18 +36,18 @@ function buildFileIssueMap(recentFindings) {
  * @param cwd     - Absolute project root path
  * @param fileList - Relative file paths (from FileFacts.path or globby)
  */
-export function checkLocalPatterns(cwd, fileList) {
-    const db = openDatabase();
+export async function checkLocalPatterns(cwd, fileList) {
+    const db = await openDatabase();
     if (!db)
         return [];
     const repoName = path.basename(cwd);
     const findings = [];
     try {
-        const patterns = getStrongPatterns(db, repoName, INSTANT_MATCH_THRESHOLD);
+        const patterns = await getStrongPatterns(db, repoName, INSTANT_MATCH_THRESHOLD);
         if (patterns.length === 0)
             return [];
         // Include both AST and LLM findings from history
-        const recentFindings = getDeepFindings(db, repoName, 200);
+        const recentFindings = await getDeepFindings(db, repoName, 200);
         if (recentFindings.length === 0)
             return [];
         const fileIssueMap = buildFileIssueMap(recentFindings);
@@ -82,35 +82,33 @@ export function checkLocalPatterns(cwd, fileList) {
         Logger.warn(`Local memory check failed: ${error}`);
     }
     finally {
-        db?.db.close();
+        await db?.close();
     }
     return findings;
 }
 /**
  * Post-scan: persist findings and reinforce patterns.
- * Wrapped in a single transaction for atomicity.
+ * Uses a transaction for atomicity.
  * Called after every scan (check, scan, scan --deep).
  */
-export function persistAndReinforce(cwd, report, meta) {
-    const db = openDatabase();
+export async function persistAndReinforce(cwd, report, meta) {
+    const db = await openDatabase();
     if (!db)
         return;
     const repoName = path.basename(cwd);
     try {
-        // Wrap all writes in a single transaction for atomicity
-        const persist = db.db.transaction(() => {
-            const scanId = insertScan(db, repoName, report, meta);
+        await db.transaction(async (tx) => {
+            const scanId = await insertScan(tx, repoName, report, meta);
             if (report.failures.length > 0) {
-                insertFindings(db, scanId, report.failures);
+                await insertFindings(tx, scanId, report.failures);
             }
             for (const f of report.failures) {
                 const category = f.category || f.id;
                 const source = f.source === 'llm' ? 'llm' : 'ast';
-                reinforcePattern(db, repoName, category, `${f.title}: ${f.details?.substring(0, 120)}`, source);
+                await reinforcePattern(tx, repoName, category, `${f.title}: ${f.details?.substring(0, 120)}`, source);
             }
-            decayPatterns(db, 30);
+            await decayPatterns(tx, 30);
         });
-        persist();
         Logger.info(`Local memory: stored ${report.failures.length} findings, ` +
             `reinforced ${report.failures.length} patterns for ${repoName}`);
     }
@@ -118,21 +116,21 @@ export function persistAndReinforce(cwd, report, meta) {
         Logger.warn(`Local memory persist failed: ${error}`);
     }
     finally {
-        db?.db.close();
+        await db?.close();
     }
 }
 /**
  * Get project learning stats (for display in scan output).
  */
-export function getProjectStats(cwd) {
-    const db = openDatabase();
+export async function getProjectStats(cwd) {
+    const db = await openDatabase();
     if (!db)
         return null;
     const repoName = path.basename(cwd);
     try {
-        const scans = getRecentScans(db, repoName, 100);
-        const patterns = getStrongPatterns(db, repoName, 0.3);
-        const hardRules = getHardRules(db, repoName);
+        const scans = await getRecentScans(db, repoName, 100);
+        const patterns = await getStrongPatterns(db, repoName, 0.3);
+        const hardRules = await getHardRules(db, repoName);
         return {
             totalScans: scans.length,
             learnedPatterns: patterns.length,
@@ -148,6 +146,6 @@ export function getProjectStats(cwd) {
         return null;
     }
     finally {
-        db?.db.close();
+        await db?.close();
     }
 }

package/dist/storage/patterns.d.ts

@@ -15,21 +15,21 @@ export interface PatternRecord {
  * If the pattern already exists for this repo, increase strength.
  * Otherwise, create a new pattern.
  */
-export declare function reinforcePattern(store: RigourDB, repo: string, pattern: string, description: string, source: 'ast' | 'llm' | 'human_feedback'): void;
+export declare function reinforcePattern(store: RigourDB, repo: string, pattern: string, description: string, source: 'ast' | 'llm' | 'human_feedback'): Promise<void>;
 /**
  * Decay patterns not seen in the last N days.
  */
-export declare function decayPatterns(store: RigourDB, daysThreshold?: number): number;
+export declare function decayPatterns(store: RigourDB, daysThreshold?: number): Promise<number>;
 /**
  * Get strong patterns for a repo (strength > threshold).
  */
-export declare function getStrongPatterns(store: RigourDB, repo: string, threshold?: number): PatternRecord[];
+export declare function getStrongPatterns(store: RigourDB, repo: string, threshold?: number): Promise<PatternRecord[]>;
 /**
  * Get all patterns for a repo.
  */
-export declare function getPatterns(store: RigourDB, repo: string): PatternRecord[];
+export declare function getPatterns(store: RigourDB, repo: string): Promise<PatternRecord[]>;
 /**
  * Get patterns promoted to hard rules (strength > 0.9).
  * These can be used as AST-level checks without LLM inference.
  */
-export declare function getHardRules(store: RigourDB, repo: string): PatternRecord[];
+export declare function getHardRules(store: RigourDB, repo: string): Promise<PatternRecord[]>;

package/dist/storage/patterns.js

@@ -8,55 +8,49 @@ import { randomUUID } from 'crypto';
  * If the pattern already exists for this repo, increase strength.
  * Otherwise, create a new pattern.
  */
-export function reinforcePattern(store, repo, pattern, description, source) {
+export async function reinforcePattern(store, repo, pattern, description, source) {
     const now = Date.now();
-    const existing = store.db.prepare('SELECT * FROM patterns WHERE repo = ? AND pattern = ?').get(repo, pattern);
+    const existing = await store.get('SELECT * FROM patterns WHERE repo = ? AND pattern = ?', repo, pattern);
     if (existing) {
-        store.db.prepare(`
-            UPDATE patterns
-            SET strength = MIN(strength + 0.15, 1.0),
-                times_seen = times_seen + 1,
-                last_seen = ?,
-                description = COALESCE(?, description)
-            WHERE id = ?
-        `).run(now, description, existing.id);
+        await store.run(`UPDATE patterns
+             SET strength = MIN(strength + 0.15, 1.0),
+                 times_seen = times_seen + 1,
+                 last_seen = ?,
+                 description = COALESCE(?, description)
+             WHERE id = ?`, now, description, existing.id);
     }
     else {
-        store.db.prepare(`
-            INSERT INTO patterns (id, repo, pattern, description, strength, times_seen, first_seen, last_seen, source)
-            VALUES (?, ?, ?, ?, 0.3, 1, ?, ?, ?)
-        `).run(randomUUID(), repo, pattern, description, now, now, source);
+        await store.run(`INSERT INTO patterns (id, repo, pattern, description, strength, times_seen, first_seen, last_seen, source)
+             VALUES (?, ?, ?, ?, 0.3, 1, ?, ?, ?)`, randomUUID(), repo, pattern, description, now, now, source);
     }
 }
 /**
  * Decay patterns not seen in the last N days.
  */
-export function decayPatterns(store, daysThreshold = 30) {
+export async function decayPatterns(store, daysThreshold = 30) {
     const cutoff = Date.now() - (daysThreshold * 24 * 60 * 60 * 1000);
-    const result = store.db.prepare(`
-        UPDATE patterns SET strength = MAX(strength - 0.05, 0.0)
-        WHERE last_seen < ?
-    `).run(cutoff);
+    const result = await store.run(`UPDATE patterns SET strength = MAX(strength - 0.05, 0.0)
+         WHERE last_seen < ?`, cutoff);
     // Prune dead patterns
-    store.db.prepare('DELETE FROM patterns WHERE strength < 0.1').run();
+    await store.run('DELETE FROM patterns WHERE strength < 0.1');
     return result.changes;
 }
 /**
  * Get strong patterns for a repo (strength > threshold).
  */
-export function getStrongPatterns(store, repo, threshold = 0.7) {
-    return store.db.prepare('SELECT * FROM patterns WHERE repo = ? AND strength >= ? ORDER BY strength DESC').all(repo, threshold);
+export async function getStrongPatterns(store, repo, threshold = 0.7) {
+    return store.all('SELECT * FROM patterns WHERE repo = ? AND strength >= ? ORDER BY strength DESC', repo, threshold);
 }
 /**
  * Get all patterns for a repo.
  */
-export function getPatterns(store, repo) {
-    return store.db.prepare('SELECT * FROM patterns WHERE repo = ? ORDER BY strength DESC').all(repo);
+export async function getPatterns(store, repo) {
+    return store.all('SELECT * FROM patterns WHERE repo = ? ORDER BY strength DESC', repo);
 }
 /**
  * Get patterns promoted to hard rules (strength > 0.9).
  * These can be used as AST-level checks without LLM inference.
  */
-export function getHardRules(store, repo) {
-    return store.db.prepare('SELECT * FROM patterns WHERE repo = ? AND strength >= 0.9 ORDER BY times_seen DESC').all(repo);
+export async function getHardRules(store, repo) {
+    return store.all('SELECT * FROM patterns WHERE repo = ? AND strength >= 0.9 ORDER BY times_seen DESC', repo);
 }

package/dist/storage/scans.d.ts

@@ -21,22 +21,22 @@ export declare function insertScan(store: RigourDB, repo: string, report: Report
     filesScanned?: number;
     deepTier?: string;
     deepModel?: string;
-}): string;
+}): Promise<string>;
 /**
  * Get recent scans for a repo (newest first).
  */
-export declare function getRecentScans(store: RigourDB, repo: string, limit?: number): ScanRecord[];
+export declare function getRecentScans(store: RigourDB, repo: string, limit?: number): Promise<ScanRecord[]>;
 /**
  * Get score trend for a repo.
  */
-export declare function getScoreTrendFromDB(store: RigourDB, repo: string, limit?: number): {
+export declare function getScoreTrendFromDB(store: RigourDB, repo: string, limit?: number): Promise<{
     scores: number[];
     direction: 'improving' | 'degrading' | 'stable';
-};
+}>;
 /**
  * Get most common issue categories for a repo.
  */
-export declare function getTopIssues(store: RigourDB, repo: string, limit?: number): {
+export declare function getTopIssues(store: RigourDB, repo: string, limit?: number): Promise<{
     category: string;
     count: number;
-}[];
+}[]>;

package/dist/storage/scans.js

@@ -5,29 +5,23 @@ import { randomUUID } from 'crypto';
 /**
  * Insert a scan record from a Rigour report.
  */
-export function insertScan(store, repo, report, meta) {
+export async function insertScan(store, repo, report, meta) {
     const id = randomUUID();
-    const stmt = store.db.prepare(`
-        INSERT INTO scans (id, repo, commit_hash, timestamp, ai_health_score, code_quality_score, overall_score, files_scanned, duration_ms, deep_tier, deep_model)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(id, repo, meta?.commitHash || null, Date.now(), report.stats.ai_health_score ?? null, report.stats.code_quality_score ?? null, report.stats.score ?? null, meta?.filesScanned ?? null, report.stats.duration_ms, meta?.deepTier ?? null, meta?.deepModel ?? null);
+    await store.run(`INSERT INTO scans (id, repo, commit_hash, timestamp, ai_health_score, code_quality_score, overall_score, files_scanned, duration_ms, deep_tier, deep_model)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, repo, meta?.commitHash || null, Date.now(), report.stats.ai_health_score ?? null, report.stats.code_quality_score ?? null, report.stats.score ?? null, meta?.filesScanned ?? null, report.stats.duration_ms, meta?.deepTier ?? null, meta?.deepModel ?? null);
     return id;
 }
 /**
  * Get recent scans for a repo (newest first).
  */
-export function getRecentScans(store, repo, limit = 10) {
-    const stmt = store.db.prepare(`
-        SELECT * FROM scans WHERE repo = ? ORDER BY timestamp DESC LIMIT ?
-    `);
-    return stmt.all(repo, limit);
+export async function getRecentScans(store, repo, limit = 10) {
+    return store.all('SELECT * FROM scans WHERE repo = ? ORDER BY timestamp DESC LIMIT ?', repo, limit);
 }
 /**
  * Get score trend for a repo.
  */
-export function getScoreTrendFromDB(store, repo, limit = 10) {
-    const scans = getRecentScans(store, repo, limit);
+export async function getScoreTrendFromDB(store, repo, limit = 10) {
+    const scans = await getRecentScans(store, repo, limit);
     const scores = scans
         .filter(s => s.overall_score != null)
         .map(s => s.overall_score)
@@ -44,12 +38,9 @@ export function getScoreTrendFromDB(store, repo, limit = 10) {
 /**
  * Get most common issue categories for a repo.
  */
-export function getTopIssues(store, repo, limit = 10) {
-    const stmt = store.db.prepare(`
-        SELECT f.category, COUNT(*) as count FROM findings f
-        JOIN scans s ON f.scan_id = s.id
-        WHERE s.repo = ?
-        GROUP BY f.category ORDER BY count DESC LIMIT ?
-    `);
-    return stmt.all(repo, limit);
+export async function getTopIssues(store, repo, limit = 10) {
+    return store.all(`SELECT f.category, COUNT(*) as count FROM findings f
+         JOIN scans s ON f.scan_id = s.id
+         WHERE s.repo = ?
+         GROUP BY f.category ORDER BY count DESC LIMIT ?`, repo, limit);
 }

package/dist/types/index.d.ts

@@ -3109,4 +3109,5 @@ export interface DeepOptions {
     apiBaseUrl?: string;
     modelName?: string;
     agents?: number;
+    maxFiles?: number;
 }

package/dist/utils/scanner.js

@@ -2,7 +2,7 @@ import { globby } from 'globby';
 import fs from 'fs-extra';
 import path from 'path';
 export class FileScanner {
-    static DEFAULT_PATTERNS = ['**/*.{ts,js,py,css,html,md}'];
+    static DEFAULT_PATTERNS = ['**/*.{ts,tsx,js,jsx,mjs,cjs,py,go,rs,rb,cs,java,kt,css,html,md,yaml,yml,toml,json}'];
     static DEFAULT_IGNORE = [
         '**/node_modules/**',
         '**/dist/**',