ruvector 0.2.16 → 0.2.18

package/dist/core/core/onnx-embedder.d.ts

@@ -1,104 +0,0 @@
-/**
- * ONNX WASM Embedder - Semantic embeddings for hooks
- *
- * Provides real transformer-based embeddings using all-MiniLM-L6-v2
- * running in pure WASM (no native dependencies).
- *
- * Uses bundled ONNX WASM files from src/core/onnx/
- *
- * Features:
- * - 384-dimensional semantic embeddings
- * - Real semantic understanding (not hash-based)
- * - Cached model loading (downloads from HuggingFace on first use)
- * - Batch embedding support
- * - Optional parallel workers for 3.8x batch speedup
- */
-declare global {
-    var __ruvector_require: NodeRequire | undefined;
-}
-export interface OnnxEmbedderConfig {
-    modelId?: string;
-    maxLength?: number;
-    normalize?: boolean;
-    cacheDir?: string;
-    /**
-     * Enable parallel workers for batch operations
-     * - 'auto' (default): Enable for long-running processes, skip for CLI
-     * - true: Always enable workers
-     * - false: Never use workers
-     */
-    enableParallel?: boolean | 'auto';
-    /** Number of worker threads (default: CPU cores - 1) */
-    numWorkers?: number;
-    /** Minimum batch size to use parallel processing (default: 4) */
-    parallelThreshold?: number;
-}
-export interface EmbeddingResult {
-    embedding: number[];
-    dimension: number;
-    timeMs: number;
-}
-export interface SimilarityResult {
-    similarity: number;
-    timeMs: number;
-}
-/**
- * Check if ONNX embedder is available (bundled files exist)
- */
-export declare function isOnnxAvailable(): boolean;
-/**
- * Initialize the ONNX embedder (downloads model if needed)
- */
-export declare function initOnnxEmbedder(config?: OnnxEmbedderConfig): Promise<boolean>;
-/**
- * Generate embedding for text
- */
-export declare function embed(text: string): Promise<EmbeddingResult>;
-/**
- * Generate embeddings for multiple texts
- * Uses parallel workers automatically for batches >= parallelThreshold
- */
-export declare function embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
-/**
- * Calculate cosine similarity between two texts
- */
-export declare function similarity(text1: string, text2: string): Promise<SimilarityResult>;
-/**
- * Calculate cosine similarity between two embeddings
- */
-export declare function cosineSimilarity(a: number[], b: number[]): number;
-/**
- * Get embedding dimension
- */
-export declare function getDimension(): number;
-/**
- * Check if embedder is ready
- */
-export declare function isReady(): boolean;
-/**
- * Get embedder stats including SIMD and parallel capabilities
- */
-export declare function getStats(): {
-    ready: boolean;
-    dimension: number;
-    model: string;
-    simd: boolean;
-    parallel: boolean;
-    parallelWorkers: number;
-    parallelThreshold: number;
-};
-/**
- * Shutdown parallel workers (call on exit)
- */
-export declare function shutdown(): Promise<void>;
-export declare class OnnxEmbedder {
-    private config;
-    constructor(config?: OnnxEmbedderConfig);
-    init(): Promise<boolean>;
-    embed(text: string): Promise<number[]>;
-    embedBatch(texts: string[]): Promise<number[][]>;
-    similarity(text1: string, text2: string): Promise<number>;
-    get dimension(): number;
-    get ready(): boolean;
-}
-export default OnnxEmbedder;

package/dist/core/core/onnx-embedder.js

