agentic-qe 3.2.3 → 3.3.1

package/v3/dist/learning/aqe-learning-engine.js

@@ -0,0 +1,708 @@
+/**
+ * AQE Learning Engine
+ * Unified learning engine with graceful degradation
+ *
+ * This is the main entry point for AQE's learning capabilities.
+ * It works standalone and optionally integrates with Claude Flow
+ * for enhanced learning features.
+ *
+ * Features:
+ * - Pattern storage and retrieval (standalone)
+ * - HNSW vector search (standalone)
+ * - Task routing to agents (standalone)
+ * - SONA trajectory tracking (when Claude Flow available)
+ * - 3-tier model routing (when Claude Flow available)
+ * - Codebase pretrain analysis (when Claude Flow available)
+ *
+ * @example
+ * ```typescript
+ * // Create engine (works standalone)
+ * const engine = createAQELearningEngine({
+ *   projectRoot: process.cwd(),
+ * });
+ *
+ * // Initialize (auto-detects Claude Flow)
+ * await engine.initialize();
+ *
+ * // Use learning features
+ * const routing = await engine.routeTask('Generate unit tests for UserService');
+ *
+ * // Track task execution (uses SONA if available)
+ * const taskId = await engine.startTask('test-generation', 'qe-test-architect');
+ * await engine.recordStep(taskId, 'analyzed-code', 'Found 5 methods');
+ * await engine.endTask(taskId, true);
+ *
+ * // Get model recommendation (uses CF router if available)
+ * const model = await engine.recommendModel('complex security audit');
+ * ```
+ */
+import { err } from '../shared/types/index.js';
+import { createQEReasoningBank, } from './qe-reasoning-bank.js';
+import { createClaudeFlowBridge, } from '../adapters/claude-flow/index.js';
+import { createExperienceCaptureService, } from './experience-capture.js';
+import { createPatternStore } from './pattern-store.js';
+import { wasmLoader, createCoherenceService, } from '../integrations/coherence/index.js';
+/**
+ * Default configuration
+ */
+export const DEFAULT_ENGINE_CONFIG = {
+    enableClaudeFlow: true,
+    enableExperienceCapture: true,
+    enablePatternPromotion: true,
+    promotionThreshold: 3,
+};
+// ============================================================================
+// AQE Learning Engine
+// ============================================================================
+/**
+ * Unified AQE Learning Engine
+ *
+ * Works standalone with graceful Claude Flow enhancement.
+ */
+export class AQELearningEngine {
+    memory;
+    eventBus;
+    config;
+    reasoningBank;
+    claudeFlowBridge;
+    experienceCapture;
+    patternStore;
+    coherenceService;
+    initialized = false;
+    // Task tracking
+    activeTasks = new Map();
+    completedTasks = 0;
+    claudeFlowErrors = 0;
+    constructor(memory, config, eventBus) {
+        this.memory = memory;
+        this.eventBus = eventBus;
+        this.config = { ...DEFAULT_ENGINE_CONFIG, ...config };
+    }
+    /**
+     * Initialize the learning engine
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Initialize CoherenceService (optional - falls back to TypeScript implementation)
+        try {
+            this.coherenceService = await createCoherenceService(wasmLoader);
+            if (this.coherenceService.isInitialized()) {
+                console.log('[AQELearningEngine] CoherenceService initialized with WASM engines');
+            }
+        }
+        catch (error) {
+            // WASM not available - coherence service will use fallback
+            console.log('[AQELearningEngine] CoherenceService WASM unavailable, using fallback:', error instanceof Error ? error.message : String(error));
+        }
+        // Initialize PatternStore (always available)
+        this.patternStore = createPatternStore(this.memory, {
+            promotionThreshold: this.config.promotionThreshold,
+        });
+        await this.patternStore.initialize();
+        // Initialize QEReasoningBank with CoherenceService for filtering
+        this.reasoningBank = createQEReasoningBank(this.memory, this.eventBus, this.config.reasoningBank, this.coherenceService // Pass coherence service for coherence-gated retrieval
+        );
+        await this.reasoningBank.initialize();
+        // Initialize ExperienceCaptureService (always available)
+        if (this.config.enableExperienceCapture) {
+            this.experienceCapture = createExperienceCaptureService(this.memory, this.patternStore, this.eventBus, {
+                promotionThreshold: this.config.promotionThreshold,
+            });
+            await this.experienceCapture.initialize();
+        }
+        // Try to initialize Claude Flow bridge (optional)
+        if (this.config.enableClaudeFlow) {
+            try {
+                this.claudeFlowBridge = createClaudeFlowBridge({
+                    projectRoot: this.config.projectRoot,
+                });
+                await this.claudeFlowBridge.initialize();
+                if (this.claudeFlowBridge.isAvailable()) {
+                    console.log('[AQELearningEngine] Claude Flow integration enabled');
+                }
+            }
+            catch (error) {
+                // Claude Flow not available - continue without it
+                if (process.env.DEBUG) {
+                    console.log('[AQELearningEngine] Claude Flow not available, using standalone mode:', error instanceof Error ? error.message : String(error));
+                }
+            }
+        }
+        this.initialized = true;
+        console.log('[AQELearningEngine] Initialized');
+    }
+    // ==========================================================================
+    // Status & Info
+    // ==========================================================================
+    /**
+     * Get engine status
+     */
+    getStatus() {
+        const cfStatus = this.claudeFlowBridge?.getStatus();
+        return {
+            initialized: this.initialized,
+            claudeFlowAvailable: cfStatus?.available ?? false,
+            features: {
+                patternLearning: true, // Always available
+                vectorSearch: true, // Always available (HNSW or hash fallback)
+                taskRouting: true, // Always available
+                trajectories: cfStatus?.features.trajectories ?? false,
+                modelRouting: cfStatus?.features.modelRouting ?? false,
+                pretrain: cfStatus?.features.pretrain ?? false,
+            },
+        };
+    }
+    /**
+     * Get engine statistics
+     */
+    async getStats() {
+        if (!this.initialized || !this.reasoningBank) {
+            throw new Error('Engine not initialized');
+        }
+        const rbStats = await this.reasoningBank.getStats();
+        const ecStats = this.experienceCapture
+            ? await this.experienceCapture.getStats()
+            : {
+                totalExperiences: 0,
+                byDomain: {},
+                successRate: 0,
+                avgQuality: 0,
+                patternsExtracted: 0,
+                patternsPromoted: 0,
+            };
+        return {
+            ...rbStats,
+            activeTasks: this.activeTasks.size,
+            completedTasks: this.completedTasks,
+            claudeFlowStatus: this.claudeFlowBridge?.getStatus() ?? {
+                available: false,
+                features: {
+                    trajectories: false,
+                    modelRouting: false,
+                    pretrain: false,
+                    patternSearch: false,
+                },
+            },
+            claudeFlowErrors: this.claudeFlowErrors,
+            experienceCapture: ecStats,
+        };
+    }
+    // ==========================================================================
+    // Pattern Learning (Standalone)
+    // ==========================================================================
+    /**
+     * Store a new pattern
+     */
+    async storePattern(options) {
+        if (!this.initialized || !this.reasoningBank) {
+            return err(new Error('Engine not initialized'));
+        }
+        return this.reasoningBank.storePattern(options);
+    }
+    /**
+     * Search for patterns
+     */
+    async searchPatterns(query, options) {
+        if (!this.initialized || !this.reasoningBank) {
+            return err(new Error('Engine not initialized'));
+        }
+        return this.reasoningBank.searchPatterns(query, options);
+    }
+    /**
+     * Get pattern by ID
+     */
+    async getPattern(id) {
+        if (!this.initialized || !this.reasoningBank) {
+            return null;
+        }
+        return this.reasoningBank.getPattern(id);
+    }
+    /**
+     * Record pattern usage outcome
+     */
+    async recordOutcome(outcome) {
+        if (!this.initialized || !this.reasoningBank) {
+            return err(new Error('Engine not initialized'));
+        }
+        return this.reasoningBank.recordOutcome(outcome);
+    }
+    // ==========================================================================
+    // Task Routing (Standalone with CF Enhancement)
+    // ==========================================================================
+    /**
+     * Route a task to optimal agent
+     *
+     * When Claude Flow is available, combines local routing with CF patterns.
+     */
+    async routeTask(request) {
+        if (!this.initialized || !this.reasoningBank) {
+            return err(new Error('Engine not initialized'));
+        }
+        // Use local routing
+        const localResult = await this.reasoningBank.routeTask(request);
+        // Enhance with Claude Flow if available
+        if (localResult.success &&
+            this.claudeFlowBridge?.pretrain.isClaudeFlowAvailable()) {
+            // Could enhance with pretrain patterns here
+            // For now, just return local result
+        }
+        return localResult;
+    }
+    /**
+     * Route a task (convenience method)
+     */
+    async route(task, context) {
+        const result = await this.routeTask({ task, context });
+        return result.success ? result.value : null;
+    }
+    // ==========================================================================
+    // Model Routing (CF Enhanced)
+    // ==========================================================================
+    /**
+     * Get recommended model for a task
+     *
+     * Uses Claude Flow 3-tier routing when available,
+     * falls back to rule-based routing.
+     */
+    async recommendModel(task) {
+        // Try Claude Flow model routing
+        if (this.claudeFlowBridge?.modelRouter.isClaudeFlowAvailable()) {
+            try {
+                return await this.claudeFlowBridge.modelRouter.routeTask(task);
+            }
+            catch {
+                // Fall through to local routing
+            }
+        }
+        // Local rule-based routing (fallback)
+        return this.localModelRoute(task);
+    }
+    /**
+     * Record model routing outcome
+     */
+    async recordModelOutcome(task, model, outcome) {
+        if (this.claudeFlowBridge?.modelRouter.isClaudeFlowAvailable()) {
+            await this.claudeFlowBridge.modelRouter.recordOutcome({ task, model, outcome });
+        }
+    }
+    /**
+     * Local rule-based model routing
+     */
+    localModelRoute(task) {
+        const taskLower = task.toLowerCase();
+        // Low complexity → Haiku
+        const lowComplexity = [
+            /simple/i, /basic/i, /fix typo/i, /rename/i, /format/i,
+            /add comment/i, /lint/i, /minor/i, /quick/i, /small/i,
+        ];
+        for (const pattern of lowComplexity) {
+            if (pattern.test(taskLower)) {
+                return {
+                    model: 'haiku',
+                    confidence: 0.75,
+                    reasoning: 'Low complexity task - using haiku for speed',
+                };
+            }
+        }
+        // High complexity → Opus
+        const highComplexity = [
+            /architect/i, /design/i, /complex/i, /security/i, /performance/i,
+            /refactor.*large/i, /critical/i, /analysis/i, /multi.*file/i,
+            /distributed/i, /concurrent/i, /migration/i,
+        ];
+        for (const pattern of highComplexity) {
+            if (pattern.test(taskLower)) {
+                return {
+                    model: 'opus',
+                    confidence: 0.8,
+                    reasoning: 'High complexity task - using opus for capability',
+                };
+            }
+        }
+        // Task length heuristic
+        if (task.length > 500) {
+            return {
+                model: 'opus',
+                confidence: 0.65,
+                reasoning: 'Long task description - using opus for complex reasoning',
+            };
+        }
+        if (task.length < 50) {
+            return {
+                model: 'haiku',
+                confidence: 0.6,
+                reasoning: 'Short task - using haiku for efficiency',
+            };
+        }
+        // Default → Sonnet
+        return {
+            model: 'sonnet',
+            confidence: 0.7,
+            reasoning: 'Medium complexity - using sonnet for balance',
+        };
+    }
+    // ==========================================================================
+    // Task Tracking (CF Enhanced with SONA)
+    // ==========================================================================
+    /**
+     * Start tracking a task execution
+     *
+     * When Claude Flow is available, creates a SONA trajectory.
+     * Also starts experience capture for pattern learning.
+     */
+    async startTask(task, agent, domain) {
+        const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        // Try to start SONA trajectory
+        let trajectoryId = id;
+        if (this.claudeFlowBridge?.trajectory.isClaudeFlowAvailable()) {
+            try {
+                trajectoryId = await this.claudeFlowBridge.trajectory.startTrajectory(task, agent);
+            }
+            catch (error) {
+                this.claudeFlowErrors++;
+                console.warn(`[AQELearningEngine] Claude Flow startTrajectory failed (${this.claudeFlowErrors} total errors):`, error instanceof Error ? error.message : String(error));
+                // Fall through to local tracking
+            }
+        }
+        // Start experience capture (linked to trajectory if available)
+        let experienceId;
+        if (this.experienceCapture) {
+            experienceId = this.experienceCapture.startCapture(task, {
+                agent,
+                domain,
+                trajectoryId: trajectoryId !== id ? trajectoryId : undefined,
+            });
+        }
+        // Local tracking
+        const execution = {
+            id: experienceId || trajectoryId,
+            task,
+            agent,
+            startedAt: Date.now(),
+            steps: [],
+        };
+        this.activeTasks.set(execution.id, execution);
+        return execution.id;
+    }
+    /**
+     * Record a step in task execution
+     */
+    async recordStep(taskId, action, result, quality) {
+        // Try SONA trajectory step
+        if (this.claudeFlowBridge?.trajectory.isClaudeFlowAvailable()) {
+            try {
+                await this.claudeFlowBridge.trajectory.recordStep(taskId, action, result, quality);
+            }
+            catch (error) {
+                this.claudeFlowErrors++;
+                console.warn(`[AQELearningEngine] Claude Flow recordStep failed (${this.claudeFlowErrors} total errors):`, error instanceof Error ? error.message : String(error));
+                // Continue with local tracking
+            }
+        }
+        // Record in experience capture
+        if (this.experienceCapture) {
+            this.experienceCapture.recordStep(taskId, {
+                action,
+                result,
+                quality,
+            });
+        }
+        // Local tracking
+        const execution = this.activeTasks.get(taskId);
+        if (execution) {
+            execution.steps.push({
+                action,
+                result,
+                quality,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    /**
+     * End task tracking
+     */
+    async endTask(taskId, success, feedback) {
+        // Try to end SONA trajectory
+        if (this.claudeFlowBridge?.trajectory.isClaudeFlowAvailable()) {
+            try {
+                await this.claudeFlowBridge.trajectory.endTrajectory(taskId, success, feedback);
+            }
+            catch (error) {
+                this.claudeFlowErrors++;
+                console.warn(`[AQELearningEngine] Claude Flow endTrajectory failed (${this.claudeFlowErrors} total errors):`, error instanceof Error ? error.message : String(error));
+                // Continue with local completion
+            }
+        }
+        // Complete local tracking
+        const execution = this.activeTasks.get(taskId);
+        if (execution) {
+            this.activeTasks.delete(taskId);
+            this.completedTasks++;
+            // Experience capture for pattern learning
+            if (this.config.enableExperienceCapture && success) {
+                await this.captureExperience(execution);
+            }
+            return execution;
+        }
+        return undefined;
+    }
+    /**
+     * Get active task
+     */
+    getTask(taskId) {
+        return this.activeTasks.get(taskId);
+    }
+    // ==========================================================================
+    // Codebase Analysis (CF Enhanced)
+    // ==========================================================================
+    /**
+     * Analyze codebase for optimal configuration
+     *
+     * Uses Claude Flow pretrain when available.
+     */
+    async analyzeCodebase(path, depth = 'medium') {
+        const targetPath = path || this.config.projectRoot;
+        // Try Claude Flow pretrain
+        if (this.claudeFlowBridge?.pretrain.isClaudeFlowAvailable()) {
+            try {
+                return await this.claudeFlowBridge.pretrain.analyze(targetPath, depth);
+            }
+            catch {
+                // Fall through to local analysis
+            }
+        }
+        // Local analysis (always available)
+        return this.localAnalyze(targetPath, depth);
+    }
+    /**
+     * Generate agent configurations
+     */
+    async generateAgentConfigs(format = 'yaml') {
+        // Try Claude Flow
+        if (this.claudeFlowBridge?.pretrain.isClaudeFlowAvailable()) {
+            try {
+                return await this.claudeFlowBridge.pretrain.generateAgentConfigs(format);
+            }
+            catch {
+                // Fall through
+            }
+        }
+        // Return default QE agents
+        return [
+            {
+                name: 'qe-test-architect',
+                type: 'worker',
+                capabilities: ['test-generation', 'test-design'],
+                model: 'sonnet',
+            },
+            {
+                name: 'qe-coverage-specialist',
+                type: 'worker',
+                capabilities: ['coverage-analysis', 'gap-detection'],
+                model: 'haiku',
+            },
+            {
+                name: 'qe-security-scanner',
+                type: 'worker',
+                capabilities: ['security-scanning', 'vulnerability-detection'],
+                model: 'opus',
+            },
+        ];
+    }
+    // ==========================================================================
+    // Experience Capture (Pattern Learning)
+    // ==========================================================================
+    /**
+     * Capture experience from completed task
+     *
+     * Uses ExperienceCaptureService for comprehensive experience tracking
+     * with pattern extraction and promotion.
+     */
+    async captureExperience(execution) {
+        if (!this.experienceCapture || !this.config.enableExperienceCapture)
+            return;
+        // Calculate average quality from steps
+        const avgQuality = execution.steps.length > 0
+            ? execution.steps.reduce((sum, s) => sum + (s.quality ?? 0.5), 0) / execution.steps.length
+            : 0.5;
+        // Complete capture using ExperienceCaptureService
+        // This handles pattern extraction and promotion automatically
+        await this.experienceCapture.completeCapture(execution.id, {
+            success: true,
+            quality: avgQuality,
+        });
+        // Also share across domains if quality is high
+        const experience = await this.experienceCapture.getExperience(execution.id);
+        if (experience && experience.quality >= 0.7) {
+            await this.experienceCapture.shareAcrossDomains(experience);
+        }
+    }
+    /**
+     * Start experience capture for a task
+     *
+     * Called automatically by startTask but can be used directly
+     * for more control over the capture process.
+     */
+    startExperienceCapture(task, options) {
+        if (!this.experienceCapture)
+            return undefined;
+        return this.experienceCapture.startCapture(task, options);
+    }
+    /**
+     * Get experience capture service (for advanced usage)
+     */
+    getExperienceCaptureService() {
+        return this.experienceCapture;
+    }
+    /**
+     * Local codebase analysis
+     */
+    async localAnalyze(targetPath, depth) {
+        try {
+            const glob = await import('fast-glob');
+            const { existsSync, readFileSync } = await import('fs');
+            const { join } = await import('path');
+            // Scan patterns based on depth
+            const patterns = depth === 'shallow'
+                ? ['*.ts', '*.js', '*.json']
+                : depth === 'medium'
+                    ? ['**/*.ts', '**/*.js', '**/*.json', '**/*.py']
+                    : ['**/*'];
+            const ignore = ['node_modules/**', 'dist/**', 'coverage/**', '.git/**'];
+            const files = await glob.default(patterns, {
+                cwd: targetPath,
+                ignore,
+                onlyFiles: true,
+            });
+            // Detect languages and frameworks
+            const languages = new Set();
+            const frameworks = new Set();
+            for (const file of files.slice(0, 100)) {
+                if (file.endsWith('.ts') || file.endsWith('.tsx'))
+                    languages.add('typescript');
+                if (file.endsWith('.js') || file.endsWith('.jsx'))
+                    languages.add('javascript');
+                if (file.endsWith('.py'))
+                    languages.add('python');
+                if (file.endsWith('.go'))
+                    languages.add('go');
+                if (file.endsWith('.rs'))
+                    languages.add('rust');
+            }
+            // Check package.json for frameworks
+            const packageJsonPath = join(targetPath, 'package.json');
+            if (existsSync(packageJsonPath)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                    if (deps.react)
+                        frameworks.add('react');
+                    if (deps.vue)
+                        frameworks.add('vue');
+                    if (deps.vitest)
+                        frameworks.add('vitest');
+                    if (deps.jest)
+                        frameworks.add('jest');
+                    if (deps.playwright)
+                        frameworks.add('playwright');
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            return {
+                success: true,
+                repositoryPath: targetPath,
+                depth,
+                analysis: {
+                    languages: Array.from(languages),
+                    frameworks: Array.from(frameworks),
+                    patterns: [],
+                    complexity: files.length > 500 ? 3 : files.length > 100 ? 2 : 1,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                repositoryPath: targetPath,
+                depth,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    // ==========================================================================
+    // Guidance (Standalone)
+    // ==========================================================================
+    /**
+     * Get QE guidance for a domain
+     */
+    getGuidance(domain, context) {
+        if (!this.reasoningBank) {
+            throw new Error('Engine not initialized');
+        }
+        return this.reasoningBank.getGuidance(domain, context);
+    }
+    /**
+     * Generate guidance context for Claude
+     */
+    generateContext(domain, context) {
+        if (!this.reasoningBank) {
+            throw new Error('Engine not initialized');
+        }
+        return this.reasoningBank.generateContext(domain, context);
+    }
+    /**
+     * Check for anti-patterns
+     */
+    checkAntiPatterns(domain, content) {
+        if (!this.reasoningBank) {
+            throw new Error('Engine not initialized');
+        }
+        return this.reasoningBank.checkAntiPatterns(domain, content);
+    }
+    // ==========================================================================
+    // Cleanup
+    // ==========================================================================
+    /**
+     * Dispose the engine
+     */
+    async dispose() {
+        if (this.experienceCapture) {
+            await this.experienceCapture.dispose();
+        }
+        if (this.patternStore) {
+            await this.patternStore.dispose();
+        }
+        if (this.reasoningBank) {
+            await this.reasoningBank.dispose();
+        }
+        this.activeTasks.clear();
+        this.initialized = false;
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create AQE Learning Engine
+ *
+ * @example
+ * ```typescript
+ * const engine = createAQELearningEngine(memory, {
+ *   projectRoot: process.cwd(),
+ * });
+ * await engine.initialize();
+ * ```
+ */
+export function createAQELearningEngine(memory, config, eventBus) {
+    return new AQELearningEngine(memory, config, eventBus);
+}
+/**
+ * Create AQE Learning Engine with defaults
+ */
+export function createDefaultLearningEngine(memory, projectRoot, eventBus) {
+    return createAQELearningEngine(memory, { projectRoot }, eventBus);
+}
+//# sourceMappingURL=aqe-learning-engine.js.map