"use strict"; /** * IntelligenceEngine - Full RuVector Intelligence Stack * * Integrates all RuVector capabilities for self-learning hooks: * - VectorDB with HNSW for semantic memory (150x faster) * - SONA for continual learning (Micro-LoRA, EWC++) * - FastAgentDB for episode/trajectory storage * - Attention mechanisms for pattern recognition * - ReasoningBank for pattern clustering * * Replaces the simple Q-learning approach with real ML-powered intelligence. */ Object.defineProperty(exports, "__esModule", { value: true }); exports.IntelligenceEngine = void 0; exports.createIntelligenceEngine = createIntelligenceEngine; exports.createHighPerformanceEngine = createHighPerformanceEngine; exports.createLightweightEngine = createLightweightEngine; const agentdb_fast_1 = require("./agentdb-fast"); const sona_wrapper_1 = require("./sona-wrapper"); const onnx_embedder_1 = require("./onnx-embedder"); const parallel_intelligence_1 = require("./parallel-intelligence"); // ============================================================================ // Lazy Loading // ============================================================================ let VectorDB = null; let vectorDbError = null; function getVectorDB() { if (VectorDB) return VectorDB; if (vectorDbError) throw vectorDbError; try { const core = require('@ruvector/core'); VectorDB = core.VectorDb || core.VectorDB; return VectorDB; } catch { try { const pkg = require('ruvector'); VectorDB = pkg.VectorDb || pkg.VectorDB; return VectorDB; } catch (e) { vectorDbError = new Error(`VectorDB not available: ${e.message}`); throw vectorDbError; } } } let attentionModule = null; let attentionError = null; function getAttention() { if (attentionModule) return attentionModule; if (attentionError) return null; // Silently fail for optional module try { attentionModule = require('@ruvector/attention'); return attentionModule; } catch (e) { attentionError = e; return null; } } // ============================================================================ // Intelligence Engine // ============================================================================ /** * Full-stack intelligence engine using all RuVector capabilities */ class IntelligenceEngine { constructor(config = {}) { this.vectorDb = null; this.sona = null; this.attention = null; this.onnxEmbedder = null; this.onnxReady = false; this.parallel = null; // In-memory data structures this.memories = new Map(); this.routingPatterns = new Map(); // state -> action -> value this.errorPatterns = new Map(); // error -> fixes this.coEditPatterns = new Map(); // file -> related files -> count this.agentMappings = new Map(); // extension/dir -> agent this.workerTriggerMappings = new Map(); // trigger -> agents // Runtime state this.currentTrajectoryId = null; this.sessionStart = Date.now(); this.learningEnabled = true; this.episodeBatchQueue = []; // If ONNX is enabled, use 384 dimensions (MiniLM default) const useOnnx = !!(config.enableOnnx && (0, onnx_embedder_1.isOnnxAvailable)()); const embeddingDim = useOnnx ? 384 : (config.embeddingDim ?? 256); this.config = { embeddingDim, maxMemories: config.maxMemories ?? 100000, maxEpisodes: config.maxEpisodes ?? 50000, enableSona: config.enableSona ?? true, enableAttention: config.enableAttention ?? true, enableOnnx: useOnnx, sonaConfig: config.sonaConfig ?? {}, storagePath: config.storagePath ?? '', learningRate: config.learningRate ?? 0.1, parallelConfig: config.parallelConfig ?? {}, }; // Initialize parallel workers (auto-enabled for MCP, disabled for CLI) this.parallel = (0, parallel_intelligence_1.getParallelIntelligence)(this.config.parallelConfig); this.initParallel(); // Initialize FastAgentDB for episode storage this.agentDb = new agentdb_fast_1.FastAgentDB(this.config.embeddingDim, this.config.maxEpisodes); // Initialize ONNX embedder if enabled if (this.config.enableOnnx) { this.onnxEmbedder = new onnx_embedder_1.OnnxEmbedder(); // Initialize async (don't block constructor) this.initOnnx(); } // Initialize SONA if enabled and available if (this.config.enableSona && (0, sona_wrapper_1.isSonaAvailable)()) { try { this.sona = sona_wrapper_1.SonaEngine.withConfig({ hiddenDim: this.config.embeddingDim, embeddingDim: this.config.embeddingDim, microLoraRank: 2, // Fast adaptations baseLoraRank: 8, patternClusters: 100, trajectoryCapacity: 10000, ...this.config.sonaConfig, }); } catch (e) { console.warn('SONA initialization failed, using fallback learning'); } } // Initialize attention if enabled (fallback if ONNX not available) if (this.config.enableAttention && !this.config.enableOnnx) { this.attention = getAttention(); } // Initialize VectorDB for memory this.initVectorDb(); } async initOnnx() { if (!this.onnxEmbedder) return; try { await this.onnxEmbedder.init(); this.onnxReady = true; } catch (e) { console.warn('ONNX initialization failed, using fallback embeddings'); this.onnxReady = false; } } async initVectorDb() { try { const VDB = getVectorDB(); this.vectorDb = new VDB({ dimensions: this.config.embeddingDim, distanceMetric: 'Cosine', }); } catch { // VectorDB not available, use fallback } } async initParallel() { if (this.parallel) { try { await this.parallel.init(); } catch { // Parallel not available, use sequential this.parallel = null; } } } // ========================================================================= // Embedding Generation // ========================================================================= /** * Generate embedding using ONNX, attention, or hash (in order of preference) */ embed(text) { const dim = this.config.embeddingDim; // Try ONNX semantic embeddings first (best quality) if (this.onnxReady && this.onnxEmbedder) { try { // Note: This is sync wrapper for async ONNX // For full async, use embedAsync return this.hashEmbed(text, dim); // Fallback for sync context } catch { // Fall through } } // Try to use attention-based embedding if (this.attention?.DotProductAttention) { try { return this.attentionEmbed(text, dim); } catch { // Fall through to hash embedding } } // Improved positional hash embedding return this.hashEmbed(text, dim); } /** * Async embedding with ONNX support (recommended for semantic quality) */ async embedAsync(text) { // Try ONNX first (best semantic quality) if (this.onnxEmbedder) { try { if (!this.onnxReady) { await this.onnxEmbedder.init(); this.onnxReady = true; } return await this.onnxEmbedder.embed(text); } catch { // Fall through to sync methods } } // Fall back to sync embedding return this.embed(text); } /** * Attention-based embedding using Flash or Multi-head attention */ attentionEmbed(text, dim) { const tokens = this.tokenize(text); const tokenEmbeddings = tokens.map(t => this.tokenEmbed(t, dim)); if (tokenEmbeddings.length === 0) { return new Array(dim).fill(0); } try { // Try FlashAttention first (fastest) if (this.attention?.FlashAttention) { const flash = new this.attention.FlashAttention(dim); const query = new Float32Array(this.meanPool(tokenEmbeddings)); const keys = tokenEmbeddings.map(e => new Float32Array(e)); const values = tokenEmbeddings.map(e => new Float32Array(e)); const result = flash.forward(query, keys, values); return Array.from(result); } // Try MultiHeadAttention (better quality) if (this.attention?.MultiHeadAttention) { const numHeads = Math.min(8, Math.floor(dim / 32)); // 8 heads max const mha = new this.attention.MultiHeadAttention(dim, numHeads); const query = new Float32Array(this.meanPool(tokenEmbeddings)); const keys = tokenEmbeddings.map(e => new Float32Array(e)); const values = tokenEmbeddings.map(e => new Float32Array(e)); const result = mha.forward(query, keys, values); return Array.from(result); } // Fall back to DotProductAttention if (this.attention?.DotProductAttention) { const attn = new this.attention.DotProductAttention(); const query = this.meanPool(tokenEmbeddings); const result = attn.forward(new Float32Array(query), tokenEmbeddings.map(e => new Float32Array(e)), tokenEmbeddings.map(e => new Float32Array(e))); return Array.from(result); } } catch { // Fall through to hash embedding } // Ultimate fallback return this.hashEmbed(text, dim); } /** * Improved hash-based embedding with positional encoding */ hashEmbed(text, dim) { const embedding = new Array(dim).fill(0); const tokens = this.tokenize(text); for (let t = 0; t < tokens.length; t++) { const token = tokens[t]; const posWeight = 1 / (1 + t * 0.1); // Positional decay for (let i = 0; i < token.length; i++) { const charCode = token.charCodeAt(i); // Multiple hash functions for better distribution const h1 = (charCode * 31 + i * 17 + t * 7) % dim; const h2 = (charCode * 37 + i * 23 + t * 11) % dim; const h3 = (charCode * 41 + i * 29 + t * 13) % dim; embedding[h1] += posWeight; embedding[h2] += posWeight * 0.5; embedding[h3] += posWeight * 0.25; } } // L2 normalize const norm = Math.sqrt(embedding.reduce((a, b) => a + b * b, 0)); if (norm > 0) { for (let i = 0; i < dim; i++) embedding[i] /= norm; } return embedding; } tokenize(text) { return text.toLowerCase() .replace(/[^\w\s]/g, ' ') .split(/\s+/) .filter(t => t.length > 0); } tokenEmbed(token, dim) { const embedding = new Array(dim).fill(0); for (let i = 0; i < token.length; i++) { const idx = (token.charCodeAt(i) * 31 + i * 17) % dim; embedding[idx] += 1; } const norm = Math.sqrt(embedding.reduce((a, b) => a + b * b, 0)); if (norm > 0) for (let i = 0; i < dim; i++) embedding[i] /= norm; return embedding; } meanPool(embeddings) { if (embeddings.length === 0) return []; const dim = embeddings[0].length; const result = new Array(dim).fill(0); for (const emb of embeddings) { for (let i = 0; i < dim; i++) result[i] += emb[i]; } for (let i = 0; i < dim; i++) result[i] /= embeddings.length; return result; } // ========================================================================= // Memory Operations // ========================================================================= /** * Store content in vector memory (uses ONNX if available) */ async remember(content, type = 'general') { const id = `mem-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`; // Use async ONNX embeddings if available for better semantic quality const embedding = await this.embedAsync(content); const entry = { id, content, type, embedding, created: new Date().toISOString(), accessed: 0, }; this.memories.set(id, entry); // Index in VectorDB if available if (this.vectorDb) { try { await this.vectorDb.insert({ id, vector: new Float32Array(embedding), metadata: JSON.stringify({ content, type, created: entry.created }), }); } catch { // Ignore indexing errors } } return entry; } /** * Semantic search of memories (uses ONNX if available) */ async recall(query, topK = 5) { // Use async ONNX embeddings if available for better semantic quality const queryEmbed = await this.embedAsync(query); // Try VectorDB search first (HNSW - 150x faster) if (this.vectorDb) { try { const results = await this.vectorDb.search({ vector: new Float32Array(queryEmbed), k: topK, }); return results.map((r) => { const entry = this.memories.get(r.id); if (entry) { entry.accessed++; entry.score = 1 - r.score; // Convert distance to similarity } return entry; }).filter((e) => e !== null); } catch { // Fall through to brute force } } // Fallback: brute-force cosine similarity const scored = Array.from(this.memories.values()).map(m => ({ ...m, score: this.cosineSimilarity(queryEmbed, m.embedding), })); return scored .sort((a, b) => (b.score || 0) - (a.score || 0)) .slice(0, topK); } cosineSimilarity(a, b) { if (a.length !== b.length) 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 ? dot / denom : 0; } // ========================================================================= // Agent Routing with SONA // ========================================================================= /** * Route a task to the best agent using learned patterns */ async route(task, file) { const ext = file ? this.getExtension(file) : ''; const state = this.getState(task, ext); const taskEmbed = this.embed(task + ' ' + (file || '')); // Apply SONA micro-LoRA transformation if available let adaptedEmbed = taskEmbed; if (this.sona) { try { adaptedEmbed = this.sona.applyMicroLora(taskEmbed); } catch { // Use original embedding } } // Find similar patterns using ReasoningBank let patterns = []; if (this.sona) { try { patterns = this.sona.findPatterns(adaptedEmbed, 5); } catch { // No patterns } } // Default agent mappings const defaults = { '.rs': 'rust-developer', '.ts': 'typescript-developer', '.tsx': 'react-developer', '.js': 'javascript-developer', '.jsx': 'react-developer', '.py': 'python-developer', '.go': 'go-developer', '.sql': 'database-specialist', '.md': 'documentation-specialist', '.yml': 'devops-engineer', '.yaml': 'devops-engineer', '.json': 'coder', '.toml': 'coder', }; // Check learned patterns first const statePatterns = this.routingPatterns.get(state); let bestAgent = defaults[ext] || 'coder'; let bestScore = 0.5; let reason = 'default mapping'; if (statePatterns && statePatterns.size > 0) { for (const [agent, score] of statePatterns) { if (score > bestScore) { bestAgent = agent; bestScore = score; reason = 'learned from patterns'; } } } // Check custom agent mappings if (this.agentMappings.has(ext)) { const mapped = this.agentMappings.get(ext); if (bestScore < 0.8) { bestAgent = mapped; bestScore = 0.8; reason = 'custom mapping'; } } // Boost confidence if SONA patterns match if (patterns.length > 0 && patterns[0].avgQuality > 0.7) { bestScore = Math.min(1.0, bestScore + 0.1); reason += ' + SONA pattern match'; } return { agent: bestAgent, confidence: Math.min(1.0, bestScore), reason, patterns: patterns.length > 0 ? patterns : undefined, alternates: this.getAlternates(statePatterns, bestAgent), }; } getExtension(file) { const idx = file.lastIndexOf('.'); return idx >= 0 ? file.slice(idx).toLowerCase() : ''; } getState(task, ext) { const taskType = task.includes('fix') ? 'fix' : task.includes('test') ? 'test' : task.includes('refactor') ? 'refactor' : task.includes('document') ? 'docs' : 'edit'; return `${taskType}:${ext || 'unknown'}`; } getAlternates(patterns, exclude) { if (!patterns) return []; return Array.from(patterns.entries()) .filter(([a]) => a !== exclude) .sort((a, b) => b[1] - a[1]) .slice(0, 3) .map(([agent, confidence]) => ({ agent, confidence: Math.min(1.0, confidence) })); } // ========================================================================= // Trajectory Learning // ========================================================================= /** * Begin recording a trajectory (before edit/command) */ beginTrajectory(context, file) { const embed = this.embed(context + ' ' + (file || '')); if (this.sona) { try { this.currentTrajectoryId = this.sona.beginTrajectory(embed); if (file) { this.sona.addContext(this.currentTrajectoryId, file); } } catch { this.currentTrajectoryId = null; } } } /** * Add a step to the current trajectory */ addTrajectoryStep(activations, reward) { if (this.sona && this.currentTrajectoryId !== null) { try { const attentionWeights = new Array(activations.length).fill(1 / activations.length); this.sona.addStep(this.currentTrajectoryId, activations, attentionWeights, reward); } catch { // Ignore step errors } } } /** * End the current trajectory with a quality score */ endTrajectory(success, quality) { const q = quality ?? (success ? 0.9 : 0.3); if (this.sona && this.currentTrajectoryId !== null) { try { this.sona.endTrajectory(this.currentTrajectoryId, q); } catch { // Ignore end errors } } this.currentTrajectoryId = null; } /** * Set the agent route for current trajectory */ setTrajectoryRoute(agent) { if (this.sona && this.currentTrajectoryId !== null) { try { this.sona.setRoute(this.currentTrajectoryId, agent); } catch { // Ignore route errors } } } // ========================================================================= // Episode Learning (Q-learning compatible) // ========================================================================= /** * Record an episode for learning */ async recordEpisode(state, action, reward, nextState, done, metadata) { const stateEmbed = this.embed(state); const nextStateEmbed = this.embed(nextState); // Store in FastAgentDB await this.agentDb.storeEpisode({ state: stateEmbed, action, reward, nextState: nextStateEmbed, done, metadata, }); // Update routing patterns (Q-learning style) if (!this.routingPatterns.has(state)) { this.routingPatterns.set(state, new Map()); } const patterns = this.routingPatterns.get(state); const oldValue = patterns.get(action) || 0.5; const newValue = oldValue + this.config.learningRate * (reward - oldValue); patterns.set(action, newValue); } /** * Queue episode for batch processing (3-4x faster with workers) */ queueEpisode(episode) { this.episodeBatchQueue.push(episode); } /** * Process queued episodes in parallel batch */ async flushEpisodeBatch() { if (this.episodeBatchQueue.length === 0) return 0; const count = this.episodeBatchQueue.length; if (this.parallel) { // Use parallel workers for batch processing await this.parallel.recordEpisodesBatch(this.episodeBatchQueue); } else { // Sequential fallback for (const ep of this.episodeBatchQueue) { await this.recordEpisode(ep.state, ep.action, ep.reward, ep.nextState, ep.done, ep.metadata); } } this.episodeBatchQueue = []; return count; } /** * Learn from similar past episodes */ async learnFromSimilar(state, k = 5) { const stateEmbed = this.embed(state); return this.agentDb.searchByState(stateEmbed, k); } // ========================================================================= // Worker-Agent Mappings // ========================================================================= /** * Register worker trigger to agent mappings */ registerWorkerTrigger(trigger, priority, agents) { this.workerTriggerMappings.set(trigger, { priority, agents }); } /** * Get agents for a worker trigger */ getAgentsForTrigger(trigger) { return this.workerTriggerMappings.get(trigger); } /** * Route a task using worker trigger patterns first, then fall back to regular routing */ async routeWithWorkers(task, file) { // Check if task matches any worker trigger patterns const taskLower = task.toLowerCase(); for (const [trigger, config] of this.workerTriggerMappings) { if (taskLower.includes(trigger)) { const primaryAgent = config.agents[0] || 'coder'; const alternates = config.agents.slice(1).map(a => ({ agent: a, confidence: 0.7 })); return { agent: primaryAgent, confidence: config.priority === 'critical' ? 0.95 : config.priority === 'high' ? 0.85 : config.priority === 'medium' ? 0.75 : 0.65, reason: `worker trigger: ${trigger}`, alternates, }; } } // Fall back to regular routing return this.route(task, file); } /** * Initialize default worker trigger mappings */ initDefaultWorkerMappings() { const defaults = [ ['ultralearn', 'high', ['researcher', 'coder']], ['optimize', 'high', ['performance-analyzer']], ['audit', 'critical', ['security-analyst', 'tester']], ['map', 'medium', ['architect']], ['security', 'critical', ['security-analyst']], ['benchmark', 'low', ['performance-analyzer']], ['document', 'medium', ['documenter']], ['refactor', 'medium', ['coder', 'reviewer']], ['testgaps', 'high', ['tester']], ['deepdive', 'low', ['researcher']], ['predict', 'medium', ['analyst']], ['consolidate', 'low', ['architect']], ]; for (const [trigger, priority, agents] of defaults) { this.workerTriggerMappings.set(trigger, { priority, agents }); } } // ========================================================================= // Co-edit Pattern Learning // ========================================================================= /** * Record a co-edit pattern */ recordCoEdit(file1, file2) { if (!this.coEditPatterns.has(file1)) { this.coEditPatterns.set(file1, new Map()); } if (!this.coEditPatterns.has(file2)) { this.coEditPatterns.set(file2, new Map()); } const count1 = this.coEditPatterns.get(file1).get(file2) || 0; this.coEditPatterns.get(file1).set(file2, count1 + 1); const count2 = this.coEditPatterns.get(file2).get(file1) || 0; this.coEditPatterns.get(file2).set(file1, count2 + 1); } /** * Get likely next files to edit */ getLikelyNextFiles(file, topK = 5) { const related = this.coEditPatterns.get(file); if (!related) return []; return Array.from(related.entries()) .sort((a, b) => b[1] - a[1]) .slice(0, topK) .map(([f, count]) => ({ file: f, count })); } // ========================================================================= // Error Pattern Learning // ========================================================================= /** * Record an error pattern with fixes */ recordErrorFix(errorPattern, fix) { if (!this.errorPatterns.has(errorPattern)) { this.errorPatterns.set(errorPattern, []); } const fixes = this.errorPatterns.get(errorPattern); if (!fixes.includes(fix)) { fixes.push(fix); } } /** * Get suggested fixes for an error */ getSuggestedFixes(error) { // Exact match if (this.errorPatterns.has(error)) { return this.errorPatterns.get(error); } // Fuzzy match by embedding similarity const errorEmbed = this.embed(error); const matches = []; for (const [pattern, fixes] of this.errorPatterns) { const patternEmbed = this.embed(pattern); const similarity = this.cosineSimilarity(errorEmbed, patternEmbed); if (similarity > 0.7) { matches.push({ pattern, similarity, fixes }); } } if (matches.length === 0) return []; // Return fixes from most similar pattern matches.sort((a, b) => b.similarity - a.similarity); return matches[0].fixes; } // ========================================================================= // Tick / Background Learning // ========================================================================= /** * Run background learning cycle */ tick() { if (this.sona) { try { return this.sona.tick(); } catch { return null; } } return null; } /** * Force immediate learning */ forceLearn() { if (this.sona) { try { return this.sona.forceLearn(); } catch { return null; } } return null; } // ========================================================================= // Statistics // ========================================================================= /** * Get comprehensive learning statistics */ getStats() { const agentDbStats = this.agentDb.getStats(); let sonaStats = null; if (this.sona) { try { sonaStats = this.sona.getStats(); } catch { // No SONA stats } } // Calculate average reward from patterns let totalReward = 0; let rewardCount = 0; for (const patterns of this.routingPatterns.values()) { for (const reward of patterns.values()) { totalReward += reward; rewardCount++; } } const parallelStats = this.parallel?.getStats() ?? { enabled: false, workers: 0, busy: 0, queued: 0 }; return { totalMemories: this.memories.size, memoryDimensions: this.config.embeddingDim, totalEpisodes: agentDbStats.episodeCount, totalTrajectories: agentDbStats.trajectoryCount, avgReward: rewardCount > 0 ? totalReward / rewardCount : 0, sonaEnabled: this.sona !== null, trajectoriesRecorded: sonaStats?.trajectoriesRecorded ?? 0, patternsLearned: sonaStats?.patternsLearned ?? 0, microLoraUpdates: sonaStats?.microLoraUpdates ?? 0, baseLoraUpdates: sonaStats?.baseLoraUpdates ?? 0, ewcConsolidations: sonaStats?.ewcConsolidations ?? 0, routingPatterns: this.routingPatterns.size, errorPatterns: this.errorPatterns.size, coEditPatterns: this.coEditPatterns.size, workerTriggers: this.workerTriggerMappings.size, attentionEnabled: this.attention !== null, onnxEnabled: this.onnxReady, parallelEnabled: parallelStats.enabled, parallelWorkers: parallelStats.workers, parallelBusy: parallelStats.busy, parallelQueued: parallelStats.queued, }; } // ========================================================================= // Persistence // ========================================================================= /** * Export all data for persistence */ export() { return { version: '2.0.0', exported: new Date().toISOString(), config: this.config, memories: Array.from(this.memories.values()), routingPatterns: Object.fromEntries(Array.from(this.routingPatterns.entries()).map(([k, v]) => [ k, Object.fromEntries(v), ])), errorPatterns: Object.fromEntries(this.errorPatterns), coEditPatterns: Object.fromEntries(Array.from(this.coEditPatterns.entries()).map(([k, v]) => [ k, Object.fromEntries(v), ])), agentMappings: Object.fromEntries(this.agentMappings), workerTriggerMappings: Object.fromEntries(Array.from(this.workerTriggerMappings.entries()).map(([k, v]) => [k, v])), stats: this.getStats(), }; } /** * Import data from persistence */ import(data, merge = false) { if (!merge) { this.memories.clear(); this.routingPatterns.clear(); this.errorPatterns.clear(); this.coEditPatterns.clear(); this.agentMappings.clear(); } // Import memories if (data.memories) { for (const mem of data.memories) { this.memories.set(mem.id, mem); } } // Import routing patterns if (data.routingPatterns) { for (const [state, actions] of Object.entries(data.routingPatterns)) { const map = new Map(Object.entries(actions)); if (merge && this.routingPatterns.has(state)) { const existing = this.routingPatterns.get(state); for (const [action, value] of map) { existing.set(action, Math.max(existing.get(action) || 0, value)); } } else { this.routingPatterns.set(state, map); } } } // Import error patterns if (data.errorPatterns) { for (const [pattern, fixes] of Object.entries(data.errorPatterns)) { if (merge && this.errorPatterns.has(pattern)) { const existing = this.errorPatterns.get(pattern); for (const fix of fixes) { if (!existing.includes(fix)) existing.push(fix); } } else { this.errorPatterns.set(pattern, fixes); } } } // Import co-edit patterns if (data.coEditPatterns) { for (const [file, related] of Object.entries(data.coEditPatterns)) { const map = new Map(Object.entries(related)); if (merge && this.coEditPatterns.has(file)) { const existing = this.coEditPatterns.get(file); for (const [f, count] of map) { existing.set(f, (existing.get(f) || 0) + count); } } else { this.coEditPatterns.set(file, map); } } } // Import agent mappings if (data.agentMappings) { for (const [ext, agent] of Object.entries(data.agentMappings)) { this.agentMappings.set(ext, agent); } } // Import worker trigger mappings if (data.workerTriggerMappings) { for (const [trigger, config] of Object.entries(data.workerTriggerMappings)) { const typedConfig = config; this.workerTriggerMappings.set(trigger, typedConfig); } } } /** * Clear all data */ clear() { this.memories.clear(); this.routingPatterns.clear(); this.errorPatterns.clear(); this.coEditPatterns.clear(); this.agentMappings.clear(); this.workerTriggerMappings.clear(); this.agentDb.clear(); } // ========================================================================= // Compatibility with existing Intelligence class // ========================================================================= /** Legacy: patterns object */ get patterns() { const result = {}; for (const [state, actions] of this.routingPatterns) { result[state] = Object.fromEntries(actions); } return result; } /** Legacy: file_sequences array */ get file_sequences() { const sequences = []; for (const [file, related] of this.coEditPatterns) { const sorted = Array.from(related.entries()) .sort((a, b) => b[1] - a[1]) .map(([f]) => f); if (sorted.length > 0) { sequences.push([file, ...sorted.slice(0, 3)]); } } return sequences; } /** Legacy: errors object */ get errors() { return Object.fromEntries(this.errorPatterns); } } exports.IntelligenceEngine = IntelligenceEngine; // ============================================================================ // Factory Functions // ============================================================================ /** * Create a new IntelligenceEngine with default settings */ function createIntelligenceEngine(config) { return new IntelligenceEngine(config); } /** * Create a high-performance engine with all features enabled */ function createHighPerformanceEngine() { return new IntelligenceEngine({ embeddingDim: 512, maxMemories: 200000, maxEpisodes: 100000, enableSona: true, enableAttention: true, sonaConfig: { hiddenDim: 512, microLoraRank: 2, baseLoraRank: 16, patternClusters: 200, }, }); } /** * Create a lightweight engine for fast startup */ function createLightweightEngine() { return new IntelligenceEngine({ embeddingDim: 128, maxMemories: 10000, maxEpisodes: 5000, enableSona: false, enableAttention: false, }); } exports.default = IntelligenceEngine;