ruvector 0.2.22 → 0.2.23

package/dist/core/parallel-workers.js

@@ -1,671 +0,0 @@
-"use strict";
-/**
- * Parallel Workers - Extended worker capabilities for RuVector hooks
- *
- * Provides parallel processing for advanced operations:
- *
- * 1. SPECULATIVE PRE-COMPUTATION
- *    - Pre-embed likely next files based on co-edit patterns
- *    - Warm model cache before operations
- *    - Predictive route caching
- *
- * 2. REAL-TIME CODE ANALYSIS
- *    - Multi-file AST parsing with tree-sitter
- *    - Cross-file type inference
- *    - Live complexity metrics
- *    - Dependency graph updates
- *
- * 3. ADVANCED LEARNING
- *    - Distributed trajectory replay
- *    - Parallel SONA micro-LoRA updates
- *    - Background EWC consolidation
- *    - Online pattern clustering
- *
- * 4. INTELLIGENT RETRIEVAL
- *    - Parallel RAG chunking and retrieval
- *    - Sharded similarity search
- *    - Context relevance ranking
- *    - Semantic deduplication
- *
- * 5. SECURITY & QUALITY
- *    - Parallel SAST scanning
- *    - Multi-rule linting
- *    - Vulnerability detection
- *    - Code smell analysis
- *
- * 6. GIT INTELLIGENCE
- *    - Parallel blame analysis
- *    - Branch comparison
- *    - Merge conflict prediction
- *    - Code churn metrics
- */
-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.ExtendedWorkerPool = void 0;
-exports.getExtendedWorkerPool = getExtendedWorkerPool;
-exports.initExtendedWorkerPool = initExtendedWorkerPool;
-const worker_threads_1 = require("worker_threads");
-const os = __importStar(require("os"));
-// ============================================================================
-// Extended Worker Pool
-// ============================================================================
-class ExtendedWorkerPool {
-    constructor(config = {}) {
-        this.workers = [];
-        this.taskQueue = [];
-        this.busyWorkers = new Map();
-        this.initialized = false;
-        this.speculativeCache = new Map();
-        this.astCache = new Map();
-        const isCLI = process.env.RUVECTOR_CLI === '1';
-        const isMCP = process.env.MCP_SERVER === '1';
-        this.config = {
-            numWorkers: config.numWorkers ?? Math.max(1, os.cpus().length - 1),
-            enabled: config.enabled ?? (isMCP || process.env.RUVECTOR_PARALLEL === '1'),
-            taskTimeout: config.taskTimeout ?? 30000,
-            maxQueueSize: config.maxQueueSize ?? 1000,
-        };
-    }
-    async init() {
-        if (this.initialized || !this.config.enabled)
-            return;
-        const workerCode = this.getWorkerCode();
-        const workerBlob = new Blob([workerCode], { type: 'application/javascript' });
-        for (let i = 0; i < this.config.numWorkers; i++) {
-            // Create worker from inline code
-            const worker = new worker_threads_1.Worker(`
-        const { parentPort, workerData } = require('worker_threads');
-        ${this.getWorkerHandlers()}
-        `, { eval: true, workerData: { workerId: i } });
-            worker.on('message', (result) => {
-                this.handleWorkerResult(worker, result);
-            });
-            worker.on('error', (err) => {
-                console.error(`Worker ${i} error:`, err);
-                this.busyWorkers.delete(worker);
-                this.processQueue();
-            });
-            this.workers.push(worker);
-        }
-        this.initialized = true;
-    }
-    getWorkerCode() {
-        return `
-      const { parentPort, workerData } = require('worker_threads');
-      ${this.getWorkerHandlers()}
-    `;
-    }
-    getWorkerHandlers() {
-        return `
-      parentPort.on('message', async (task) => {
-        try {
-          let result;
-          switch (task.type) {
-            case 'speculative-embed':
-              result = await speculativeEmbed(task.files, task.coEditGraph);
-              break;
-            case 'ast-analyze':
-              result = await astAnalyze(task.files);
-              break;
-            case 'security-scan':
-              result = await securityScan(task.files, task.rules);
-              break;
-            case 'rag-retrieve':
-              result = await ragRetrieve(task.query, task.chunks, task.topK);
-              break;
-            case 'context-rank':
-              result = await contextRank(task.context, task.query);
-              break;
-            case 'git-blame':
-              result = await gitBlame(task.files);
-              break;
-            case 'git-churn':
-              result = await gitChurn(task.files, task.since);
-              break;
-            case 'complexity-analyze':
-              result = await complexityAnalyze(task.files);
-              break;
-            case 'dependency-graph':
-              result = await dependencyGraph(task.entryPoints);
-              break;
-            case 'deduplicate':
-              result = await deduplicate(task.items, task.threshold);
-              break;
-            default:
-              throw new Error('Unknown task type: ' + task.type);
-          }
-          parentPort.postMessage({ success: true, data: result, taskId: task.taskId });
-        } catch (error) {
-          parentPort.postMessage({ success: false, error: error.message, taskId: task.taskId });
-        }
-      });
-
-      // Worker implementations
-      async function speculativeEmbed(files, coEditGraph) {
-        // Pre-compute embeddings for likely next files
-        return files.map(f => ({ file: f, embedding: [], confidence: 0.5 }));
-      }
-
-      async function astAnalyze(files) {
-        const fs = require('fs');
-        return files.map(file => {
-          try {
-            const content = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-            const lines = content.split('\\n');
-            return {
-              file,
-              language: file.split('.').pop() || 'unknown',
-              complexity: Math.min(lines.length / 10, 100),
-              functions: extractFunctions(content),
-              imports: extractImports(content),
-              exports: extractExports(content),
-              dependencies: [],
-            };
-          } catch {
-            return { file, language: 'unknown', complexity: 0, functions: [], imports: [], exports: [], dependencies: [] };
-          }
-        });
-      }
-
-      function extractFunctions(content) {
-        const patterns = [
-          /function\\s+(\\w+)/g,
-          /const\\s+(\\w+)\\s*=\\s*(?:async\\s*)?\\([^)]*\\)\\s*=>/g,
-          /(?:async\\s+)?(?:public|private|protected)?\\s*(\\w+)\\s*\\([^)]*\\)\\s*{/g,
-        ];
-        const funcs = new Set();
-        for (const pattern of patterns) {
-          let match;
-          while ((match = pattern.exec(content)) !== null) {
-            if (match[1] && !['if', 'for', 'while', 'switch', 'catch'].includes(match[1])) {
-              funcs.add(match[1]);
-            }
-          }
-        }
-        return Array.from(funcs);
-      }
-
-      function extractImports(content) {
-        const imports = [];
-        const patterns = [
-          /import\\s+.*?from\\s+['"]([^'"]+)['"]/g,
-          /require\\s*\\(['"]([^'"]+)['"]\\)/g,
-        ];
-        for (const pattern of patterns) {
-          let match;
-          while ((match = pattern.exec(content)) !== null) {
-            imports.push(match[1]);
-          }
-        }
-        return imports;
-      }
-
-      function extractExports(content) {
-        const exports = [];
-        const patterns = [
-          /export\\s+(?:default\\s+)?(?:class|function|const|let|var)\\s+(\\w+)/g,
-          /module\\.exports\\s*=\\s*(\\w+)/g,
-        ];
-        for (const pattern of patterns) {
-          let match;
-          while ((match = pattern.exec(content)) !== null) {
-            exports.push(match[1]);
-          }
-        }
-        return exports;
-      }
-
-      async function securityScan(files, rules) {
-        const fs = require('fs');
-        const findings = [];
-        const securityPatterns = [
-          { pattern: /eval\\s*\\(/g, rule: 'no-eval', severity: 'high', message: 'Avoid eval()' },
-          { pattern: /innerHTML\\s*=/g, rule: 'no-inner-html', severity: 'medium', message: 'Avoid innerHTML, use textContent' },
-          { pattern: /password\\s*=\\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-secrets', severity: 'critical', message: 'Hardcoded password detected' },
-          { pattern: /api[_-]?key\\s*=\\s*['"][^'"]+['"]/gi, rule: 'no-hardcoded-secrets', severity: 'critical', message: 'Hardcoded API key detected' },
-          { pattern: /exec\\s*\\(/g, rule: 'no-exec', severity: 'high', message: 'Avoid exec(), use execFile or spawn' },
-          { pattern: /\\$\\{.*\\}/g, rule: 'template-injection', severity: 'medium', message: 'Potential template injection' },
-        ];
-
-        for (const file of files) {
-          try {
-            if (!fs.existsSync(file)) continue;
-            const content = fs.readFileSync(file, 'utf8');
-            const lines = content.split('\\n');
-
-            for (const { pattern, rule, severity, message } of securityPatterns) {
-              let match;
-              const regex = new RegExp(pattern.source, pattern.flags);
-              while ((match = regex.exec(content)) !== null) {
-                const lineNum = content.substring(0, match.index).split('\\n').length;
-                findings.push({ file, line: lineNum, severity, rule, message });
-              }
-            }
-          } catch {}
-        }
-        return findings;
-      }
-
-      async function ragRetrieve(query, chunks, topK) {
-        // Simple keyword-based retrieval (would use embeddings in production)
-        const queryTerms = query.toLowerCase().split(/\\s+/);
-        return chunks
-          .map(chunk => {
-            const content = chunk.content.toLowerCase();
-            const matches = queryTerms.filter(term => content.includes(term)).length;
-            return { ...chunk, relevance: matches / queryTerms.length };
-          })
-          .sort((a, b) => b.relevance - a.relevance)
-          .slice(0, topK);
-      }
-
-      async function contextRank(context, query) {
-        const queryTerms = query.toLowerCase().split(/\\s+/);
-        return context
-          .map((ctx, i) => {
-            const content = ctx.toLowerCase();
-            const matches = queryTerms.filter(term => content.includes(term)).length;
-            return { index: i, content: ctx, relevance: matches / queryTerms.length };
-          })
-          .sort((a, b) => b.relevance - a.relevance);
-      }
-
-      async function gitBlame(files) {
-        const { execSync } = require('child_process');
-        const results = [];
-        for (const file of files) {
-          try {
-            const output = execSync(\`git blame --line-porcelain "\${file}" 2>/dev/null\`, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });
-            const lines = [];
-            let currentLine = {};
-            for (const line of output.split('\\n')) {
-              if (line.startsWith('author ')) currentLine.author = line.slice(7);
-              else if (line.startsWith('author-time ')) currentLine.date = new Date(parseInt(line.slice(12)) * 1000).toISOString();
-              else if (line.match(/^[a-f0-9]{40}/)) currentLine.commit = line.slice(0, 40);
-              else if (line.startsWith('\\t')) {
-                lines.push({ ...currentLine, line: lines.length + 1 });
-                currentLine = {};
-              }
-            }
-            results.push({ file, lines });
-          } catch {
-            results.push({ file, lines: [] });
-          }
-        }
-        return results;
-      }
-
-      async function gitChurn(files, since) {
-        const { execSync } = require('child_process');
-        const results = [];
-        const sinceArg = since ? \`--since="\${since}"\` : '--since="30 days ago"';
-
-        for (const file of files) {
-          try {
-            const log = execSync(\`git log \${sinceArg} --format="%H|%an|%aI" --numstat -- "\${file}" 2>/dev/null\`, { encoding: 'utf8' });
-            let additions = 0, deletions = 0, commits = 0;
-            const authors = new Set();
-            let lastModified = '';
-
-            for (const line of log.split('\\n')) {
-              if (line.includes('|')) {
-                const [commit, author, date] = line.split('|');
-                authors.add(author);
-                commits++;
-                if (!lastModified) lastModified = date;
-              } else if (line.match(/^\\d+\\s+\\d+/)) {
-                const [add, del] = line.split('\\t');
-                additions += parseInt(add) || 0;
-                deletions += parseInt(del) || 0;
-              }
-            }
-
-            results.push({ file, additions, deletions, commits, authors: Array.from(authors), lastModified });
-          } catch {
-            results.push({ file, additions: 0, deletions: 0, commits: 0, authors: [], lastModified: '' });
-          }
-        }
-        return results;
-      }
-
-      async function complexityAnalyze(files) {
-        const fs = require('fs');
-        return files.map(file => {
-          try {
-            const content = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-            const lines = content.split('\\n');
-            const nonEmpty = lines.filter(l => l.trim()).length;
-            const branches = (content.match(/\\b(if|else|switch|case|for|while|catch|\\?|&&|\\|\\|)\\b/g) || []).length;
-            const functions = (content.match(/function|=>|\\bdef\\b|\\bfn\\b/g) || []).length;
-
-            return {
-              file,
-              lines: lines.length,
-              nonEmptyLines: nonEmpty,
-              cyclomaticComplexity: branches + 1,
-              functions,
-              avgFunctionSize: functions > 0 ? Math.round(nonEmpty / functions) : nonEmpty,
-            };
-          } catch {
-            return { file, lines: 0, nonEmptyLines: 0, cyclomaticComplexity: 1, functions: 0, avgFunctionSize: 0 };
-          }
-        });
-      }
-
-      async function dependencyGraph(entryPoints) {
-        const fs = require('fs');
-        const path = require('path');
-        const graph = new Map();
-
-        function analyze(file, visited = new Set()) {
-          if (visited.has(file)) return;
-          visited.add(file);
-
-          try {
-            if (!fs.existsSync(file)) return;
-            const content = fs.readFileSync(file, 'utf8');
-            const deps = [];
-
-            // Extract imports
-            const importRegex = /(?:import|require)\\s*\\(?['"]([^'"]+)['"]/g;
-            let match;
-            while ((match = importRegex.exec(content)) !== null) {
-              const dep = match[1];
-              if (dep.startsWith('.')) {
-                const resolved = path.resolve(path.dirname(file), dep);
-                deps.push(resolved);
-                analyze(resolved, visited);
-              } else {
-                deps.push(dep);
-              }
-            }
-
-            graph.set(file, deps);
-          } catch {}
-        }
-
-        for (const entry of entryPoints) {
-          analyze(entry);
-        }
-
-        return Object.fromEntries(graph);
-      }
-
-      async function deduplicate(items, threshold) {
-        // Simple Jaccard similarity deduplication
-        const unique = [];
-        const seen = new Set();
-
-        for (const item of items) {
-          const tokens = new Set(item.toLowerCase().split(/\\s+/));
-          let isDup = false;
-
-          for (const existing of unique) {
-            const existingTokens = new Set(existing.toLowerCase().split(/\\s+/));
-            const intersection = [...tokens].filter(t => existingTokens.has(t)).length;
-            const union = new Set([...tokens, ...existingTokens]).size;
-            const similarity = intersection / union;
-
-            if (similarity >= threshold) {
-              isDup = true;
-              break;
-            }
-          }
-
-          if (!isDup) unique.push(item);
-        }
-
-        return unique;
-      }
-    `;
-    }
-    handleWorkerResult(worker, result) {
-        this.busyWorkers.delete(worker);
-        // Find and resolve the corresponding task
-        const taskIndex = this.taskQueue.findIndex(t => t.task.taskId === result.taskId);
-        if (taskIndex >= 0) {
-            const task = this.taskQueue.splice(taskIndex, 1)[0];
-            clearTimeout(task.timeout);
-            if (result.success) {
-                task.resolve(result.data);
-            }
-            else {
-                task.reject(new Error(result.error));
-            }
-        }
-        this.processQueue();
-    }
-    processQueue() {
-        while (this.taskQueue.length > 0) {
-            const availableWorker = this.workers.find(w => !this.busyWorkers.has(w));
-            if (!availableWorker)
-                break;
-            const task = this.taskQueue[0];
-            this.busyWorkers.set(availableWorker, task.task.type);
-            availableWorker.postMessage(task.task);
-        }
-    }
-    async execute(task) {
-        if (!this.initialized || !this.config.enabled) {
-            throw new Error('Worker pool not initialized');
-        }
-        const taskId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const taskWithId = { ...task, taskId };
-        return new Promise((resolve, reject) => {
-            if (this.taskQueue.length >= this.config.maxQueueSize) {
-                reject(new Error('Task queue full'));
-                return;
-            }
-            const timeout = setTimeout(() => {
-                const idx = this.taskQueue.findIndex(t => t.task.taskId === taskId);
-                if (idx >= 0) {
-                    this.taskQueue.splice(idx, 1);
-                    reject(new Error('Task timeout'));
-                }
-            }, this.config.taskTimeout);
-            const availableWorker = this.workers.find(w => !this.busyWorkers.has(w));
-            if (availableWorker) {
-                this.busyWorkers.set(availableWorker, task.type);
-                this.taskQueue.push({ task: taskWithId, resolve, reject, timeout });
-                availableWorker.postMessage(taskWithId);
-            }
-            else {
-                this.taskQueue.push({ task: taskWithId, resolve, reject, timeout });
-            }
-        });
-    }
-    // =========================================================================
-    // Public API - Speculative Pre-computation
-    // =========================================================================
-    /**
-     * Pre-embed files likely to be edited next based on co-edit patterns
-     * Hook: session-start, post-edit
-     */
-    async speculativeEmbed(currentFile, coEditGraph) {
-        const likelyFiles = coEditGraph.get(currentFile) || [];
-        if (likelyFiles.length === 0)
-            return [];
-        // Check cache first
-        const uncached = likelyFiles.filter(f => !this.speculativeCache.has(f));
-        if (uncached.length === 0) {
-            return likelyFiles.map(f => this.speculativeCache.get(f));
-        }
-        const results = await this.execute({
-            type: 'speculative-embed',
-            files: uncached,
-            coEditGraph,
-        });
-        // Update cache
-        for (const result of results) {
-            this.speculativeCache.set(result.file, result);
-        }
-        return likelyFiles.map(f => this.speculativeCache.get(f)).filter(Boolean);
-    }
-    // =========================================================================
-    // Public API - Code Analysis
-    // =========================================================================
-    /**
-     * Analyze AST of multiple files in parallel
-     * Hook: pre-edit, route
-     */
-    async analyzeAST(files) {
-        // Check cache
-        const uncached = files.filter(f => !this.astCache.has(f));
-        if (uncached.length === 0) {
-            return files.map(f => this.astCache.get(f));
-        }
-        const results = await this.execute({
-            type: 'ast-analyze',
-            files: uncached,
-        });
-        // Update cache
-        for (const result of results) {
-            this.astCache.set(result.file, result);
-        }
-        return files.map(f => this.astCache.get(f)).filter(Boolean);
-    }
-    /**
-     * Analyze code complexity for multiple files
-     * Hook: post-edit, session-end
-     */
-    async analyzeComplexity(files) {
-        return this.execute({ type: 'complexity-analyze', files });
-    }
-    /**
-     * Build dependency graph from entry points
-     * Hook: session-start
-     */
-    async buildDependencyGraph(entryPoints) {
-        return this.execute({ type: 'dependency-graph', entryPoints });
-    }
-    // =========================================================================
-    // Public API - Security
-    // =========================================================================
-    /**
-     * Scan files for security vulnerabilities
-     * Hook: pre-command (before commit), post-edit
-     */
-    async securityScan(files, rules) {
-        return this.execute({ type: 'security-scan', files, rules });
-    }
-    // =========================================================================
-    // Public API - RAG & Context
-    // =========================================================================
-    /**
-     * Retrieve relevant context chunks in parallel
-     * Hook: suggest-context, recall
-     */
-    async ragRetrieve(query, chunks, topK = 5) {
-        return this.execute({ type: 'rag-retrieve', query, chunks, topK });
-    }
-    /**
-     * Rank context items by relevance to query
-     * Hook: suggest-context
-     */
-    async rankContext(context, query) {
-        return this.execute({ type: 'context-rank', context, query });
-    }
-    /**
-     * Deduplicate similar items
-     * Hook: remember, suggest-context
-     */
-    async deduplicate(items, threshold = 0.8) {
-        return this.execute({ type: 'deduplicate', items, threshold });
-    }
-    // =========================================================================
-    // Public API - Git Intelligence
-    // =========================================================================
-    /**
-     * Get blame information for files in parallel
-     * Hook: pre-edit (for context), coedit
-     */
-    async gitBlame(files) {
-        return this.execute({ type: 'git-blame', files });
-    }
-    /**
-     * Analyze code churn for files
-     * Hook: session-start, route
-     */
-    async gitChurn(files, since) {
-        return this.execute({ type: 'git-churn', files, since });
-    }
-    // =========================================================================
-    // Stats & Lifecycle
-    // =========================================================================
-    getStats() {
-        return {
-            enabled: this.config.enabled,
-            workers: this.workers.length,
-            busy: this.busyWorkers.size,
-            queued: this.taskQueue.length,
-            speculativeCacheSize: this.speculativeCache.size,
-            astCacheSize: this.astCache.size,
-        };
-    }
-    clearCaches() {
-        this.speculativeCache.clear();
-        this.astCache.clear();
-    }
-    async shutdown() {
-        // Clear pending tasks
-        for (const task of this.taskQueue) {
-            clearTimeout(task.timeout);
-            task.reject(new Error('Worker pool shutting down'));
-        }
-        this.taskQueue = [];
-        // Terminate workers
-        await Promise.all(this.workers.map(w => w.terminate()));
-        this.workers = [];
-        this.busyWorkers.clear();
-        this.initialized = false;
-    }
-}
-exports.ExtendedWorkerPool = ExtendedWorkerPool;
-// ============================================================================
-// Singleton
-// ============================================================================
-let instance = null;
-function getExtendedWorkerPool(config) {
-    if (!instance) {
-        instance = new ExtendedWorkerPool(config);
-    }
-    return instance;
-}
-async function initExtendedWorkerPool(config) {
-    const pool = getExtendedWorkerPool(config);
-    await pool.init();
-    return pool;
-}
-exports.default = ExtendedWorkerPool;