agentic-qe 2.5.8 → 2.5.10

package/dist/agents/BaseAgent.js

@@ -20,6 +20,8 @@ const AgentCoordinator_1 = require("./coordination/AgentCoordinator");
 const AgentMemoryService_1 = require("./memory/AgentMemoryService");
 const RuvllmProvider_1 = require("../providers/RuvllmProvider");
 const LLMProviderFactory_1 = require("../providers/LLMProviderFactory");
+// HybridRouter with RuVector cache (Phase 0.5 - GNN Self-Learning)
+const HybridRouter_1 = require("../providers/HybridRouter");
 const adapters_1 = require("./adapters");
 // Extracted utilities (B1.2)
 const utils_1 = require("./utils");
@@ -30,15 +32,32 @@ class BaseAgent extends events_1.EventEmitter {
         super();
         this.performanceMetrics = { tasksCompleted: 0, averageExecutionTime: 0, errorCount: 0, lastActivity: new Date() };
         this.federatedInitialized = false;
+        this.patternStoreInitialized = false;
         this.agentId = { id: config.id || (0, utils_1.generateAgentId)(config.type), type: config.type, created: new Date() };
-        this.capabilities = new Map(config.capabilities.map(cap => [cap.name, cap]));
+        this.capabilities = new Map((config.capabilities || []).map(cap => [cap.name, cap]));
         this.context = config.context;
         this.memoryStore = config.memoryStore;
-        this.eventBus = config.eventBus;
+        this.eventBus = config.eventBus || new events_1.EventEmitter();
         this.enableLearning = config.enableLearning ?? true;
         this.learningConfig = config.learningConfig;
         // LLM configuration (Phase 0 - default enabled with RuvLLM)
         this.llmConfig = config.llm ?? { enabled: true, preferredProvider: 'ruvllm' };
+        // QE Pattern Store configuration (Phase 0.5 - RuVector Integration)
+        // Environment variables take precedence, then config, then defaults
+        // RuVector is OPT-IN to maintain backward compatibility with existing users
+        const envRuVectorEnabled = process.env.AQE_RUVECTOR_ENABLED?.toLowerCase() === 'true';
+        const envRuVectorUrl = process.env.AQE_RUVECTOR_URL || process.env.RUVECTOR_URL;
+        const envPatternStoreEnabled = process.env.AQE_PATTERN_STORE_ENABLED?.toLowerCase() !== 'false';
+        this.qePatternConfig = {
+            enabled: config.patternStore?.enabled ?? envPatternStoreEnabled,
+            // RuVector defaults to FALSE - opt-in for advanced self-learning
+            useRuVector: config.patternStore?.useRuVector ?? envRuVectorEnabled,
+            useHNSW: config.patternStore?.useHNSW ?? true,
+            dualWrite: config.patternStore?.dualWrite ?? (process.env.AQE_PATTERN_DUAL_WRITE === 'true'),
+            ruvectorUrl: config.patternStore?.ruvectorUrl ?? envRuVectorUrl ?? 'postgresql://ruvector:ruvector@localhost:5432/ruvector_db',
+            storagePath: config.patternStore?.storagePath ?? process.env.AQE_PATTERN_STORE_PATH ?? './data/qe-patterns.ruvector',
+            autoSync: config.patternStore?.autoSync ?? (process.env.AQE_PATTERN_AUTO_SYNC === 'true'),
+        };
         // Early validation (Issue #137)
         const validation = (0, utils_1.validateLearningConfig)(config);
         if (!validation.valid && validation.warning) {
@@ -103,6 +122,8 @@ class BaseAgent extends events_1.EventEmitter {
                     await this.initializeLLMProvider();
                     // Initialize Federated Learning (Phase 0 M0.5)
                     await this.initializeFederatedLearning();
+                    // Initialize QE Pattern Store (Phase 0.5)
+                    await this.initializePatternStore();
                     await this.initializeComponents();
                     await this.executeHook('post-initialization');
                     this.coordinator.emitEvent('agent.initialized', { agentId: this.agentId });
@@ -158,6 +179,7 @@ class BaseAgent extends events_1.EventEmitter {
                     await this.cleanup();
                     await this.cleanupLLM(); // Phase 0: Cleanup LLM resources
                     await this.cleanupFederated(); // Phase 0 M0.5: Cleanup federated learning
+                    await this.cleanupPatternStore(); // Phase 0.5: Cleanup pattern store
                     this.coordinator.clearAllHandlers();
                 },
                 onPostTermination: async () => {
@@ -413,7 +435,8 @@ class BaseAgent extends events_1.EventEmitter {
                 await this[method](data);
         }
         catch (error) {
-            console.error(`Hook ${hookName} failed:`, error);
+            // Use warn - hooks are optional and failures shouldn't break agent operation
+            console.warn(`Hook ${hookName} failed:`, error);
         }
     }
     setupEventHandlers() {
@@ -472,7 +495,7 @@ class BaseAgent extends events_1.EventEmitter {
     // ============================================
     /**
      * Initialize LLM provider for agent use
-     * Supports RuvLLM (local), Claude, and OpenRouter providers
+     * Supports RuvLLM (local), Claude, OpenRouter, and HybridRouter with RuVector cache
      */
     async initializeLLMProvider() {
         if (!this.llmConfig.enabled) {
@@ -486,6 +509,37 @@ class BaseAgent extends events_1.EventEmitter {
                 console.log(`[${this.agentId.id}] Using injected LLM provider`);
                 return;
             }
+            // Phase 0.5: Create HybridRouter with RuVector GNN cache for intelligent routing
+            if (this.llmConfig.enableHybridRouter || this.llmConfig.preferredProvider === 'hybrid') {
+                const hybridConfig = {
+                    // RuVector cache configuration (GNN self-learning)
+                    ruvector: {
+                        enabled: true,
+                        baseUrl: this.llmConfig.ruvectorCache?.baseUrl || 'http://localhost:8080',
+                        cacheThreshold: this.llmConfig.ruvectorCache?.cacheThreshold ?? 0.85,
+                        learningEnabled: this.llmConfig.ruvectorCache?.learningEnabled ?? true,
+                        loraRank: this.llmConfig.ruvectorCache?.loraRank ?? 8,
+                        ewcEnabled: this.llmConfig.ruvectorCache?.ewcEnabled ?? true,
+                        ...this.llmConfig.ruvectorCache,
+                    },
+                    // Local LLM via ruvllm
+                    ruvllm: {
+                        name: `${this.agentId.id}-ruvllm`,
+                        enableSessions: this.llmConfig.enableSessions ?? true,
+                        enableTRM: true,
+                        enableSONA: true,
+                        ...this.llmConfig.ruvllm,
+                    },
+                    // Routing strategy
+                    defaultStrategy: this.llmConfig.hybridRouterConfig?.defaultStrategy || HybridRouter_1.RoutingStrategy.BALANCED,
+                    ...this.llmConfig.hybridRouterConfig,
+                };
+                this.hybridRouter = new HybridRouter_1.HybridRouter(hybridConfig);
+                await this.hybridRouter.initialize();
+                this.llmProvider = this.hybridRouter;
+                console.log(`[${this.agentId.id}] HybridRouter initialized with RuVector GNN cache`);
+                return;
+            }
             // Create RuvLLM provider directly (preferred for local inference)
             if (this.llmConfig.preferredProvider === 'ruvllm' || !this.llmConfig.preferredProvider) {
                 const ruvllmConfig = {
@@ -524,7 +578,8 @@ class BaseAgent extends events_1.EventEmitter {
             }
         }
         catch (error) {
-            console.error(`[${this.agentId.id}] LLM initialization failed:`, error.message);
+            // Use warn instead of error - this is expected fallback behavior, not a failure
+            console.warn(`[${this.agentId.id}] LLM initialization failed:`, error.message);
             // Don't throw - agent can still work without LLM (algorithmic fallback)
         }
     }
@@ -559,7 +614,8 @@ class BaseAgent extends events_1.EventEmitter {
             }
         }
         catch (error) {
-            console.error(`[${this.agentId.id}] Federated learning initialization failed:`, error.message);
+            // Use warn instead of error - this is expected fallback behavior
+            console.warn(`[${this.agentId.id}] Federated learning initialization failed:`, error.message);
             // Don't throw - agent can work without federated learning
         }
     }
@@ -760,9 +816,401 @@ class BaseAgent extends events_1.EventEmitter {
         return {
             available: this.hasLLM(),
             sessionId: this.llmSessionId,
-            provider: this.llmProvider ? 'ruvllm' : undefined
+            provider: this.hybridRouter ? 'hybrid' : (this.llmProvider ? 'ruvllm' : undefined),
+            hasRuVectorCache: this.hasRuVectorCache(),
+            hasPatternStore: this.hasPatternStore(),
+            patternStoreType: this.hasPatternStore() ?
+                this.qePatternStore?.getImplementationInfo?.()?.type :
+                undefined,
         };
     }
+    // ============================================
+    // RuVector Cache Methods (Phase 0.5 - GNN Self-Learning)
+    // ============================================
+    /**
+     * Check if RuVector GNN cache is available
+     */
+    hasRuVectorCache() {
+        return this.hybridRouter !== undefined;
+    }
+    /**
+     * Get RuVector cache metrics
+     * Returns cache hit rate, pattern count, and learning metrics
+     */
+    async getRuVectorMetrics() {
+        if (!this.hybridRouter) {
+            return null;
+        }
+        try {
+            return await this.hybridRouter.getRuVectorMetrics();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get cache hit rate for this agent's requests
+     */
+    getCacheHitRate() {
+        if (!this.hybridRouter) {
+            return 0;
+        }
+        return this.hybridRouter.getCacheHitRate();
+    }
+    /**
+     * Get routing statistics including cache savings
+     */
+    getRoutingStats() {
+        if (!this.hybridRouter) {
+            return {
+                totalDecisions: 0,
+                localDecisions: 0,
+                cloudDecisions: 0,
+                cacheHits: 0,
+                cacheMisses: 0,
+                cacheHitRate: 0,
+                averageLocalLatency: 0,
+                averageCloudLatency: 0,
+                successRate: 0,
+            };
+        }
+        return this.hybridRouter.getRoutingStats();
+    }
+    /**
+     * Force learning consolidation in the RuVector cache
+     * Triggers LoRA adaptation and EWC++ protection
+     */
+    async forceRuVectorLearn() {
+        if (!this.hybridRouter) {
+            return { success: false, error: 'RuVector not enabled' };
+        }
+        return await this.hybridRouter.forceRuVectorLearn();
+    }
+    /**
+     * Get cost savings report from using RuVector cache
+     */
+    getCostSavingsReport() {
+        if (!this.hybridRouter) {
+            return {
+                totalRequests: 0,
+                localRequests: 0,
+                cloudRequests: 0,
+                totalCost: 0,
+                estimatedCloudCost: 0,
+                savings: 0,
+                savingsPercentage: 0,
+                cacheHits: 0,
+                cacheSavings: 0,
+            };
+        }
+        return this.hybridRouter.getCostSavingsReport();
+    }
+    /**
+     * Make an LLM call with automatic caching and learning
+     * Uses RuVector GNN cache when available for sub-ms pattern matching
+     *
+     * @param prompt - The prompt to process
+     * @param options - Additional options
+     * @returns The response text
+     */
+    async llmCompleteWithLearning(prompt, options) {
+        if (!this.llmProvider) {
+            throw new Error(`[${this.agentId.id}] LLM not available - initialize agent first`);
+        }
+        // If using HybridRouter, it automatically handles caching and learning
+        if (this.hybridRouter) {
+            const completionOptions = {
+                model: options?.model || 'auto',
+                messages: [{ role: 'user', content: prompt }],
+                maxTokens: options?.maxTokens,
+                temperature: options?.temperature,
+                metadata: {
+                    ...options?.metadata,
+                    agentId: this.agentId.id,
+                    agentType: this.agentId.type,
+                    complexity: options?.complexity,
+                },
+            };
+            const response = await this.hybridRouter.complete(completionOptions);
+            // Extract text from response
+            const text = response.content
+                .filter(block => block.type === 'text')
+                .map(block => block.text)
+                .join('\n');
+            return {
+                response: text,
+                source: response.metadata?.source || 'local',
+                confidence: response.metadata?.confidence,
+            };
+        }
+        // Fallback to regular completion
+        const text = await this.llmComplete(prompt, options);
+        return { response: text, source: 'local' };
+    }
+    // ============================================
+    // QE Pattern Store Methods (Phase 0.5 - RuVector Integration)
+    // ============================================
+    /**
+     * Initialize QE Pattern Store for learned pattern storage
+     * Supports both RuVector Docker (150x faster) and local HNSW fallback
+     */
+    async initializePatternStore() {
+        if (!this.qePatternConfig.enabled) {
+            console.log(`[${this.agentId.id}] QE Pattern Store disabled by configuration`);
+            return;
+        }
+        try {
+            // Phase 0.5: Use PostgreSQL adapter when RuVector is enabled
+            if (this.qePatternConfig.useRuVector) {
+                try {
+                    const { createDockerRuVectorAdapter } = require('../providers/RuVectorPostgresAdapter');
+                    // Parse PostgreSQL connection URL or use defaults
+                    const url = this.qePatternConfig.ruvectorUrl || '';
+                    const isPostgres = url.startsWith('postgresql://') || url.startsWith('postgres://');
+                    if (isPostgres) {
+                        // Parse connection URL
+                        const parsed = new URL(url);
+                        this.qePatternStore = createDockerRuVectorAdapter({
+                            host: parsed.hostname,
+                            port: parseInt(parsed.port) || 5432,
+                            database: parsed.pathname.slice(1) || 'ruvector_db',
+                            user: parsed.username || 'ruvector',
+                            password: parsed.password || 'ruvector',
+                            learningEnabled: true,
+                            cacheThreshold: 0.85,
+                        });
+                    }
+                    else {
+                        // Use default Docker configuration
+                        this.qePatternStore = createDockerRuVectorAdapter({
+                            host: process.env.RUVECTOR_HOST || 'localhost',
+                            port: parseInt(process.env.RUVECTOR_PORT || '5432'),
+                            database: process.env.RUVECTOR_DATABASE || 'ruvector_db',
+                            user: process.env.RUVECTOR_USER || 'ruvector',
+                            password: process.env.RUVECTOR_PASSWORD || 'ruvector',
+                            learningEnabled: true,
+                            cacheThreshold: 0.85,
+                        });
+                    }
+                    await this.qePatternStore.initialize();
+                    this.patternStoreInitialized = true;
+                    console.log(`[${this.agentId.id}] QE Pattern Store initialized (RuVector PostgreSQL: enabled)`);
+                    return;
+                }
+                catch (postgresError) {
+                    console.warn(`[${this.agentId.id}] RuVector PostgreSQL unavailable, falling back to HNSW:`, postgresError.message);
+                    // Fall through to HNSW fallback
+                }
+            }
+            // Fallback: Use local RuVectorPatternStore (HNSW-based)
+            const { RuVectorPatternStore } = require('../memory/RuVectorPatternStore');
+            // Configure pattern store with local HNSW
+            const storeConfig = {
+                dimension: 384,
+                metric: 'cosine',
+                storagePath: this.qePatternConfig.storagePath,
+                autoPersist: true,
+                enableMetrics: true,
+                hnsw: {
+                    m: 32,
+                    efConstruction: 200,
+                    efSearch: 100,
+                },
+            };
+            this.qePatternStore = new RuVectorPatternStore(storeConfig);
+            await this.qePatternStore.initialize();
+            this.patternStoreInitialized = true;
+            console.log(`[${this.agentId.id}] QE Pattern Store initialized (HNSW fallback)`);
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Pattern Store initialization failed:`, error.message);
+            // Don't throw - agent can work without pattern store
+        }
+    }
+    /**
+     * Check if QE pattern store is available
+     */
+    hasPatternStore() {
+        return this.patternStoreInitialized && this.qePatternStore !== undefined;
+    }
+    /**
+     * Store a QE learned pattern
+     * Automatically uses RuVector when available, falls back to HNSW
+     *
+     * @param pattern - The QE pattern to store
+     * @returns Success status
+     */
+    async storeQEPattern(pattern) {
+        if (!this.hasPatternStore()) {
+            return { success: false };
+        }
+        try {
+            const testPattern = {
+                id: pattern.id,
+                type: pattern.type,
+                domain: pattern.domain,
+                content: pattern.content,
+                embedding: pattern.embedding,
+                framework: pattern.framework,
+                coverage: pattern.coverage,
+                createdAt: Date.now(),
+                lastUsed: Date.now(),
+                usageCount: 0,
+                metadata: {
+                    agentId: this.agentId.id,
+                    agentType: this.agentId.type,
+                    ...pattern.metadata,
+                },
+            };
+            // Use auto-sync variant if enabled
+            if (this.qePatternConfig.autoSync && this.qePatternStore.storeWithSync) {
+                const result = await this.qePatternStore.storeWithSync(testPattern);
+                return { success: result.stored, synced: result.synced };
+            }
+            await this.qePatternStore.storePattern(testPattern);
+            return { success: true };
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Failed to store QE pattern:`, error.message);
+            return { success: false };
+        }
+    }
+    /**
+     * Search for similar QE patterns
+     * Uses RuVector's 150x faster search when available
+     *
+     * @param embedding - Query embedding vector
+     * @param k - Number of results to return (default: 10)
+     * @param options - Additional search options
+     * @returns Array of similar patterns with scores
+     */
+    async searchQEPatterns(embedding, k = 10, options) {
+        if (!this.hasPatternStore()) {
+            return [];
+        }
+        try {
+            const results = await this.qePatternStore.searchSimilar(embedding, {
+                k,
+                domain: options?.domain,
+                type: options?.type,
+                framework: options?.framework,
+                threshold: options?.threshold ?? 0.7,
+                useMMR: options?.useMMR ?? false,
+            });
+            return results;
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Pattern search failed:`, error.message);
+            return [];
+        }
+    }
+    /**
+     * Get QE pattern store metrics
+     * Returns performance and usage statistics
+     */
+    getQEPatternMetrics() {
+        if (!this.hasPatternStore()) {
+            return null;
+        }
+        try {
+            const stats = this.qePatternStore.getStats?.();
+            const perfMetrics = this.qePatternStore.getPerformanceMetrics?.();
+            const metrics = {
+                enabled: true,
+                patternCount: stats?.count ?? 0,
+                implementation: stats?.implementation ?? 'fallback',
+            };
+            if (perfMetrics) {
+                metrics.performance = {
+                    avgSearchTime: perfMetrics.avgSearchTime,
+                    p50SearchTime: perfMetrics.p50SearchTime,
+                    p99SearchTime: perfMetrics.p99SearchTime,
+                    estimatedQPS: perfMetrics.estimatedQPS,
+                };
+            }
+            // GNN learning metrics if available
+            if (this.qePatternStore.isGNNEnabled?.()) {
+                const gnnMetrics = this.qePatternStore.getGNNMetrics?.();
+                if (gnnMetrics) {
+                    metrics.gnnLearning = {
+                        enabled: gnnMetrics.enabled,
+                        cacheHitRate: gnnMetrics.cacheHitRate,
+                        patternsLearned: gnnMetrics.patternsLearned,
+                    };
+                }
+            }
+            return metrics;
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Failed to get pattern metrics:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Sync local patterns to remote RuVector service
+     * Only applicable when RuVector Docker is enabled
+     */
+    async syncPatternsToRemote(options) {
+        if (!this.hasPatternStore() || !this.qePatternStore.syncToRemote) {
+            return { synced: 0, failed: 0, duration: 0 };
+        }
+        try {
+            const result = await this.qePatternStore.syncToRemote(options);
+            console.log(`[${this.agentId.id}] Synced ${result.synced} patterns to remote (${result.duration}ms)`);
+            return result;
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Pattern sync failed:`, error.message);
+            return { synced: 0, failed: 0, duration: 0 };
+        }
+    }
+    /**
+     * Force GNN learning consolidation on remote service
+     * Triggers LoRA parameter updates with EWC protection
+     */
+    async forcePatternLearning() {
+        if (!this.hasPatternStore() || !this.qePatternStore.forceGNNLearn) {
+            return { success: false, patternsConsolidated: 0, duration: 0 };
+        }
+        try {
+            const result = await this.qePatternStore.forceGNNLearn({
+                domain: this.agentId.type,
+            });
+            return {
+                success: result.success,
+                patternsConsolidated: result.patternsConsolidated,
+                duration: result.duration,
+            };
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Force learning failed:`, error.message);
+            return { success: false, patternsConsolidated: 0, duration: 0 };
+        }
+    }
+    /**
+     * Cleanup pattern store resources on agent termination
+     */
+    async cleanupPatternStore() {
+        if (!this.patternStoreInitialized || !this.qePatternStore) {
+            return;
+        }
+        try {
+            // Sync pending patterns before shutdown
+            if (this.qePatternConfig.autoSync && this.qePatternStore.syncToRemote) {
+                await this.qePatternStore.syncToRemote({ force: true });
+            }
+            // Shutdown and release resources
+            if (this.qePatternStore.shutdown) {
+                await this.qePatternStore.shutdown();
+            }
+            console.log(`[${this.agentId.id}] Pattern Store cleanup complete`);
+        }
+        catch (error) {
+            console.warn(`[${this.agentId.id}] Pattern Store cleanup error:`, error.message);
+        }
+        this.patternStoreInitialized = false;
+        this.qePatternStore = undefined;
+    }
     /**
      * Cleanup LLM resources on agent termination
      */