@rigour-labs/core 3.0.5 → 4.0.0

package/dist/inference/index.js

@@ -0,0 +1,23 @@
+export { MODELS } from './types.js';
+export { SidecarProvider } from './sidecar-provider.js';
+export { CloudProvider } from './cloud-provider.js';
+export { ensureModel, isModelCached, getModelPath, getModelInfo, downloadModel, getModelsDir } from './model-manager.js';
+import { SidecarProvider } from './sidecar-provider.js';
+import { CloudProvider } from './cloud-provider.js';
+/**
+ * Create the appropriate inference provider based on options.
+ *
+ * - No API key → SidecarProvider (local llama.cpp binary)
+ * - API key + any provider → CloudProvider (no restrictions, user's key, user's choice)
+ */
+export function createProvider(options) {
+    if (options.apiKey && options.provider && options.provider !== 'local') {
+        return new CloudProvider(options.provider, options.apiKey, {
+            baseUrl: options.apiBaseUrl,
+            modelName: options.modelName,
+        });
+    }
+    // Default: local sidecar
+    const tier = options.pro ? 'pro' : 'deep';
+    return new SidecarProvider(tier);
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Pattern Indexer — Pure Utility Helpers
+ *
+ * Standalone pure functions shared across language extractors and the main
+ * indexer class. No class state is referenced here.
+ */
+import type { PatternEntry, PatternType } from './types.js';
+/** SHA-256 of `content`, truncated to 16 hex chars. */
+export declare function hashContent(content: string): string;
+export interface PatternEntryParams {
+    type: PatternType;
+    name: string;
+    file: string;
+    line: number;
+    endLine: number;
+    signature: string;
+    description: string;
+    keywords: string[];
+    content: string;
+    exported: boolean;
+}
+/** Build a complete PatternEntry from constituent parts. */
+export declare function createPatternEntry(params: PatternEntryParams): PatternEntry;
+/** Split camelCase / PascalCase / snake_case names into unique lowercase words. */
+export declare function extractKeywords(name: string): string[];
+/** Walk forward from `startIndex` and return the line index after the closing brace. */
+export declare function findBraceBlockEnd(lines: string[], startIndex: number): number;
+/** Return the source lines for a brace-delimited block starting at `startIndex`. */
+export declare function getBraceBlockContent(lines: string[], startIndex: number): string;
+/**
+ * Collect consecutive `//` comments immediately above `startIndex` (Go / Rust style).
+ * Walks upward until a non-comment line is encountered.
+ */
+export declare function getCOMLineComments(lines: string[], startIndex: number): string;
+/**
+ * Extract the first JavaDoc `/** … *\/` comment block found above `startIndex`.
+ */
+export declare function getJavaDoc(lines: string[], startIndex: number): string;

package/dist/pattern-index/indexer-helpers.js

@@ -0,0 +1,111 @@
+/**
+ * Pattern Indexer — Pure Utility Helpers
+ *
+ * Standalone pure functions shared across language extractors and the main
+ * indexer class. No class state is referenced here.
+ */
+import { createHash } from 'crypto';
+// ---------------------------------------------------------------------------
+// Hashing / ID generation
+// ---------------------------------------------------------------------------
+/** SHA-256 of `content`, truncated to 16 hex chars. */
+export function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+/** Build a complete PatternEntry from constituent parts. */
+export function createPatternEntry(params) {
+    const id = hashContent(`${params.file}:${params.name}:${params.line}`);
+    const hash = hashContent(params.content);
+    return {
+        id,
+        type: params.type,
+        name: params.name,
+        file: params.file,
+        line: params.line,
+        endLine: params.endLine,
+        signature: params.signature,
+        description: params.description,
+        keywords: params.keywords,
+        hash,
+        exported: params.exported,
+        usageCount: 0,
+        indexedAt: new Date().toISOString(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Keyword extraction
+// ---------------------------------------------------------------------------
+/** Split camelCase / PascalCase / snake_case names into unique lowercase words. */
+export function extractKeywords(name) {
+    const words = name
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/[\s_-]+/)
+        .filter(w => w.length > 1);
+    return [...new Set(words)];
+}
+// ---------------------------------------------------------------------------
+// Brace-based block helpers (Go, Rust, JVM, C-style)
+// ---------------------------------------------------------------------------
+/** Walk forward from `startIndex` and return the line index after the closing brace. */
+export function findBraceBlockEnd(lines, startIndex) {
+    let braceCount = 0;
+    let started = false;
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes('{')) {
+            braceCount += (line.match(/\{/g) || []).length;
+            started = true;
+        }
+        if (line.includes('}')) {
+            braceCount -= (line.match(/\}/g) || []).length;
+        }
+        if (started && braceCount === 0)
+            return i + 1;
+    }
+    return lines.length;
+}
+/** Return the source lines for a brace-delimited block starting at `startIndex`. */
+export function getBraceBlockContent(lines, startIndex) {
+    const end = findBraceBlockEnd(lines, startIndex);
+    return lines.slice(startIndex, end).join('\n');
+}
+// ---------------------------------------------------------------------------
+// Comment extraction helpers
+// ---------------------------------------------------------------------------
+/**
+ * Collect consecutive `//` comments immediately above `startIndex` (Go / Rust style).
+ * Walks upward until a non-comment line is encountered.
+ */
+export function getCOMLineComments(lines, startIndex) {
+    const comments = [];
+    for (let i = startIndex; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.startsWith('//')) {
+            comments.unshift(line.replace('//', '').trim());
+        }
+        else {
+            break;
+        }
+    }
+    return comments.join(' ');
+}
+/**
+ * Extract the first JavaDoc `/** … *\/` comment block found above `startIndex`.
+ */
+export function getJavaDoc(lines, startIndex) {
+    const comments = [];
+    let inDoc = false;
+    for (let i = startIndex; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line.endsWith('*/'))
+            inDoc = true;
+        if (inDoc) {
+            comments.unshift(line.replace('/**', '').replace('*/', '').replace(/^\*/, '').trim());
+        }
+        if (line.startsWith('/**'))
+            break;
+    }
+    return comments.join(' ');
+}

package/dist/pattern-index/indexer-lang.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pattern Indexer — Language-Specific Extractors
+ *
+ * Standalone extraction functions for Go, Rust, JVM (Java/Kotlin/C#),
+ * Python, and a generic C-style fallback. Each function is pure and
+ * receives all required context as parameters.
+ */
+import type { PatternEntry } from './types.js';
+export declare function extractGoPatterns(filePath: string, content: string, rootDir: string): PatternEntry[];
+export declare function extractRustPatterns(filePath: string, content: string, rootDir: string): PatternEntry[];
+export declare function extractJVMStylePatterns(filePath: string, content: string, rootDir: string): PatternEntry[];
+export declare function extractGenericCPatterns(_filePath: string, _content: string): PatternEntry[];
+export declare function extractPythonPatterns(filePath: string, content: string, rootDir: string, minNameLength: number): PatternEntry[];