@@ -1,410 +0,0 @@
-"use strict";
-/**
- * ONNX WASM Embedder - Semantic embeddings for hooks
- *
- * Provides real transformer-based embeddings using all-MiniLM-L6-v2
- * running in pure WASM (no native dependencies).
- *
- * Uses bundled ONNX WASM files from src/core/onnx/
- *
- * Features:
- * - 384-dimensional semantic embeddings
- * - Real semantic understanding (not hash-based)
- * - Cached model loading (downloads from HuggingFace on first use)
- * - Batch embedding support
- * - Optional parallel workers for 3.8x batch speedup
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnnxEmbedder = void 0;
-exports.isOnnxAvailable = isOnnxAvailable;
-exports.initOnnxEmbedder = initOnnxEmbedder;
-exports.embed = embed;
-exports.embedBatch = embedBatch;
-exports.similarity = similarity;
-exports.cosineSimilarity = cosineSimilarity;
-exports.getDimension = getDimension;
-exports.isReady = isReady;
-exports.getStats = getStats;
-exports.shutdown = shutdown;
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const url_1 = require("url");
-const module_1 = require("module");
-// Set up ESM-compatible require for WASM module (fixes Windows/ESM compatibility)
-// The WASM bindings use module.require for Node.js crypto, this provides a fallback
-if (typeof globalThis !== 'undefined' && !globalThis.__ruvector_require) {
-    try {
-        // In ESM context, use createRequire with __filename
-        globalThis.__ruvector_require = (0, module_1.createRequire)(__filename);
-    }
-    catch {
-        // Fallback: require should be available in CommonJS
-        try {
-            globalThis.__ruvector_require = require;
-        }
-        catch {
-            // Neither available - WASM will fall back to crypto.getRandomValues
-        }
-    }
-}
-// Force native dynamic import (avoids TypeScript transpiling to require)
-// eslint-disable-next-line @typescript-eslint/no-implied-eval
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-// Capability detection
-let simdAvailable = false;
-let parallelAvailable = false;
-// Lazy-loaded module state
-let wasmModule = null;
-let embedder = null;
-let parallelEmbedder = null;
-let loadError = null;
-let loadPromise = null;
-let isInitialized = false;
-let parallelEnabled = false;
-let parallelThreshold = 4;
-// Default model
-const DEFAULT_MODEL = 'all-MiniLM-L6-v2';
-/**
- * Check if ONNX embedder is available (bundled files exist)
- */
-function isOnnxAvailable() {
-    try {
-        const pkgPath = path.join(__dirname, 'onnx', 'pkg', 'ruvector_onnx_embeddings_wasm.js');
-        return fs.existsSync(pkgPath);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if parallel workers are available (npm package installed)
- */
-async function detectParallelAvailable() {
-    try {
-        await dynamicImport('ruvector-onnx-embeddings-wasm/parallel');
-        parallelAvailable = true;
-        return true;
-    }
-    catch {
-        parallelAvailable = false;
-        return false;
-    }
-}
-/**
- * Check if SIMD is available (from WASM module)
- */
-function detectSimd() {
-    try {
-        if (wasmModule && typeof wasmModule.simd_available === 'function') {
-            simdAvailable = wasmModule.simd_available();
-            return simdAvailable;
-        }
-    }
-    catch { }
-    return false;
-}
-/**
- * Try to load ParallelEmbedder from npm package (optional)
- */
-async function tryInitParallel(config) {
-    // Skip if explicitly disabled
-    if (config.enableParallel === false)
-        return false;
-    // For 'auto' or true, try to initialize
-    try {
-        const parallelModule = await dynamicImport('ruvector-onnx-embeddings-wasm/parallel');
-        const { ParallelEmbedder } = parallelModule;
-        parallelEmbedder = new ParallelEmbedder({
-            numWorkers: config.numWorkers,
-        });
-        await parallelEmbedder.init(config.modelId || DEFAULT_MODEL);
-        parallelThreshold = config.parallelThreshold || 4;
-        parallelEnabled = true;
-        parallelAvailable = true;
-        console.error(`Parallel embedder ready: ${parallelEmbedder.numWorkers} workers, SIMD: ${simdAvailable}`);
-        return true;
-    }
-    catch (e) {
-        parallelAvailable = false;
-        if (config.enableParallel === true) {
-            // Only warn if explicitly requested
-            console.error(`Parallel embedder not available: ${e.message}`);
-        }
-        return false;
-    }
-}
-/**
- * Initialize the ONNX embedder (downloads model if needed)
- */
-async function initOnnxEmbedder(config = {}) {
-    if (isInitialized)
-        return true;
-    if (loadError)
-        throw loadError;
-    if (loadPromise) {
-        await loadPromise;
-        return isInitialized;
-    }
-    loadPromise = (async () => {
-        try {
-            // Paths to bundled ONNX files
-            const pkgPath = path.join(__dirname, 'onnx', 'pkg', 'ruvector_onnx_embeddings_wasm.js');
-            const loaderPath = path.join(__dirname, 'onnx', 'loader.js');
-            if (!fs.existsSync(pkgPath)) {
-                throw new Error('ONNX WASM files not bundled. The onnx/ directory is missing.');
-            }
-            // Convert paths to file:// URLs for cross-platform ESM compatibility (Windows fix)
-            const pkgUrl = (0, url_1.pathToFileURL)(pkgPath).href;
-            const loaderUrl = (0, url_1.pathToFileURL)(loaderPath).href;
-            // Dynamic import of bundled modules using file:// URLs
-            wasmModule = await dynamicImport(pkgUrl);
-            // Initialize WASM module (loads the .wasm file)
-            const wasmPath = path.join(__dirname, 'onnx', 'pkg', 'ruvector_onnx_embeddings_wasm_bg.wasm');
-            if (wasmModule.default && typeof wasmModule.default === 'function') {
-                // For bundler-style initialization, pass the wasm buffer
-                const wasmBytes = fs.readFileSync(wasmPath);
-                await wasmModule.default(wasmBytes);
-            }
-            const loaderModule = await dynamicImport(loaderUrl);
-            const { ModelLoader } = loaderModule;
-            // Create model loader with caching
-            const modelLoader = new ModelLoader({
-                cache: true,
-                cacheDir: config.cacheDir || path.join(process.env.HOME || '/tmp', '.ruvector', 'models'),
-            });
-            // Load model (downloads from HuggingFace on first use)
-            const modelId = config.modelId || DEFAULT_MODEL;
-            console.error(`Loading ONNX model: ${modelId}...`);
-            const { modelBytes, tokenizerJson, config: modelConfig } = await modelLoader.loadModel(modelId);
-            // Create embedder with config
-            const embedderConfig = new wasmModule.WasmEmbedderConfig()
-                .setMaxLength(config.maxLength || modelConfig.maxLength || 256)
-                .setNormalize(config.normalize !== false)
-                .setPooling(0); // Mean pooling
-            embedder = wasmModule.WasmEmbedder.withConfig(modelBytes, tokenizerJson, embedderConfig);
-            // Detect SIMD capability
-            detectSimd();
-            console.error(`ONNX embedder ready: ${embedder.dimension()}d, SIMD: ${simdAvailable}`);
-            isInitialized = true;
-            // Determine if we should use parallel workers
-            // - true: always enable
-            // - false: never enable
-            // - 'auto'/undefined: enable for long-running processes (MCP, servers), skip for CLI
-            let shouldTryParallel = false;
-            if (config.enableParallel === true) {
-                shouldTryParallel = true;
-            }
-            else if (config.enableParallel === false) {
-                shouldTryParallel = false;
-            }
-            else {
-                // Auto-detect: check if running as CLI hook or long-running process
-                const isCLI = process.argv[1]?.includes('cli.js') ||
-                    process.argv[1]?.includes('bin/ruvector') ||
-                    process.env.RUVECTOR_CLI === '1';
-                const isMCP = process.env.MCP_SERVER === '1' ||
-                    process.argv.some(a => a.includes('mcp'));
-                const forceParallel = process.env.RUVECTOR_PARALLEL === '1';
-                // Enable parallel for MCP/servers or if explicitly requested, skip for CLI
-                shouldTryParallel = forceParallel || (isMCP && !isCLI);
-            }
-            if (shouldTryParallel) {
-                await tryInitParallel(config);
-            }
-        }
-        catch (e) {
-            loadError = new Error(`Failed to initialize ONNX embedder: ${e.message}`);
-            throw loadError;
-        }
-    })();
-    await loadPromise;
-    return isInitialized;
-}
-/**
- * Generate embedding for text
- */
-async function embed(text) {
-    if (!isInitialized) {
-        await initOnnxEmbedder();
-    }
-    if (!embedder) {
-        throw new Error('ONNX embedder not initialized');
-    }
-    const start = performance.now();
-    const embedding = embedder.embedOne(text);
-    const timeMs = performance.now() - start;
-    return {
-        embedding: Array.from(embedding),
-        dimension: embedding.length,
-        timeMs,
-    };
-}
-/**
- * Generate embeddings for multiple texts
- * Uses parallel workers automatically for batches >= parallelThreshold
- */
-async function embedBatch(texts) {
-    if (!isInitialized) {
-        await initOnnxEmbedder();
-    }
-    if (!embedder) {
-        throw new Error('ONNX embedder not initialized');
-    }
-    const start = performance.now();
-    // Use parallel workers for large batches
-    if (parallelEnabled && parallelEmbedder && texts.length >= parallelThreshold) {
-        const batchResults = await parallelEmbedder.embedBatch(texts);
-        const totalTime = performance.now() - start;
-        const dimension = parallelEmbedder.dimension || 384;
-        return batchResults.map((emb) => ({
-            embedding: Array.from(emb),
-            dimension,
-            timeMs: totalTime / texts.length,
-        }));
-    }
-    // Sequential fallback
-    const batchEmbeddings = embedder.embedBatch(texts);
-    const totalTime = performance.now() - start;
-    const dimension = embedder.dimension();
-    const results = [];
-    for (let i = 0; i < texts.length; i++) {
-        const embedding = batchEmbeddings.slice(i * dimension, (i + 1) * dimension);
-        results.push({
-            embedding: Array.from(embedding),
-            dimension,
-            timeMs: totalTime / texts.length,
-        });
-    }
-    return results;
-}
-/**
- * Calculate cosine similarity between two texts
- */
-async function similarity(text1, text2) {
-    if (!isInitialized) {
-        await initOnnxEmbedder();
-    }
-    if (!embedder) {
-        throw new Error('ONNX embedder not initialized');
-    }
-    const start = performance.now();
-    const sim = embedder.similarity(text1, text2);
-    const timeMs = performance.now() - start;
-    return { similarity: sim, timeMs };
-}
-/**
- * Calculate cosine similarity between two embeddings
- */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-        throw new Error('Embeddings must have same dimension');
-    }
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-    return magnitude === 0 ? 0 : dotProduct / magnitude;
-}
-/**
- * Get embedding dimension
- */
-function getDimension() {
-    return embedder ? embedder.dimension() : 384;
-}
-/**
- * Check if embedder is ready
- */
-function isReady() {
-    return isInitialized;
-}
-/**
- * Get embedder stats including SIMD and parallel capabilities
- */
-function getStats() {
-    return {
-        ready: isInitialized,
-        dimension: embedder ? embedder.dimension() : 384,
-        model: DEFAULT_MODEL,
-        simd: simdAvailable,
-        parallel: parallelEnabled,
-        parallelWorkers: parallelEmbedder?.numWorkers || 0,
-        parallelThreshold,
-    };
-}
-/**
- * Shutdown parallel workers (call on exit)
- */
-async function shutdown() {
-    if (parallelEmbedder) {
-        await parallelEmbedder.shutdown();
-        parallelEmbedder = null;
-        parallelEnabled = false;
-    }
-}
-// Export class wrapper for compatibility
-class OnnxEmbedder {
-    constructor(config = {}) {
-        this.config = config;
-    }
-    async init() {
-        return initOnnxEmbedder(this.config);
-    }
-    async embed(text) {
-        const result = await embed(text);
-        return result.embedding;
-    }
-    async embedBatch(texts) {
-        const results = await embedBatch(texts);
-        return results.map(r => r.embedding);
-    }
-    async similarity(text1, text2) {
-        const result = await similarity(text1, text2);
-        return result.similarity;
-    }
-    get dimension() {
-        return getDimension();
-    }
-    get ready() {
-        return isReady();
-    }
-}
-exports.OnnxEmbedder = OnnxEmbedder;
-exports.default = OnnxEmbedder;

