@rigour-labs/core 3.0.6 → 4.0.0

package/dist/inference/model-manager.d.ts

@@ -0,0 +1,26 @@
+import { type ModelTier, type ModelInfo } from './types.js';
+/**
+ * Check if a model is already downloaded and valid.
+ */
+export declare function isModelCached(tier: ModelTier): boolean;
+/**
+ * Get the path to a cached model.
+ */
+export declare function getModelPath(tier: ModelTier): string;
+/**
+ * Get model info for a tier.
+ */
+export declare function getModelInfo(tier: ModelTier): ModelInfo;
+/**
+ * Download a model from HuggingFace CDN.
+ * Calls onProgress with status updates.
+ */
+export declare function downloadModel(tier: ModelTier, onProgress?: (message: string, percent?: number) => void): Promise<string>;
+/**
+ * Ensure a model is available, downloading if needed.
+ */
+export declare function ensureModel(tier: ModelTier, onProgress?: (message: string, percent?: number) => void): Promise<string>;
+/**
+ * Get the models directory path.
+ */
+export declare function getModelsDir(): string;

package/dist/inference/model-manager.js

@@ -0,0 +1,106 @@
+/**
+ * Model Manager — handles downloading, caching, and verifying GGUF models.
+ * Models cached at ~/.rigour/models/
+ */
+import path from 'path';
+import fs from 'fs-extra';
+import { RIGOUR_DIR } from '../storage/db.js';
+import { MODELS } from './types.js';
+const MODELS_DIR = path.join(RIGOUR_DIR, 'models');
+/**
+ * Check if a model is already downloaded and valid.
+ */
+export function isModelCached(tier) {
+    const model = MODELS[tier];
+    const modelPath = path.join(MODELS_DIR, model.filename);
+    if (!fs.existsSync(modelPath))
+        return false;
+    // Basic size check (within 10% tolerance)
+    const stat = fs.statSync(modelPath);
+    const tolerance = model.sizeBytes * 0.1;
+    return stat.size > model.sizeBytes - tolerance;
+}
+/**
+ * Get the path to a cached model.
+ */
+export function getModelPath(tier) {
+    return path.join(MODELS_DIR, MODELS[tier].filename);
+}
+/**
+ * Get model info for a tier.
+ */
+export function getModelInfo(tier) {
+    return MODELS[tier];
+}
+/**
+ * Download a model from HuggingFace CDN.
+ * Calls onProgress with status updates.
+ */
+export async function downloadModel(tier, onProgress) {
+    const model = MODELS[tier];
+    const destPath = path.join(MODELS_DIR, model.filename);
+    const tempPath = destPath + '.download';
+    fs.ensureDirSync(MODELS_DIR);
+    // Already cached
+    if (isModelCached(tier)) {
+        onProgress?.(`Model ${model.name} already cached`, 100);
+        return destPath;
+    }
+    onProgress?.(`Downloading ${model.name} (${model.sizeHuman})...`, 0);
+    try {
+        const response = await fetch(model.url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const writeStream = fs.createWriteStream(tempPath);
+        let downloaded = 0;
+        let lastProgressPercent = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            writeStream.write(Buffer.from(value));
+            downloaded += value.length;
+            if (contentLength > 0) {
+                const percent = Math.round((downloaded / contentLength) * 100);
+                if (percent >= lastProgressPercent + 5) { // Report every 5%
+                    lastProgressPercent = percent;
+                    onProgress?.(`Downloading ${model.name}: ${percent}%`, percent);
+                }
+            }
+        }
+        writeStream.end();
+        await new Promise((resolve, reject) => {
+            writeStream.on('finish', resolve);
+            writeStream.on('error', reject);
+        });
+        // Atomic rename
+        fs.renameSync(tempPath, destPath);
+        onProgress?.(`Model ${model.name} ready`, 100);
+        return destPath;
+    }
+    catch (error) {
+        // Clean up temp file on failure
+        fs.removeSync(tempPath);
+        throw error;
+    }
+}
+/**
+ * Ensure a model is available, downloading if needed.
+ */
+export async function ensureModel(tier, onProgress) {
+    if (isModelCached(tier)) {
+        return getModelPath(tier);
+    }
+    return downloadModel(tier, onProgress);
+}
+/**
+ * Get the models directory path.
+ */
+export function getModelsDir() {
+    return MODELS_DIR;
+}

