@rigour-labs/core 3.0.6 → 4.0.0

package/dist/storage/db.d.ts

@@ -0,0 +1,16 @@
+declare const RIGOUR_DIR: string;
+declare const DB_PATH: string;
+export interface RigourDB {
+    db: any;
+    close(): void;
+}
+/**
+ * Open (or create) the Rigour SQLite database.
+ * Returns null if better-sqlite3 is not available.
+ */
+export declare function openDatabase(dbPath?: string): RigourDB | null;
+/**
+ * Check if SQLite is available (better-sqlite3 installed)
+ */
+export declare function isSQLiteAvailable(): boolean;
+export { RIGOUR_DIR, DB_PATH };

package/dist/storage/db.js

@@ -0,0 +1,132 @@
+/**
+ * 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.
+ */
+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;
+    try {
+        const require = createRequire(import.meta.url);
+        Database = require('better-sqlite3');
+    }
+    catch {
+        Database = null;
+    }
+    return Database;
+}
+const RIGOUR_DIR = path.join(os.homedir(), '.rigour');
+const DB_PATH = path.join(RIGOUR_DIR, 'rigour.db');
+const SCHEMA_SQL = `
+-- Every scan result, forever
+CREATE TABLE IF NOT EXISTS scans (
+    id TEXT PRIMARY KEY,
+    repo TEXT NOT NULL,
+    commit_hash TEXT,
+    timestamp INTEGER NOT NULL,
+    ai_health_score INTEGER,
+    code_quality_score INTEGER,
+    overall_score INTEGER,
+    files_scanned INTEGER,
+    duration_ms INTEGER,
+    deep_tier TEXT,
+    deep_model TEXT
+);
+
+-- Every finding from every scan
+CREATE TABLE IF NOT EXISTS findings (
+    id TEXT PRIMARY KEY,
+    scan_id TEXT REFERENCES scans(id),
+    file TEXT NOT NULL,
+    line INTEGER,
+    category TEXT NOT NULL,
+    severity TEXT NOT NULL,
+    source TEXT NOT NULL,
+    provenance TEXT,
+    description TEXT,
+    suggestion TEXT,
+    confidence REAL,
+    verified INTEGER DEFAULT 0
+);
+
+-- Learned patterns (the Brain's memory)
+CREATE TABLE IF NOT EXISTS patterns (
+    id TEXT PRIMARY KEY,
+    repo TEXT,
+    pattern TEXT NOT NULL,
+    description TEXT,
+    strength REAL DEFAULT 0.3,
+    times_seen INTEGER DEFAULT 1,
+    first_seen INTEGER NOT NULL,
+    last_seen INTEGER NOT NULL,
+    source TEXT NOT NULL
+);
+
+-- Human feedback on findings
+CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY,
+    finding_id TEXT REFERENCES findings(id),
+    rating TEXT NOT NULL,
+    comment TEXT,
+    timestamp INTEGER NOT NULL
+);
+
+-- Codebase index (AST graph)
+CREATE TABLE IF NOT EXISTS codebase (
+    id TEXT PRIMARY KEY,
+    repo TEXT NOT NULL,
+    file TEXT NOT NULL,
+    functions TEXT,
+    imports TEXT,
+    exports TEXT,
+    complexity_metrics TEXT,
+    last_indexed INTEGER NOT NULL
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_scans_repo ON scans(repo);
+CREATE INDEX IF NOT EXISTS idx_scans_timestamp ON scans(timestamp);
+CREATE INDEX IF NOT EXISTS idx_findings_scan ON findings(scan_id);
+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);
+`;
+/**
+ * Open (or create) the Rigour SQLite database.
+ * Returns null if better-sqlite3 is not available.
+ */
+export function openDatabase(dbPath) {
+    const Db = loadDatabase();
+    if (!Db)
+        return null;
+    const resolvedPath = dbPath || DB_PATH;
+    fs.ensureDirSync(path.dirname(resolvedPath));
+    const db = new Db(resolvedPath);
+    // WAL mode for better concurrent read performance
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    // Run schema migration
+    db.exec(SCHEMA_SQL);
+    return {
+        db,
+        close() {
+            db.close();
+        },
+    };
+}
+/**
+ * Check if SQLite is available (better-sqlite3 installed)
+ */
+export function isSQLiteAvailable() {
+    return loadDatabase() !== null;
+}
+export { RIGOUR_DIR, DB_PATH };

package/dist/storage/findings.d.ts

@@ -0,0 +1,14 @@
+import type { RigourDB } from './db.js';
+import type { Failure } from '../types/index.js';
+/**
+ * Insert findings from a scan report into SQLite.
+ */
+export declare function insertFindings(store: RigourDB, scanId: string, failures: Failure[]): void;
+/**
+ * Get findings for a specific scan.
+ */
+export declare function getFindingsForScan(store: RigourDB, scanId: string): any[];
+/**
+ * Get all deep analysis findings for a repo.
+ */
+export declare function getDeepFindings(store: RigourDB, repo: string, limit?: number): any[];

package/dist/storage/findings.js

