ruvector 0.2.28 → 0.2.29

package/dist/core/parallel-workers.js

@@ -105,9 +105,9 @@ class ExtendedWorkerPool {
         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()}
+            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);
@@ -122,445 +122,445 @@ class ExtendedWorkerPool {
         this.initialized = true;
     }
     getWorkerCode() {
-        return `
-      const { parentPort, workerData } = require('worker_threads');
-      ${this.getWorkerHandlers()}
+        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
-
-      // Hash-based embedding: deterministic, no external deps, 128-dim
-      function hashEmbed(text, dim = 128) {
-        const embedding = new Float64Array(dim);
-        const tokens = text.split(/\\s+|[{}()\\[\\];,.<>=/+\\-*&|!~^%@#]/);
-
-        for (let t = 0; t < tokens.length; t++) {
-          const token = tokens[t];
-          if (!token) continue;
-
-          // FNV-1a hash
-          let h = 0x811c9dc5;
-          for (let i = 0; i < token.length; i++) {
-            h ^= token.charCodeAt(i);
-            h = Math.imul(h, 0x01000193);
-          }
-
-          // Positional weight (tokens near start matter more)
-          const posWeight = 1.0 / (1.0 + Math.log1p(t));
-
-          // Distribute across multiple dimensions using hash rotations
-          for (let d = 0; d < 4; d++) {
-            const idx = ((h >>> 0) + d * 37) % dim;
-            const sign = (h & (1 << d)) ? 1 : -1;
-            embedding[idx] += sign * posWeight;
-            h = (h >>> 7) | (h << 25); // rotate
-          }
-        }
-
-        // L2 normalize
-        let norm = 0;
-        for (let i = 0; i < dim; i++) norm += embedding[i] * embedding[i];
-        norm = Math.sqrt(norm) || 1;
-        const result = new Array(dim);
-        for (let i = 0; i < dim; i++) result[i] = embedding[i] / norm;
-        return result;
-      }
-
-      async function speculativeEmbed(files, coEditGraph) {
-        const fs = require('fs');
-        return files.map(file => {
-          try {
-            if (!fs.existsSync(file)) {
-              return { file, embedding: hashEmbed(file), confidence: 0.2, timestamp: Date.now() };
-            }
-            const content = fs.readFileSync(file, 'utf8');
-            const embedding = hashEmbed(content);
-
-            // Confidence based on file size (more content = higher confidence)
-            const lines = content.split('\\n').length;
-            const confidence = Math.min(0.95, 0.3 + (lines / 500) * 0.65);
-
-            return { file, embedding, confidence, timestamp: Date.now() };
-          } catch {
-            return { file, embedding: hashEmbed(file), confidence: 0.1, timestamp: Date.now() };
-          }
-        });
-      }
-
-      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;
-      }
-
-      function cosineSimilarity(a, b) {
-        if (!a || !b || a.length !== b.length || a.length === 0) return 0;
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < a.length; i++) {
-          dot += a[i] * b[i];
-          normA += a[i] * a[i];
-          normB += b[i] * b[i];
-        }
-        const denom = Math.sqrt(normA) * Math.sqrt(normB);
-        return denom === 0 ? 0 : dot / denom;
-      }
-
-      async function ragRetrieve(query, chunks, topK) {
-        // If chunks have embeddings, use cosine similarity (semantic retrieval)
-        const hasEmbeddings = chunks.some(c => c.embedding && c.embedding.length > 0);
-
-        if (hasEmbeddings) {
-          const queryEmbedding = hashEmbed(query, chunks[0].embedding.length);
-          return chunks
-            .map(chunk => {
-              const semantic = chunk.embedding && chunk.embedding.length > 0
-                ? cosineSimilarity(queryEmbedding, chunk.embedding)
-                : 0;
-              // Blend semantic + keyword for robustness
-              const queryTerms = query.toLowerCase().split(/\\s+/);
-              const content = chunk.content.toLowerCase();
-              const kwMatches = queryTerms.filter(t => content.includes(t)).length;
-              const keyword = queryTerms.length > 0 ? kwMatches / queryTerms.length : 0;
-              const relevance = semantic * 0.7 + keyword * 0.3;
-              return { ...chunk, relevance };
-            })
-            .sort((a, b) => b.relevance - a.relevance)
-            .slice(0, topK);
-        }
-
-        // Fallback: TF-IDF-weighted keyword matching
-        const queryTerms = query.toLowerCase().split(/\\s+/).filter(Boolean);
-        const allContent = chunks.map(c => c.content.toLowerCase());
-        // IDF: log(N / df) for each query term
-        const idf = {};
-        for (const term of queryTerms) {
-          const df = allContent.filter(c => c.includes(term)).length || 1;
-          idf[term] = Math.log(allContent.length / df);
-        }
-        return chunks
-          .map(chunk => {
-            const content = chunk.content.toLowerCase();
-            const words = content.split(/\\s+/);
-            let score = 0;
-            for (const term of queryTerms) {
-              const tf = words.filter(w => w === term).length / (words.length || 1);
-              score += tf * (idf[term] || 1);
-            }
-            return { ...chunk, relevance: score };
-          })
-          .sort((a, b) => b.relevance - a.relevance)
-          .slice(0, topK);
-      }
-
-      async function contextRank(context, query) {
-        // Use TF-IDF scoring instead of raw keyword matching
-        const queryTerms = query.toLowerCase().split(/\\s+/).filter(Boolean);
-        const allContent = context.map(c => c.toLowerCase());
-        const idf = {};
-        for (const term of queryTerms) {
-          const df = allContent.filter(c => c.includes(term)).length || 1;
-          idf[term] = Math.log(allContent.length / df);
-        }
-        return context
-          .map((ctx, i) => {
-            const content = ctx.toLowerCase();
-            const words = content.split(/\\s+/);
-            let score = 0;
-            for (const term of queryTerms) {
-              const tf = words.filter(w => w === term).length / (words.length || 1);
-              score += tf * (idf[term] || 1);
-            }
-            return { index: i, content: ctx, relevance: score };
-          })
-          .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;
-      }
+        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
+
+      // Hash-based embedding: deterministic, no external deps, 128-dim
+      function hashEmbed(text, dim = 128) {
+        const embedding = new Float64Array(dim);
+        const tokens = text.split(/\\s+|[{}()\\[\\];,.<>=/+\\-*&|!~^%@#]/);
+
+        for (let t = 0; t < tokens.length; t++) {
+          const token = tokens[t];
+          if (!token) continue;
+
+          // FNV-1a hash
+          let h = 0x811c9dc5;
+          for (let i = 0; i < token.length; i++) {
+            h ^= token.charCodeAt(i);
+            h = Math.imul(h, 0x01000193);
+          }
+
+          // Positional weight (tokens near start matter more)
+          const posWeight = 1.0 / (1.0 + Math.log1p(t));
+
+          // Distribute across multiple dimensions using hash rotations
+          for (let d = 0; d < 4; d++) {
+            const idx = ((h >>> 0) + d * 37) % dim;
+            const sign = (h & (1 << d)) ? 1 : -1;
+            embedding[idx] += sign * posWeight;
+            h = (h >>> 7) | (h << 25); // rotate
+          }
+        }
+
+        // L2 normalize
+        let norm = 0;
+        for (let i = 0; i < dim; i++) norm += embedding[i] * embedding[i];
+        norm = Math.sqrt(norm) || 1;
+        const result = new Array(dim);
+        for (let i = 0; i < dim; i++) result[i] = embedding[i] / norm;
+        return result;
+      }
+
+      async function speculativeEmbed(files, coEditGraph) {
+        const fs = require('fs');
+        return files.map(file => {
+          try {
+            if (!fs.existsSync(file)) {
+              return { file, embedding: hashEmbed(file), confidence: 0.2, timestamp: Date.now() };
+            }
+            const content = fs.readFileSync(file, 'utf8');
+            const embedding = hashEmbed(content);
+
+            // Confidence based on file size (more content = higher confidence)
+            const lines = content.split('\\n').length;
+            const confidence = Math.min(0.95, 0.3 + (lines / 500) * 0.65);
+
+            return { file, embedding, confidence, timestamp: Date.now() };
+          } catch {
+            return { file, embedding: hashEmbed(file), confidence: 0.1, timestamp: Date.now() };
+          }
+        });
+      }
+
+      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;
+      }
+
+      function cosineSimilarity(a, b) {
+        if (!a || !b || a.length !== b.length || a.length === 0) return 0;
+        let dot = 0, normA = 0, normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          dot += a[i] * b[i];
+          normA += a[i] * a[i];
+          normB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(normA) * Math.sqrt(normB);
+        return denom === 0 ? 0 : dot / denom;
+      }
+
+      async function ragRetrieve(query, chunks, topK) {
+        // If chunks have embeddings, use cosine similarity (semantic retrieval)
+        const hasEmbeddings = chunks.some(c => c.embedding && c.embedding.length > 0);
+
+        if (hasEmbeddings) {
+          const queryEmbedding = hashEmbed(query, chunks[0].embedding.length);
+          return chunks
+            .map(chunk => {
+              const semantic = chunk.embedding && chunk.embedding.length > 0
+                ? cosineSimilarity(queryEmbedding, chunk.embedding)
+                : 0;
+              // Blend semantic + keyword for robustness
+              const queryTerms = query.toLowerCase().split(/\\s+/);
+              const content = chunk.content.toLowerCase();
+              const kwMatches = queryTerms.filter(t => content.includes(t)).length;
+              const keyword = queryTerms.length > 0 ? kwMatches / queryTerms.length : 0;
+              const relevance = semantic * 0.7 + keyword * 0.3;
+              return { ...chunk, relevance };
+            })
+            .sort((a, b) => b.relevance - a.relevance)
+            .slice(0, topK);
+        }
+
+        // Fallback: TF-IDF-weighted keyword matching
+        const queryTerms = query.toLowerCase().split(/\\s+/).filter(Boolean);
+        const allContent = chunks.map(c => c.content.toLowerCase());
+        // IDF: log(N / df) for each query term
+        const idf = {};
+        for (const term of queryTerms) {
+          const df = allContent.filter(c => c.includes(term)).length || 1;
+          idf[term] = Math.log(allContent.length / df);
+        }
+        return chunks
+          .map(chunk => {
+            const content = chunk.content.toLowerCase();
+            const words = content.split(/\\s+/);
+            let score = 0;
+            for (const term of queryTerms) {
+              const tf = words.filter(w => w === term).length / (words.length || 1);
+              score += tf * (idf[term] || 1);
+            }
+            return { ...chunk, relevance: score };
+          })
+          .sort((a, b) => b.relevance - a.relevance)
+          .slice(0, topK);
+      }
+
+      async function contextRank(context, query) {
+        // Use TF-IDF scoring instead of raw keyword matching
+        const queryTerms = query.toLowerCase().split(/\\s+/).filter(Boolean);
+        const allContent = context.map(c => c.toLowerCase());
+        const idf = {};
+        for (const term of queryTerms) {
+          const df = allContent.filter(c => c.includes(term)).length || 1;
+          idf[term] = Math.log(allContent.length / df);
+        }
+        return context
+          .map((ctx, i) => {
+            const content = ctx.toLowerCase();
+            const words = content.split(/\\s+/);
+            let score = 0;
+            for (const term of queryTerms) {
+              const tf = words.filter(w => w === term).length / (words.length || 1);
+              score += tf * (idf[term] || 1);
+            }
+            return { index: i, content: ctx, relevance: score };
+          })
+          .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) {