package/dist/core/core/parallel-intelligence.d.ts

@@ -1,108 +0,0 @@
-/**
- * Parallel Intelligence - Worker-based acceleration for IntelligenceEngine
- *
- * Provides parallel processing for:
- * - Q-learning batch updates (3-4x faster)
- * - Multi-file pattern matching
- * - Background memory indexing
- * - Parallel similarity search
- * - Multi-file code analysis
- * - Parallel git commit analysis
- *
- * Uses worker_threads for CPU-bound operations, keeping hooks non-blocking.
- */
-export interface ParallelConfig {
-    /** Number of worker threads (default: CPU cores - 1) */
-    numWorkers?: number;
-    /** Enable parallel processing (default: true for MCP, false for CLI) */
-    enabled?: boolean;
-    /** Minimum batch size to use parallel (default: 4) */
-    batchThreshold?: number;
-}
-export interface BatchEpisode {
-    state: string;
-    action: string;
-    reward: number;
-    nextState: string;
-    done: boolean;
-    metadata?: Record<string, any>;
-}
-export interface PatternMatchResult {
-    file: string;
-    patterns: Array<{
-        pattern: string;
-        confidence: number;
-    }>;
-}
-export interface CoEditAnalysis {
-    file1: string;
-    file2: string;
-    commits: string[];
-    strength: number;
-}
-export declare class ParallelIntelligence {
-    private workers;
-    private taskQueue;
-    private busyWorkers;
-    private config;
-    private initialized;
-    constructor(config?: ParallelConfig);
-    /**
-     * Initialize worker pool
-     */
-    init(): Promise<void>;
-    private processQueue;
-    /**
-     * Execute task in worker pool
-     */
-    private executeInWorker;
-    /**
-     * Batch Q-learning episode recording (3-4x faster)
-     */
-    recordEpisodesBatch(episodes: BatchEpisode[]): Promise<void>;
-    /**
-     * Multi-file pattern matching (parallel pretrain)
-     */
-    matchPatternsParallel(files: string[]): Promise<PatternMatchResult[]>;
-    /**
-     * Background memory indexing (non-blocking)
-     */
-    indexMemoriesBackground(memories: Array<{
-        content: string;
-        type: string;
-    }>): Promise<void>;
-    /**
-     * Parallel similarity search with sharding
-     */
-    searchParallel(query: string, topK?: number): Promise<Array<{
-        content: string;
-        score: number;
-    }>>;
-    /**
-     * Multi-file AST analysis for routing
-     */
-    analyzeFilesParallel(files: string[]): Promise<Map<string, {
-        agent: string;
-        confidence: number;
-    }>>;
-    /**
-     * Parallel git commit analysis for co-edit detection
-     */
-    analyzeCommitsParallel(commits: string[]): Promise<CoEditAnalysis[]>;
-    /**
-     * Get worker pool stats
-     */
-    getStats(): {
-        enabled: boolean;
-        workers: number;
-        busy: number;
-        queued: number;
-    };
-    /**
-     * Shutdown worker pool
-     */
-    shutdown(): Promise<void>;
-}
-export declare function getParallelIntelligence(config?: ParallelConfig): ParallelIntelligence;
-export declare function initParallelIntelligence(config?: ParallelConfig): Promise<ParallelIntelligence>;
-export default ParallelIntelligence;