@@ -0,0 +1,38 @@
+/**
+ * Findings CRUD operations for Rigour Brain SQLite storage.
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Insert findings from a scan report into SQLite.
+ */
+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);
+        }
+    });
+    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);
+}
+/**
+ * Get all deep analysis findings for a repo.
+ */
+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'
+        ORDER BY f.confidence DESC LIMIT ?
+    `);
+    return stmt.all(repo, limit);
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rigour Brain — SQLite storage layer.
+ * Everything in one file: ~/.rigour/rigour.db
+ */
+export { openDatabase, isSQLiteAvailable, RIGOUR_DIR, DB_PATH } from './db.js';
+export type { RigourDB } from './db.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/index.js

@@ -0,0 +1,8 @@
+/**
+ * Rigour Brain — SQLite storage layer.
+ * Everything in one file: ~/.rigour/rigour.db
+ */
+export { openDatabase, isSQLiteAvailable, RIGOUR_DIR, DB_PATH } from './db.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/patterns.d.ts

@@ -0,0 +1,35 @@
+import type { RigourDB } from './db.js';
+export interface PatternRecord {
+    id: string;
+    repo: string | null;
+    pattern: string;
+    description: string | null;
+    strength: number;
+    times_seen: number;
+    first_seen: number;
+    last_seen: number;
+    source: string;
+}
+/**
+ * Record or reinforce a pattern.
+ * 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;
+/**
+ * Decay patterns not seen in the last N days.
+ */
+export declare function decayPatterns(store: RigourDB, daysThreshold?: number): number;
+/**
+ * Get strong patterns for a repo (strength > threshold).
+ */
+export declare function getStrongPatterns(store: RigourDB, repo: string, threshold?: number): PatternRecord[];
+/**
+ * Get all patterns for a repo.
+ */
+export declare function getPatterns(store: RigourDB, repo: string): 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[];

package/dist/storage/patterns.js

@@ -0,0 +1,62 @@
+/**
+ * Pattern learning and reinforcement for Rigour Brain.
+ * Patterns grow in strength when seen repeatedly, decay when absent.
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Record or reinforce a pattern.
+ * If the pattern already exists for this repo, increase strength.
+ * Otherwise, create a new pattern.
+ */
+export 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);
+    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);
+    }
+    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);
+    }
+}
+/**
+ * Decay patterns not seen in the last N days.
+ */
+export 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);
+    // Prune dead patterns
+    store.db.prepare('DELETE FROM patterns WHERE strength < 0.1').run();
+    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);
+}
+/**
+ * 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);
+}
+/**
+ * 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);
+}

package/dist/storage/scans.d.ts

@@ -0,0 +1,42 @@
+import type { RigourDB } from './db.js';
+import type { Report } from '../types/index.js';
+export interface ScanRecord {
+    id: string;
+    repo: string;
+    commit_hash?: string;
+    timestamp: number;
+    ai_health_score?: number;
+    code_quality_score?: number;
+    overall_score?: number;
+    files_scanned?: number;
+    duration_ms?: number;
+    deep_tier?: string;
+    deep_model?: string;
+}
+/**
+ * Insert a scan record from a Rigour report.
+ */
+export declare function insertScan(store: RigourDB, repo: string, report: Report, meta?: {
+    commitHash?: string;
+    filesScanned?: number;
+    deepTier?: string;
+    deepModel?: string;
+}): string;
+/**
+ * Get recent scans for a repo (newest first).
+ */
+export declare function getRecentScans(store: RigourDB, repo: string, limit?: number): ScanRecord[];
+/**
+ * Get score trend for a repo.
+ */
+export declare function getScoreTrendFromDB(store: RigourDB, repo: string, limit?: number): {
+    scores: number[];
+    direction: 'improving' | 'degrading' | 'stable';
+};
+/**
+ * Get most common issue categories for a repo.
+ */
+export declare function getTopIssues(store: RigourDB, repo: string, limit?: number): {
+    category: string;
+    count: number;
+}[];

package/dist/storage/scans.js

@@ -0,0 +1,55 @@
+/**
+ * Scan CRUD operations for Rigour Brain SQLite storage.
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Insert a scan record from a Rigour report.
+ */
+export 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);
+    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);
+}
+/**
+ * Get score trend for a repo.
+ */
+export function getScoreTrendFromDB(store, repo, limit = 10) {
+    const scans = getRecentScans(store, repo, limit);
+    const scores = scans
+        .filter(s => s.overall_score != null)
+        .map(s => s.overall_score)
+        .reverse(); // oldest first
+    if (scores.length < 2)
+        return { scores, direction: 'stable' };
+    const recent = scores.slice(-3);
+    const avg = recent.reduce((a, b) => a + b, 0) / recent.length;
+    const older = scores.slice(0, -3);
+    const olderAvg = older.length > 0 ? older.reduce((a, b) => a + b, 0) / older.length : avg;
+    const direction = avg > olderAvg + 2 ? 'improving' : avg < olderAvg - 2 ? 'degrading' : 'stable';
+    return { scores, direction };
+}
+/**
+ * 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);
+}

package/dist/templates/universal-config.js

@@ -155,6 +155,25 @@ export const UNIVERSAL_CONFIG = {
             max_mocks_per_test: 5,
             ignore_patterns: [],
         },
+        deep: {
+            enabled: false,
+            pro: false,
+            provider: 'local',
+            threads: 4,
+            max_tokens: 512,
+            temperature: 0.1,
+            timeout_ms: 60000,
+            checks: {
+                solid: true,
+                dry: true,
+                design_patterns: true,
+                language_idioms: true,
+                error_handling: true,
+                test_quality: true,
+                architecture: true,
+                code_smells: true,
+            },
+        },
     },
     hooks: {
         enabled: false,