agentic-qe 2.1.2 → 2.2.1

package/dist/learning/LearningEngine.d.ts

@@ -6,8 +6,22 @@
  */
 import { SwarmMemoryManager } from '../core/memory/SwarmMemoryManager';
 import { QLearningConfig } from './QLearning';
+import { AbstractRLLearner } from './algorithms/AbstractRLLearner';
 import { TaskResult } from './RewardCalculator';
 import { LearningConfig, TaskExperience, TaskState, AgentAction, LearningFeedback, LearningOutcome, LearnedPattern, FailurePattern, StrategyRecommendation } from './types';
+import { ExperienceSharingProtocol } from './ExperienceSharingProtocol';
+/**
+ * RL Algorithm type selection
+ */
+export type RLAlgorithmType = 'q-learning' | 'sarsa' | 'actor-critic' | 'ppo' | 'maml' | 'legacy';
+/**
+ * Extended learning configuration with algorithm selection
+ */
+export interface ExtendedLearningConfig extends LearningConfig {
+    algorithm?: RLAlgorithmType;
+    enableExperienceSharing?: boolean;
+    experienceSharingPriority?: number;
+}
 /**
  * LearningEngine - Reinforcement learning for agents
  */
@@ -17,6 +31,7 @@ export declare class LearningEngine {
     private readonly agentId;
     private config;
     private qTable;
+    private rlAlgorithm?;
     private qLearning?;
     private useQLearning;
     private experiences;
@@ -24,7 +39,8 @@ export declare class LearningEngine {
     private taskCount;
     private readonly stateExtractor;
     private readonly rewardCalculator;
-    constructor(agentId: string, memoryStore: SwarmMemoryManager, config?: Partial<LearningConfig>);
+    private experienceSharing?;
+    constructor(agentId: string, memoryStore: SwarmMemoryManager, config?: Partial<ExtendedLearningConfig>);
     /**
      * Initialize the learning engine
      *
@@ -41,10 +57,10 @@ export declare class LearningEngine {
      */
     recordExperience(task: any, result: TaskResult, feedback?: LearningFeedback): Promise<void>;
     /**
-     * Load patterns from memoryStore (AgentDB via SwarmMemoryManager)
+     * Load patterns from memoryStore (SwarmMemoryManager -> memory.db)
      *
-     * Architecture: Retrieves patterns from SwarmMemoryManager which
-     * internally uses AgentDB (.agentic-qe/agentdb.db).
+     * Architecture: Retrieves patterns from the unified memory.db database
+     * via SwarmMemoryManager.
      *
      * Note: This method is legacy and not currently used (patterns loaded on-demand).
      */
@@ -227,5 +243,89 @@ export declare class LearningEngine {
      * The shared SwarmMemoryManager handles database lifecycle management.
      */
     dispose(): void;
+    /**
+     * Set the RL algorithm to use (Q-Learning, SARSA, etc.)
+     * Supports dynamic algorithm switching with state transfer
+     */
+    setAlgorithm(algorithm: RLAlgorithmType): void;
+    /**
+     * Disable RL algorithm and revert to legacy Q-table
+     */
+    private disableRLAlgorithm;
+    /**
+     * Import legacy Q-table into current RL algorithm
+     */
+    private importLegacyQTable;
+    /**
+     * Get current RL algorithm type
+     */
+    getAlgorithm(): RLAlgorithmType;
+    /**
+     * Get RL algorithm instance (for advanced use)
+     */
+    getRLAlgorithm(): AbstractRLLearner | undefined;
+    /**
+     * Get algorithm-specific statistics
+     */
+    getAlgorithmStats(): {
+        algorithm: RLAlgorithmType;
+        stats?: ReturnType<AbstractRLLearner['getStatistics']>;
+    };
+    /**
+     * Enable experience sharing with other agents
+     * Connects this LearningEngine to an ExperienceSharingProtocol
+     *
+     * @param protocol - The ExperienceSharingProtocol instance to use
+     */
+    enableExperienceSharing(protocol: ExperienceSharingProtocol): void;
+    /**
+     * Disable experience sharing
+     */
+    disableExperienceSharing(): void;
+    /**
+     * Check if experience sharing is enabled
+     */
+    isExperienceSharingEnabled(): boolean;
+    /**
+     * Get the ExperienceSharingProtocol instance (if enabled)
+     */
+    getExperienceSharingProtocol(): ExperienceSharingProtocol | undefined;
+    /**
+     * Share an experience with other agents
+     * Called internally after learning from execution when sharing is enabled
+     *
+     * @param experience - The experience to share
+     * @param priority - Optional priority override (0-1, higher = more valuable)
+     */
+    shareExperienceWithPeers(experience: TaskExperience, priority?: number): Promise<string | undefined>;
+    /**
+     * Calculate the priority/value of an experience for sharing
+     * Higher rewards and successful experiences get higher priority
+     */
+    private calculateExperiencePriority;
+    /**
+     * Handle an experience received from another agent
+     * Integrates the shared experience into local learning
+     */
+    private handleReceivedExperience;
+    /**
+     * Query relevant experiences from peers for a given state
+     * Useful for transfer learning before executing a task
+     *
+     * @param state - The current task state
+     * @param limit - Maximum number of experiences to retrieve
+     */
+    queryPeerExperiences(state: TaskState, limit?: number): Promise<TaskExperience[]>;
+    /**
+     * Get experience sharing statistics
+     */
+    getExperienceSharingStats(): {
+        enabled: boolean;
+        stats?: {
+            experiencesShared: number;
+            experiencesReceived: number;
+            activeConnections: number;
+        };
+    };
 }
 //# sourceMappingURL=LearningEngine.d.ts.map

package/dist/learning/LearningEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LearningEngine.d.ts","sourceRoot":"","sources":["../../src/learning/LearningEngine.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"LearningEngine.d.ts","sourceRoot":"","sources":["../../src/learning/LearningEngine.ts"],"names":[],"mappings":"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"}

package/dist/learning/LearningEngine.js

@@ -13,9 +13,13 @@ exports.LearningEngine = void 0;
 const uuid_1 = require("uuid");
 const Logger_1 = require("../utils/Logger");
 const QLearning_1 = require("./QLearning");
+const SARSALearner_1 = require("./algorithms/SARSALearner");
+const ActorCriticLearner_1 = require("./algorithms/ActorCriticLearner");
+const PPOLearner_1 = require("./algorithms/PPOLearner");
 const StateExtractor_1 = require("./StateExtractor");
 const RewardCalculator_1 = require("./RewardCalculator");
 const package_json_1 = __importDefault(require("../../package.json"));
+const LearningTelemetry_1 = require("../telemetry/LearningTelemetry");
 const PACKAGE_VERSION = package_json_1.default.version;
 /**
  * Default learning configuration
@@ -29,7 +33,10 @@ const DEFAULT_CONFIG = {
     minExplorationRate: 0.01,
     maxMemorySize: 100 * 1024 * 1024, // 100MB
     batchSize: 32,
-    updateFrequency: 10
+    updateFrequency: 10,
+    algorithm: 'q-learning', // Default to Q-Learning
+    enableExperienceSharing: false, // Disabled by default for backward compatibility
+    experienceSharingPriority: 0.5 // Only share moderately valuable experiences
 };
 /**
  * LearningEngine - Reinforcement learning for agents
@@ -48,13 +55,20 @@ class LearningEngine {
         this.taskCount = 0;
         this.stateExtractor = new StateExtractor_1.StateExtractor();
         this.rewardCalculator = new RewardCalculator_1.RewardCalculator();
-        // Architecture Improvement (Phase 3): LearningEngine now accepts SwarmMemoryManager
-        // directly for unified persistence. This ensures:
-        // 1. All learning patterns persist to .agentic-qe/agentdb.db via SwarmMemoryManager
-        // 2. Unified memory access across all agents
-        // 3. Proper resource management and no duplicate connections
-        // 4. Backward compatibility with QEReasoningBank
-        this.logger.info(`LearningEngine initialized for agent ${agentId} - using ${memoryStore.constructor.name} for persistent storage`);
+        // Initialize RL algorithm if specified
+        if (this.config.algorithm && this.config.algorithm !== 'legacy') {
+            this.setAlgorithm(this.config.algorithm);
+        }
+        // UNIFIED PERSISTENCE ARCHITECTURE (v2.2.0):
+        // LearningEngine uses SwarmMemoryManager for ALL persistence.
+        // All data goes to the SINGLE database: .agentic-qe/memory.db
+        // This ensures CLI, MCP, and agents all share the same data.
+        //
+        // Key methods that persist to memory.db:
+        // - storeLearningExperience() -> learning_experiences table
+        // - storePattern() -> patterns table
+        // - upsertQValue() -> q_values table
+        this.logger.info(`LearningEngine initialized for agent ${agentId} with algorithm ${this.config.algorithm} - using ${memoryStore.constructor.name} for persistent storage`);
     }
     /**
      * Initialize the learning engine
@@ -87,25 +101,25 @@ class LearningEngine {
         await this.learnFromExecution(task, result, feedback);
     }
     /**
-     * Load patterns from memoryStore (AgentDB via SwarmMemoryManager)
+     * Load patterns from memoryStore (SwarmMemoryManager -> memory.db)
      *
-     * Architecture: Retrieves patterns from SwarmMemoryManager which
-     * internally uses AgentDB (.agentic-qe/agentdb.db).
+     * Architecture: Retrieves patterns from the unified memory.db database
+     * via SwarmMemoryManager.
      *
      * Note: This method is legacy and not currently used (patterns loaded on-demand).
      */
     async loadPatternsFromMemoryStore() {
         try {
-            // Query all patterns from AgentDB (confidence >= 0 returns all)
+            // Query all patterns from memory.db (confidence >= 0 returns all)
             const allPatterns = await this.memoryStore.queryPatternsByConfidence(0);
             if (allPatterns.length === 0) {
-                this.logger.info('No existing patterns found in AgentDB');
+                this.logger.info('No existing patterns found in memory.db');
                 return;
             }
-            this.logger.info(`Found ${allPatterns.length} patterns in AgentDB for agent ${this.agentId}`);
+            this.logger.info(`Found ${allPatterns.length} patterns in memory.db for agent ${this.agentId}`);
         }
         catch (error) {
-            this.logger.warn(`Failed to load patterns from AgentDB:`, error);
+            this.logger.warn(`Failed to load patterns from memory.db:`, error);
         }
     }
     /**
@@ -120,6 +134,7 @@ class LearningEngine {
         if (!this.config.enabled) {
             return this.createOutcome(false, 0, 0);
         }
+        const episodeStartTime = Date.now();
         try {
             // Extract experience from task execution
             const experience = this.extractExperience(task, result, feedback);
@@ -129,6 +144,8 @@ class LearningEngine {
             this.experiences.push(experience);
             // Update Q-table (in-memory)
             await this.updateQTable(experience);
+            // Record telemetry: Q-value update occurred
+            (0, LearningTelemetry_1.recordQValueUpdate)(this.agentId, 1, undefined, this.getAlgorithm());
             // Persist to database via memoryStore (replaces persistence adapter)
             // Only if memoryStore is SwarmMemoryManager
             if (this.memoryStore && typeof this.memoryStore.storeLearningExperience === "function") {
@@ -185,6 +202,10 @@ class LearningEngine {
             this.decayExploration();
             // Calculate improvement
             const improvement = await this.calculateImprovement();
+            // Share experience with peers if enabled and valuable
+            if (this.config.enableExperienceSharing && this.experienceSharing) {
+                await this.shareExperienceWithPeers(experience);
+            }
             // Emit learning event
             await this.emitLearningEvent('training', {
                 experience,
@@ -867,9 +888,322 @@ class LearningEngine {
      * The shared SwarmMemoryManager handles database lifecycle management.
      */
     dispose() {
-        // No resources to clean up - memoryStore is managed externally
+        // Clean up experience sharing listeners
+        if (this.experienceSharing) {
+            this.experienceSharing.removeAllListeners('experience_received');
+            this.experienceSharing = undefined;
+        }
         this.logger.debug(`LearningEngine disposed for agent ${this.agentId}`);
     }
+    /**
+     * Set the RL algorithm to use (Q-Learning, SARSA, etc.)
+     * Supports dynamic algorithm switching with state transfer
+     */
+    setAlgorithm(algorithm) {
+        if (algorithm === 'legacy') {
+            // Revert to legacy Q-table implementation
+            this.disableRLAlgorithm();
+            return;
+        }
+        const rlConfig = {
+            learningRate: this.config.learningRate,
+            discountFactor: this.config.discountFactor,
+            explorationRate: this.config.explorationRate,
+            explorationDecay: this.config.explorationDecay,
+            minExplorationRate: this.config.minExplorationRate,
+            useExperienceReplay: true,
+            replayBufferSize: 10000,
+            batchSize: this.config.batchSize
+        };
+        // Export current algorithm state if exists
+        let existingState;
+        if (this.rlAlgorithm) {
+            existingState = this.rlAlgorithm.export();
+        }
+        else if (this.qLearning) {
+            // Migrate from legacy qLearning
+            existingState = this.qLearning.export();
+        }
+        // Create new algorithm instance
+        switch (algorithm) {
+            case 'q-learning':
+                this.rlAlgorithm = new QLearning_1.QLearning(rlConfig);
+                this.qLearning = this.rlAlgorithm; // Backward compatibility
+                this.useQLearning = true;
+                break;
+            case 'sarsa':
+                this.rlAlgorithm = new SARSALearner_1.SARSALearner(rlConfig);
+                this.useQLearning = false; // SARSA is different from Q-Learning
+                break;
+            case 'actor-critic':
+                this.rlAlgorithm = new ActorCriticLearner_1.ActorCriticLearner({
+                    ...rlConfig,
+                    actorLearningRate: rlConfig.learningRate * 0.1,
+                    criticLearningRate: rlConfig.learningRate,
+                    entropyCoefficient: 0.01,
+                    temperature: 1.0,
+                    normalizeAdvantage: true,
+                    targetUpdateFrequency: 100
+                });
+                this.useQLearning = false;
+                break;
+            case 'ppo':
+                this.rlAlgorithm = new PPOLearner_1.PPOLearner({
+                    ...rlConfig,
+                    clipEpsilon: 0.2,
+                    ppoEpochs: 4,
+                    miniBatchSize: 32,
+                    valueLossCoefficient: 0.5,
+                    entropyCoefficient: 0.01,
+                    gaeLambda: 0.95,
+                    maxGradNorm: 0.5,
+                    clipValueLoss: true,
+                    policyLearningRate: rlConfig.learningRate,
+                    valueLearningRate: rlConfig.learningRate * 3
+                });
+                this.useQLearning = false;
+                break;
+            default:
+                throw new Error(`Unknown RL algorithm: ${algorithm}`);
+        }
+        // Import existing state if available
+        if (existingState) {
+            this.rlAlgorithm.import(existingState);
+            this.logger.info(`Migrated existing Q-table to ${algorithm} (${this.rlAlgorithm.getTableSize()} state-action pairs)`);
+        }
+        else if (this.qTable.size > 0) {
+            // Import from legacy Q-table
+            this.importLegacyQTable();
+        }
+        this.config.algorithm = algorithm;
+        this.logger.info(`Switched to ${algorithm} algorithm for agent ${this.agentId}`, { config: rlConfig });
+    }
+    /**
+     * Disable RL algorithm and revert to legacy Q-table
+     */
+    disableRLAlgorithm() {
+        if (this.rlAlgorithm) {
+            // Export RL algorithm state to legacy Q-table
+            const exported = this.rlAlgorithm.export();
+            this.deserializeQTableFromQLearning(exported.qTable);
+        }
+        else if (this.qLearning && this.useQLearning) {
+            // Export from legacy qLearning
+            const exported = this.qLearning.export();
+            this.deserializeQTableFromQLearning(exported.qTable);
+        }
+        this.rlAlgorithm = undefined;
+        this.qLearning = undefined;
+        this.useQLearning = false;
+        this.config.algorithm = 'legacy';
+        this.logger.info(`Disabled RL algorithm for agent ${this.agentId}, reverted to legacy Q-table`);
+    }
+    /**
+     * Import legacy Q-table into current RL algorithm
+     */
+    importLegacyQTable() {
+        if (!this.rlAlgorithm) {
+            return;
+        }
+        const serialized = this.serializeQTableForQLearning();
+        this.rlAlgorithm.import({
+            qTable: serialized,
+            config: {
+                learningRate: this.config.learningRate,
+                discountFactor: this.config.discountFactor,
+                explorationRate: this.config.explorationRate,
+                explorationDecay: this.config.explorationDecay,
+                minExplorationRate: this.config.minExplorationRate,
+                useExperienceReplay: true,
+                replayBufferSize: 10000,
+                batchSize: this.config.batchSize
+            },
+            stepCount: this.taskCount,
+            episodeCount: Math.floor(this.taskCount / 10)
+        });
+        this.logger.info(`Imported legacy Q-table to ${this.config.algorithm} (${this.rlAlgorithm.getTableSize()} state-action pairs)`);
+    }
+    /**
+     * Get current RL algorithm type
+     */
+    getAlgorithm() {
+        return this.config.algorithm ?? 'legacy';
+    }
+    /**
+     * Get RL algorithm instance (for advanced use)
+     */
+    getRLAlgorithm() {
+        return this.rlAlgorithm;
+    }
+    /**
+     * Get algorithm-specific statistics
+     */
+    getAlgorithmStats() {
+        if (this.rlAlgorithm) {
+            return {
+                algorithm: this.config.algorithm ?? 'legacy',
+                stats: this.rlAlgorithm.getStatistics()
+            };
+        }
+        return {
+            algorithm: 'legacy'
+        };
+    }
+    // ============================================================================
+    // Experience Sharing Integration
+    // ============================================================================
+    /**
+     * Enable experience sharing with other agents
+     * Connects this LearningEngine to an ExperienceSharingProtocol
+     *
+     * @param protocol - The ExperienceSharingProtocol instance to use
+     */
+    enableExperienceSharing(protocol) {
+        this.experienceSharing = protocol;
+        this.config.enableExperienceSharing = true;
+        // Subscribe to incoming experiences from other agents
+        protocol.on('experience_received', async (event) => {
+            await this.handleReceivedExperience(event.experienceId);
+        });
+        this.logger.info(`Experience sharing enabled for agent ${this.agentId}`);
+    }
+    /**
+     * Disable experience sharing
+     */
+    disableExperienceSharing() {
+        if (this.experienceSharing) {
+            this.experienceSharing.removeAllListeners('experience_received');
+            this.experienceSharing = undefined;
+        }
+        this.config.enableExperienceSharing = false;
+        this.logger.info(`Experience sharing disabled for agent ${this.agentId}`);
+    }
+    /**
+     * Check if experience sharing is enabled
+     */
+    isExperienceSharingEnabled() {
+        return this.config.enableExperienceSharing === true && this.experienceSharing !== undefined;
+    }
+    /**
+     * Get the ExperienceSharingProtocol instance (if enabled)
+     */
+    getExperienceSharingProtocol() {
+        return this.experienceSharing;
+    }
+    /**
+     * Share an experience with other agents
+     * Called internally after learning from execution when sharing is enabled
+     *
+     * @param experience - The experience to share
+     * @param priority - Optional priority override (0-1, higher = more valuable)
+     */
+    async shareExperienceWithPeers(experience, priority) {
+        if (!this.experienceSharing) {
+            return undefined;
+        }
+        // Calculate priority from reward if not provided
+        const calculatedPriority = priority ?? this.calculateExperiencePriority(experience);
+        // Only share if priority meets threshold
+        if (calculatedPriority < (this.config.experienceSharingPriority ?? 0.5)) {
+            this.logger.debug(`Experience below sharing threshold: ${calculatedPriority} < ${this.config.experienceSharingPriority}`);
+            return undefined;
+        }
+        try {
+            const experienceId = await this.experienceSharing.shareExperience(experience, calculatedPriority);
+            this.logger.debug(`Shared experience with peers: ${experienceId}`, { priority: calculatedPriority });
+            return experienceId;
+        }
+        catch (error) {
+            this.logger.warn('Failed to share experience with peers:', error);
+            return undefined;
+        }
+    }
+    /**
+     * Calculate the priority/value of an experience for sharing
+     * Higher rewards and successful experiences get higher priority
+     */
+    calculateExperiencePriority(experience) {
+        // Base priority from reward (normalized from [-2, 2] to [0, 1])
+        const rewardPriority = (experience.reward + 2) / 4;
+        // Boost for successful experiences (positive reward)
+        const successBoost = experience.reward > 0 ? 0.2 : 0;
+        // Boost for unusual/interesting states (high complexity)
+        const complexityBoost = experience.state.taskComplexity > 0.7 ? 0.1 : 0;
+        return Math.min(1.0, Math.max(0, rewardPriority + successBoost + complexityBoost));
+    }
+    /**
+     * Handle an experience received from another agent
+     * Integrates the shared experience into local learning
+     */
+    async handleReceivedExperience(experienceId) {
+        if (!this.experienceSharing) {
+            return;
+        }
+        try {
+            // Get the shared experience from the protocol
+            const sharedExperiences = await this.experienceSharing.getRelevantExperiences({ taskComplexity: 0, requiredCapabilities: [], contextFeatures: {}, previousAttempts: 0, availableResources: 1 }, 100);
+            const sharedExp = sharedExperiences.find(e => e.id === experienceId);
+            if (!sharedExp) {
+                return; // Experience not found or already processed
+            }
+            // Learn from the shared experience (with reduced weight)
+            // Apply a transfer learning discount factor
+            const transferDiscount = 0.5; // Shared experiences weighted 50%
+            const adjustedExperience = {
+                ...sharedExp.experience,
+                reward: sharedExp.experience.reward * transferDiscount
+            };
+            // Update Q-table with shared experience
+            await this.updateQTable(adjustedExperience);
+            // Store in local experiences buffer
+            this.experiences.push(adjustedExperience);
+            this.logger.debug(`Integrated shared experience: ${experienceId}`, {
+                from: sharedExp.sourceAgentId,
+                originalReward: sharedExp.experience.reward,
+                adjustedReward: adjustedExperience.reward
+            });
+        }
+        catch (error) {
+            this.logger.warn(`Failed to handle received experience ${experienceId}:`, error);
+        }
+    }
+    /**
+     * Query relevant experiences from peers for a given state
+     * Useful for transfer learning before executing a task
+     *
+     * @param state - The current task state
+     * @param limit - Maximum number of experiences to retrieve
+     */
+    async queryPeerExperiences(state, limit = 10) {
+        if (!this.experienceSharing) {
+            return [];
+        }
+        try {
+            const sharedExperiences = await this.experienceSharing.getRelevantExperiences(state, limit);
+            return sharedExperiences.map(se => se.experience);
+        }
+        catch (error) {
+            this.logger.warn('Failed to query peer experiences:', error);
+            return [];
+        }
+    }
+    /**
+     * Get experience sharing statistics
+     */
+    getExperienceSharingStats() {
+        if (!this.experienceSharing) {
+            return { enabled: false };
+        }
+        const stats = this.experienceSharing.getStats();
+        return {
+            enabled: true,
+            stats: {
+                experiencesShared: stats.experiencesShared,
+                experiencesReceived: stats.experiencesReceived,
+                activeConnections: stats.activeConnections
+            }
+        };
+    }
 }
 exports.LearningEngine = LearningEngine;
 //# sourceMappingURL=LearningEngine.js.map