package/dist/inference/sidecar-provider.d.ts

@@ -0,0 +1,15 @@
+import type { InferenceProvider, InferenceOptions, ModelTier } from './types.js';
+export declare class SidecarProvider implements InferenceProvider {
+    readonly name = "sidecar";
+    private binaryPath;
+    private modelPath;
+    private tier;
+    private threads;
+    constructor(tier?: ModelTier, threads?: number);
+    isAvailable(): Promise<boolean>;
+    setup(onProgress?: (message: string) => void): Promise<void>;
+    analyze(prompt: string, options?: InferenceOptions): Promise<string>;
+    dispose(): void;
+    private getPlatformKey;
+    private resolveBinaryPath;
+}

package/dist/inference/sidecar-provider.js

@@ -0,0 +1,153 @@
+/**
+ * Sidecar Binary Provider — runs inference via pre-compiled llama.cpp binary.
+ * Binary ships as @rigour/brain-{platform} optional npm dependency.
+ * Falls back to PATH lookup for development/manual installs.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { ensureModel, isModelCached, getModelInfo } from './model-manager.js';
+const execFileAsync = promisify(execFile);
+/** Platform → npm package mapping */
+const PLATFORM_PACKAGES = {
+    'darwin-arm64': '@rigour/brain-darwin-arm64',
+    'darwin-x64': '@rigour/brain-darwin-x64',
+    'linux-x64': '@rigour/brain-linux-x64',
+    'linux-arm64': '@rigour/brain-linux-arm64',
+    'win32-x64': '@rigour/brain-win-x64',
+};
+export class SidecarProvider {
+    name = 'sidecar';
+    binaryPath = null;
+    modelPath = null;
+    tier;
+    threads;
+    constructor(tier = 'deep', threads = 4) {
+        this.tier = tier;
+        this.threads = threads;
+    }
+    async isAvailable() {
+        const binary = await this.resolveBinaryPath();
+        return binary !== null;
+    }
+    async setup(onProgress) {
+        // 1. Check/resolve binary
+        this.binaryPath = await this.resolveBinaryPath();
+        if (this.binaryPath) {
+            onProgress?.('✓ Inference engine ready');
+        }
+        else {
+            onProgress?.('⚠ Inference engine not found. Install @rigour/brain-* or add llama-cli to PATH');
+            throw new Error('Sidecar binary not found. Run: npm install @rigour/brain-' + this.getPlatformKey());
+        }
+        // 2. Ensure model is downloaded
+        if (!isModelCached(this.tier)) {
+            const modelInfo = getModelInfo(this.tier);
+            onProgress?.(`⬇ Downloading analysis model (${modelInfo.sizeHuman})...`);
+        }
+        this.modelPath = await ensureModel(this.tier, (msg, percent) => {
+            if (percent !== undefined && percent < 100) {
+                onProgress?.(`  ${msg}`);
+            }
+        });
+        onProgress?.('✓ Model ready');
+    }
+    async analyze(prompt, options) {
+        if (!this.binaryPath || !this.modelPath) {
+            throw new Error('Provider not set up. Call setup() first.');
+        }
+        const args = [
+            '--model', this.modelPath,
+            '--prompt', prompt,
+            '--n-predict', String(options?.maxTokens || 512),
+            '--threads', String(this.threads),
+            '--temp', String(options?.temperature || 0.1),
+            '--no-display-prompt', // Don't echo the prompt
+            '--log-disable', // Suppress llama.cpp logging
+        ];
+        // JSON grammar constraint if available
+        if (options?.jsonMode) {
+            args.push('--json');
+        }
+        try {
+            const { stdout, stderr } = await execFileAsync(this.binaryPath, args, {
+                timeout: options?.timeout || 60000,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+                env: { ...process.env, LLAMA_LOG_DISABLE: '1' },
+            });
+            // llama.cpp sometimes outputs to stderr for diagnostics — ignore
+            return stdout.trim();
+        }
+        catch (error) {
+            if (error.killed) {
+                throw new Error(`Inference timed out after ${(options?.timeout || 60000) / 1000}s`);
+            }
+            throw new Error(`Inference failed: ${error.message}`);
+        }
+    }
+    dispose() {
+        // No persistent process to clean up
+        this.binaryPath = null;
+        this.modelPath = null;
+    }
+    getPlatformKey() {
+        return `${os.platform()}-${os.arch()}`;
+    }
+    async resolveBinaryPath() {
+        const platformKey = this.getPlatformKey();
+        // Strategy 1: Check @rigour/brain-{platform} optional dependency
+        const packageName = PLATFORM_PACKAGES[platformKey];
+        if (packageName) {
+            try {
+                // Try to resolve from node_modules
+                const possiblePaths = [
+                    // From rigour-core node_modules
+                    path.join(__dirname, '..', '..', '..', 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain'),
+                    // From global node_modules
+                    path.join(os.homedir(), '.npm-global', 'lib', 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain'),
+                ];
+                for (const p of possiblePaths) {
+                    const binPath = os.platform() === 'win32' ? p + '.exe' : p;
+                    if (await fs.pathExists(binPath)) {
+                        return binPath;
+                    }
+                }
+            }
+            catch {
+                // Package not installed
+            }
+        }
+        // Strategy 2: Check ~/.rigour/bin/
+        const localBin = path.join(os.homedir(), '.rigour', 'bin', 'rigour-brain');
+        const localBinPath = os.platform() === 'win32' ? localBin + '.exe' : localBin;
+        if (await fs.pathExists(localBinPath)) {
+            return localBinPath;
+        }
+        // Strategy 3: Check PATH for llama-cli (llama.cpp CLI)
+        try {
+            const { stdout } = await execFileAsync('which', ['llama-cli']);
+            const llamaPath = stdout.trim();
+            if (llamaPath && await fs.pathExists(llamaPath)) {
+                return llamaPath;
+            }
+        }
+        catch {
+            // Not in PATH
+        }
+        // Strategy 4: Check for llama.cpp server-style binary names
+        const altNames = ['llama-cli', 'llama', 'main'];
+        for (const name of altNames) {
+            try {
+                const { stdout } = await execFileAsync('which', [name]);
+                if (stdout.trim())
+                    return stdout.trim();
+            }
+            catch {
+                // Continue
+            }
+        }
+        return null;
+    }
+}

package/dist/inference/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Inference provider interface for Rigour deep analysis.
+ * Supports sidecar binary (local llama.cpp), cloud APIs (Claude/OpenAI).
+ */
+import type { Severity } from '../types/index.js';
+/**
+ * Abstract inference provider — all backends implement this.
+ */
+export interface InferenceProvider {
+    /** Provider name for logging/reporting */
+    readonly name: string;
+    /** Check if this provider is available (binary exists, API key valid, etc.) */
+    isAvailable(): Promise<boolean>;
+    /**
+     * One-time setup: download model, verify binary, etc.
+     * Should show progress to user via callback.
+     */
+    setup(onProgress?: (message: string) => void): Promise<void>;
+    /**
+     * Run inference on a prompt. Returns raw text response.
+     * Provider handles tokenization, temperature, etc.
+     */
+    analyze(prompt: string, options?: InferenceOptions): Promise<string>;
+    /** Clean up resources (kill process, close connection) */
+    dispose(): void;
+}
+export interface InferenceOptions {
+    maxTokens?: number;
+    temperature?: number;
+    timeout?: number;
+    jsonMode?: boolean;
+}
+/**
+ * A single finding from deep LLM analysis.
+ */
+export interface DeepFinding {
+    /** Category like 'srp_violation', 'god_function', 'dry_violation' */
+    category: string;
+    /** Severity level */
+    severity: Severity;
+    /** Relative file path */
+    file: string;
+    /** Line number (if available) */
+    line?: number;
+    /** Human-readable description of the issue */
+    description: string;
+    /** Actionable suggestion for how to fix */
+    suggestion: string;
+    /** LLM confidence score 0.0-1.0 */
+    confidence: number;
+}
+/**
+ * Result of a deep analysis batch.
+ */
+export interface DeepAnalysisResult {
+    findings: DeepFinding[];
+    model: string;
+    tokensUsed?: number;
+    durationMs: number;
+}
+/**
+ * Available model tiers.
+ */
+export type ModelTier = 'deep' | 'pro';
+/**
+ * Model info for download/caching.
+ */
+export interface ModelInfo {
+    tier: ModelTier;
+    name: string;
+    filename: string;
+    url: string;
+    sizeBytes: number;
+    sizeHuman: string;
+}
+/** All supported model definitions */
+export declare const MODELS: Record<ModelTier, ModelInfo>;

package/dist/inference/types.js

@@ -0,0 +1,19 @@
+/** All supported model definitions */
+export const MODELS = {
+    deep: {
+        tier: 'deep',
+        name: 'Qwen2.5-Coder-0.5B-Instruct',
+        filename: 'qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
+        url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
+        sizeBytes: 350_000_000,
+        sizeHuman: '350MB',
+    },
+    pro: {
+        tier: 'pro',
+        name: 'Qwen2.5-Coder-1.5B-Instruct',
+        filename: 'qwen2.5-coder-1.5b-instruct-q4_k_m.gguf',
+        url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-1.5b-instruct-q4_k_m.gguf',
+        sizeBytes: 900_000_000,
+        sizeHuman: '900MB',
+    },
+};

package/dist/settings.d.ts

@@ -0,0 +1,104 @@
+/**
+ * RigourSettings Interface
+ * Defines the schema for ~/.rigour/settings.json global user configuration
+ */
+export interface RigourSettings {
+    providers?: {
+        anthropic?: string;
+        openai?: string;
+        groq?: string;
+        deepseek?: string;
+        mistral?: string;
+        together?: string;
+        gemini?: string;
+        ollama?: string;
+        [key: string]: string | undefined;
+    };
+    deep?: {
+        defaultProvider?: string;
+        defaultModel?: string;
+        apiBaseUrl?: string;
+        maxTokens?: number;
+        temperature?: number;
+    };
+    agents?: {
+        [agentName: string]: {
+            model?: string;
+            provider?: string;
+            fallback?: string;
+        };
+    };
+    cli?: {
+        defaultPreset?: string;
+        colorOutput?: boolean;
+        verboseOutput?: boolean;
+    };
+}
+/**
+ * Resolved deep options from CLI flags merged with settings.json
+ */
+export interface ResolvedDeepOptions {
+    apiKey?: string;
+    provider?: string;
+    apiBaseUrl?: string;
+    modelName?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * CLI options that may override settings
+ */
+export interface CLIDeepOptions {
+    apiKey?: string;
+    provider?: string;
+    apiBaseUrl?: string;
+    modelName?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/**
+ * Get the settings file path: ~/.rigour/settings.json
+ */
+export declare function getSettingsPath(): string;
+/**
+ * Load settings from ~/.rigour/settings.json
+ * Returns empty object if file not found or is malformed
+ */
+export declare function loadSettings(): RigourSettings;
+/**
+ * Save settings to ~/.rigour/settings.json
+ */
+export declare function saveSettings(settings: RigourSettings): void;
+/**
+ * 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 declare function resolveDeepOptions(cliOptions: CLIDeepOptions): ResolvedDeepOptions;
+/**
+ * Get a specific provider's API key from settings
+ * Supports both normalized names (claude -> anthropic) and exact keys
+ */
+export declare function getProviderKey(providerName: string): string | undefined;
+/**
+ * Get agent configuration from settings
+ */
+export declare function getAgentConfig(agentName: string): {
+    model?: string;
+    provider?: string;
+    fallback?: string;
+} | undefined;
+/**
+ * Get CLI preferences from settings
+ */
+export declare function getCliPreferences(): RigourSettings['cli'];
+/**
+ * Update a specific provider key in settings
+ */
+export declare function updateProviderKey(provider: string, apiKey: string): void;
+/**
+ * Remove a provider key from settings
+ */
+export declare function removeProviderKey(provider: string): void;

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);
+    }
+}