claude-flow 2.7.0 → 2.7.1

package/dist/src/mcp/mcp-server.js

@@ -1977,9 +1977,10 @@ let ClaudeFlowMCPServer = class ClaudeFlowMCPServer {
                 const baseTime = 2;
                 const timePerEpoch = 0.08;
                 const trainingTime = baseTime + epochs * timePerEpoch + (Math.random() * 2 - 1);
-                return {
+                const modelId = `model_${args.pattern_type || 'general'}_${Date.now()}`;
+                const patternData = {
                     success: true,
-                    modelId: `model_${args.pattern_type || 'general'}_${Date.now()}`,
+                    modelId: modelId,
                     pattern_type: args.pattern_type || 'coordination',
                     epochs: epochs,
                     accuracy: Math.min(finalAccuracy, maxAccuracy),
@@ -1987,8 +1988,265 @@ let ClaudeFlowMCPServer = class ClaudeFlowMCPServer {
                     status: 'completed',
                     improvement_rate: epochFactor > 1 ? 'converged' : 'improving',
                     data_source: args.training_data || 'recent',
-                    timestamp: new Date().toISOString()
+                    timestamp: new Date().toISOString(),
+                    training_metadata: {
+                        baseAccuracy: baseAccuracy,
+                        maxAccuracy: maxAccuracy,
+                        epochFactor: epochFactor,
+                        finalAccuracy: Math.min(finalAccuracy, maxAccuracy)
+                    }
                 };
+                if (this.memoryStore) {
+                    try {
+                        await this.memoryStore.store(modelId, JSON.stringify(patternData), {
+                            namespace: 'patterns',
+                            ttl: 30 * 24 * 60 * 60 * 1000,
+                            metadata: {
+                                sessionId: this.sessionId,
+                                pattern_type: args.pattern_type || 'coordination',
+                                accuracy: patternData.accuracy,
+                                epochs: epochs,
+                                storedBy: 'neural_train',
+                                type: 'neural_pattern'
+                            }
+                        });
+                        const statsKey = `stats_${args.pattern_type || 'coordination'}`;
+                        const existingStats = await this.memoryStore.retrieve(statsKey, {
+                            namespace: 'pattern-stats'
+                        });
+                        let stats = existingStats ? JSON.parse(existingStats) : {
+                            pattern_type: args.pattern_type || 'coordination',
+                            total_trainings: 0,
+                            avg_accuracy: 0,
+                            max_accuracy: 0,
+                            min_accuracy: 1,
+                            total_epochs: 0,
+                            models: []
+                        };
+                        stats.total_trainings += 1;
+                        stats.avg_accuracy = (stats.avg_accuracy * (stats.total_trainings - 1) + patternData.accuracy) / stats.total_trainings;
+                        stats.max_accuracy = Math.max(stats.max_accuracy, patternData.accuracy);
+                        stats.min_accuracy = Math.min(stats.min_accuracy, patternData.accuracy);
+                        stats.total_epochs += epochs;
+                        stats.models.push({
+                            modelId: modelId,
+                            accuracy: patternData.accuracy,
+                            timestamp: patternData.timestamp
+                        });
+                        if (stats.models.length > 50) {
+                            stats.models = stats.models.slice(-50);
+                        }
+                        await this.memoryStore.store(statsKey, JSON.stringify(stats), {
+                            namespace: 'pattern-stats',
+                            ttl: 30 * 24 * 60 * 60 * 1000,
+                            metadata: {
+                                pattern_type: args.pattern_type || 'coordination',
+                                storedBy: 'neural_train',
+                                type: 'pattern_statistics'
+                            }
+                        });
+                        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Neural pattern stored: ${modelId} (accuracy: ${patternData.accuracy.toFixed(4)})`);
+                    } catch (error) {
+                        console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist pattern: ${error.message}`);
+                    }
+                }
+                return patternData;
+            case 'neural_patterns':
+                if (!this.memoryStore) {
+                    return {
+                        success: false,
+                        error: 'Shared memory system not initialized',
+                        timestamp: new Date().toISOString()
+                    };
+                }
+                try {
+                    switch(args.action){
+                        case 'analyze':
+                            if (args.metadata && args.metadata.modelId) {
+                                const patternValue = await this.memoryStore.retrieve(args.metadata.modelId, {
+                                    namespace: 'patterns'
+                                });
+                                if (!patternValue) {
+                                    return {
+                                        success: false,
+                                        action: 'analyze',
+                                        error: 'Pattern not found',
+                                        modelId: args.metadata.modelId,
+                                        timestamp: new Date().toISOString()
+                                    };
+                                }
+                                const pattern = JSON.parse(patternValue);
+                                return {
+                                    success: true,
+                                    action: 'analyze',
+                                    pattern: pattern,
+                                    analysis: {
+                                        quality: pattern.accuracy > 0.9 ? 'excellent' : pattern.accuracy > 0.75 ? 'good' : 'fair',
+                                        confidence: pattern.accuracy,
+                                        pattern_type: pattern.pattern_type,
+                                        training_epochs: pattern.epochs,
+                                        improvement_rate: pattern.improvement_rate,
+                                        data_source: pattern.data_source
+                                    },
+                                    timestamp: new Date().toISOString()
+                                };
+                            } else {
+                                const allPatterns = await this.memoryStore.list({
+                                    namespace: 'patterns',
+                                    limit: 100
+                                });
+                                return {
+                                    success: true,
+                                    action: 'analyze',
+                                    total_patterns: allPatterns.length,
+                                    patterns: allPatterns.map((p)=>{
+                                        try {
+                                            const data = JSON.parse(p.value);
+                                            return {
+                                                modelId: data.modelId,
+                                                pattern_type: data.pattern_type,
+                                                accuracy: data.accuracy,
+                                                timestamp: data.timestamp
+                                            };
+                                        } catch (e) {
+                                            return {
+                                                error: 'Failed to parse pattern data'
+                                            };
+                                        }
+                                    }),
+                                    timestamp: new Date().toISOString()
+                                };
+                            }
+                        case 'learn':
+                            if (!args.operation || !args.outcome) {
+                                return {
+                                    success: false,
+                                    action: 'learn',
+                                    error: 'operation and outcome are required for learning',
+                                    timestamp: new Date().toISOString()
+                                };
+                            }
+                            const learningId = `learning_${Date.now()}`;
+                            const learningData = {
+                                learningId: learningId,
+                                operation: args.operation,
+                                outcome: args.outcome,
+                                metadata: args.metadata || {},
+                                timestamp: new Date().toISOString()
+                            };
+                            await this.memoryStore.store(learningId, JSON.stringify(learningData), {
+                                namespace: 'patterns',
+                                ttl: 30 * 24 * 60 * 60 * 1000,
+                                metadata: {
+                                    sessionId: this.sessionId,
+                                    storedBy: 'neural_patterns',
+                                    type: 'learning_experience',
+                                    operation: args.operation
+                                }
+                            });
+                            return {
+                                success: true,
+                                action: 'learn',
+                                learningId: learningId,
+                                stored: true,
+                                timestamp: new Date().toISOString()
+                            };
+                        case 'predict':
+                            const patternType = args.metadata && args.metadata.pattern_type || 'coordination';
+                            const statsKey = `stats_${patternType}`;
+                            const statsValue = await this.memoryStore.retrieve(statsKey, {
+                                namespace: 'pattern-stats'
+                            });
+                            if (!statsValue) {
+                                return {
+                                    success: true,
+                                    action: 'predict',
+                                    prediction: {
+                                        confidence: 0.5,
+                                        recommendation: 'No historical data available for this pattern type',
+                                        pattern_type: patternType
+                                    },
+                                    timestamp: new Date().toISOString()
+                                };
+                            }
+                            const stats = JSON.parse(statsValue);
+                            return {
+                                success: true,
+                                action: 'predict',
+                                prediction: {
+                                    confidence: stats.avg_accuracy,
+                                    expected_accuracy: stats.avg_accuracy,
+                                    pattern_type: patternType,
+                                    recommendation: stats.avg_accuracy > 0.85 ? 'High confidence - pattern is well-established' : stats.avg_accuracy > 0.7 ? 'Moderate confidence - more training recommended' : 'Low confidence - significant training needed',
+                                    historical_trainings: stats.total_trainings,
+                                    best_accuracy: stats.max_accuracy
+                                },
+                                timestamp: new Date().toISOString()
+                            };
+                        case 'stats':
+                            const requestedType = args.metadata && args.metadata.pattern_type || null;
+                            if (requestedType) {
+                                const statsKey = `stats_${requestedType}`;
+                                const statsValue = await this.memoryStore.retrieve(statsKey, {
+                                    namespace: 'pattern-stats'
+                                });
+                                if (!statsValue) {
+                                    return {
+                                        success: true,
+                                        action: 'stats',
+                                        pattern_type: requestedType,
+                                        statistics: {
+                                            total_trainings: 0,
+                                            message: 'No training data available for this pattern type'
+                                        },
+                                        timestamp: new Date().toISOString()
+                                    };
+                                }
+                                const stats = JSON.parse(statsValue);
+                                return {
+                                    success: true,
+                                    action: 'stats',
+                                    pattern_type: requestedType,
+                                    statistics: stats,
+                                    timestamp: new Date().toISOString()
+                                };
+                            } else {
+                                const allStats = await this.memoryStore.list({
+                                    namespace: 'pattern-stats',
+                                    limit: 100
+                                });
+                                return {
+                                    success: true,
+                                    action: 'stats',
+                                    total_pattern_types: allStats.length,
+                                    statistics: allStats.map((s)=>{
+                                        try {
+                                            return JSON.parse(s.value);
+                                        } catch (e) {
+                                            return {
+                                                error: 'Failed to parse stats data'
+                                            };
+                                        }
+                                    }),
+                                    timestamp: new Date().toISOString()
+                                };
+                            }
+                        default:
+                            return {
+                                success: false,
+                                error: `Unknown action: ${args.action}. Valid actions are: analyze, learn, predict, stats`,
+                                timestamp: new Date().toISOString()
+                            };
+                    }
+                } catch (error) {
+                    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] neural_patterns error: ${error.message}`);
+                    return {
+                        success: false,
+                        action: args.action,
+                        error: error.message,
+                        timestamp: new Date().toISOString()
+                    };
+                }
             case 'memory_usage':
                 return await this.handleMemoryUsage(args);
             case 'performance_report':