@rigour-labs/core 3.0.5 → 4.0.0

package/dist/settings.js

@@ -0,0 +1,186 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+import { Logger } from './utils/logger.js';
+/**
+ * Get the settings file path: ~/.rigour/settings.json
+ */
+export function getSettingsPath() {
+    const homeDir = os.homedir();
+    return path.join(homeDir, '.rigour', 'settings.json');
+}
+/**
+ * Load settings from ~/.rigour/settings.json
+ * Returns empty object if file not found or is malformed
+ */
+export function loadSettings() {
+    const settingsPath = getSettingsPath();
+    try {
+        if (!fs.existsSync(settingsPath)) {
+            Logger.debug(`Settings file not found at ${settingsPath}`);
+            return {};
+        }
+        const content = fs.readFileSync(settingsPath, 'utf-8');
+        const settings = JSON.parse(content);
+        Logger.debug(`Settings loaded from ${settingsPath}`);
+        return settings;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            Logger.warn(`Malformed JSON in ${settingsPath}: ${error.message}`);
+        }
+        else if (error instanceof Error) {
+            Logger.warn(`Failed to read settings from ${settingsPath}: ${error.message}`);
+        }
+        else {
+            Logger.warn(`Failed to read settings from ${settingsPath}`);
+        }
+        return {};
+    }
+}
+/**
+ * Save settings to ~/.rigour/settings.json
+ */
+export function saveSettings(settings) {
+    const settingsPath = getSettingsPath();
+    const settingsDir = path.dirname(settingsPath);
+    try {
+        // Ensure directory exists
+        fs.ensureDirSync(settingsDir);
+        // Write with pretty formatting (2-space indent)
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+        Logger.debug(`Settings saved to ${settingsPath}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Logger.error(`Failed to save settings to ${settingsPath}: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Map common provider names to their settings.json key
+ * This allows --provider claude to resolve to anthropic API key
+ */
+function normalizeProviderName(provider) {
+    const mapping = {
+        'claude': 'anthropic',
+        'anthropic': 'anthropic',
+        'gpt': 'openai',
+        'openai': 'openai',
+        'groq': 'groq',
+        'deepseek': 'deepseek',
+        'mistral': 'mistral',
+        'together': 'together',
+        'gemini': 'gemini',
+        'google': 'gemini',
+        'ollama': 'ollama',
+    };
+    return mapping[provider.toLowerCase()] || provider;
+}
+/**
+ * Resolve deep analysis options by merging CLI flags with settings.json
+ * CLI flags always take precedence over settings.json values
+ *
+ * @param cliOptions CLI flags provided by user
+ * @returns Merged options with CLI taking precedence
+ */
+export function resolveDeepOptions(cliOptions) {
+    const settings = loadSettings();
+    const result = {};
+    // 1. Start with settings.json defaults
+    if (settings.deep?.apiBaseUrl) {
+        result.apiBaseUrl = settings.deep.apiBaseUrl;
+    }
+    if (settings.deep?.maxTokens) {
+        result.maxTokens = settings.deep.maxTokens;
+    }
+    if (settings.deep?.temperature) {
+        result.temperature = settings.deep.temperature;
+    }
+    // 2. Apply provider selection (settings or default)
+    let selectedProvider = settings.deep?.defaultProvider || 'anthropic';
+    if (cliOptions.provider) {
+        selectedProvider = cliOptions.provider;
+    }
+    result.provider = selectedProvider;
+    // 3. Apply model selection (settings or default)
+    if (settings.deep?.defaultModel) {
+        result.modelName = settings.deep.defaultModel;
+    }
+    if (cliOptions.modelName) {
+        result.modelName = cliOptions.modelName;
+    }
+    // 4. Resolve API key
+    // CLI flag takes highest precedence
+    if (cliOptions.apiKey) {
+        result.apiKey = cliOptions.apiKey;
+    }
+    else if (settings.providers) {
+        // Otherwise look up provider key in settings.providers
+        const normalizedProvider = normalizeProviderName(selectedProvider);
+        const apiKey = settings.providers[normalizedProvider];
+        if (apiKey) {
+            result.apiKey = apiKey;
+        }
+    }
+    // 5. Override with CLI flags (highest priority)
+    if (cliOptions.apiBaseUrl) {
+        result.apiBaseUrl = cliOptions.apiBaseUrl;
+    }
+    if (cliOptions.maxTokens) {
+        result.maxTokens = cliOptions.maxTokens;
+    }
+    if (cliOptions.temperature) {
+        result.temperature = cliOptions.temperature;
+    }
+    return result;
+}
+/**
+ * Get a specific provider's API key from settings
+ * Supports both normalized names (claude -> anthropic) and exact keys
+ */
+export function getProviderKey(providerName) {
+    const settings = loadSettings();
+    if (!settings.providers) {
+        return undefined;
+    }
+    const normalized = normalizeProviderName(providerName);
+    return settings.providers[normalized];
+}
+/**
+ * Get agent configuration from settings
+ */
+export function getAgentConfig(agentName) {
+    const settings = loadSettings();
+    return settings.agents?.[agentName];
+}
+/**
+ * Get CLI preferences from settings
+ */
+export function getCliPreferences() {
+    const settings = loadSettings();
+    return settings.cli || {};
+}
+/**
+ * Update a specific provider key in settings
+ */
+export function updateProviderKey(provider, apiKey) {
+    const settings = loadSettings();
+    const normalized = normalizeProviderName(provider);
+    if (!settings.providers) {
+        settings.providers = {};
+    }
+    settings.providers[normalized] = apiKey;
+    saveSettings(settings);
+}
+/**
+ * Remove a provider key from settings
+ */
+export function removeProviderKey(provider) {
+    const settings = loadSettings();
+    const normalized = normalizeProviderName(provider);
+    if (settings.providers && settings.providers[normalized]) {
+        delete settings.providers[normalized];
+        saveSettings(settings);
+    }
+}

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/index.d.ts

@@ -1,16 +1,12 @@
-import { Config, Commands, Gates } from '../types/index.js';
-export interface Template {
-    name: string;
-    markers: string[];
-    config: {
-        preset?: string;
-        paradigm?: string;
-        commands?: Partial<Commands>;
-        gates?: Partial<Gates>;
-        planned?: string[];
-        ignore?: string[];
-    };
-}
-export declare const TEMPLATES: Template[];
-export declare const PARADIGM_TEMPLATES: Template[];
-export declare const UNIVERSAL_CONFIG: Config;
+/**
+ * Templates — Public Barrel
+ *
+ * Re-exports from sub-modules so that existing importers keep working.
+ * - Preset definitions  →  ./presets.ts
+ * - Paradigm templates  →  ./paradigms.ts
+ * - Universal config    →  ./universal-config.ts
+ */
+export type { Template } from './presets.js';
+export { TEMPLATES } from './presets.js';
+export { PARADIGM_TEMPLATES } from './paradigms.js';
+export { UNIVERSAL_CONFIG } from './universal-config.js';