claude-flow
Version:
Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)
529 lines (464 loc) • 19.4 kB
JavaScript
/**
* MCP Integration Layer - Bridge between UI and Claude Flow MCP Tools
* Handles all MCP tool execution, caching, and result processing
*/
import { EventBus } from './EventBus.js';
export class MCPIntegrationLayer {
constructor(eventBus) {
this.eventBus = eventBus;
this.mcpTools = new Map();
this.toolResults = new Map();
this.activeExecutions = new Map();
this.cache = new Map();
this.isInitialized = false;
this.mcpServerStatus = 'unknown';
this.toolCategories = {
neural: [],
memory: [],
monitoring: [],
workflow: [],
github: [],
daa: [],
system: []
};
}
/**
* Initialize MCP integration layer
*/
async initialize() {
try {
// Check if MCP server is available
this.mcpServerStatus = await this.checkMCPServerStatus();
// Discover available tools
await this.discoverTools();
// Setup tool execution handlers
this.setupToolHandlers();
// Initialize caching system
this.initializeCache();
this.isInitialized = true;
this.eventBus.emit('mcp:initialized', { status: this.mcpServerStatus });
console.log('🔌 MCP Integration Layer initialized');
} catch (error) {
console.error('❌ Failed to initialize MCP Integration Layer:', error);
this.mcpServerStatus = 'error';
throw error;
}
}
/**
* Check MCP server status
*/
async checkMCPServerStatus() {
try {
// Try to detect available MCP tools
// This would normally check for actual MCP server connection
if (typeof window !== 'undefined' && window.claudeFlowMCP) {
return 'connected';
}
// Check for Node.js environment with MCP tools
if (typeof process !== 'undefined' && process.env.CLAUDE_FLOW_MCP_ENABLED === 'true') {
return 'connected';
}
return 'mock'; // Use mock mode for development
} catch (error) {
console.warn('MCP Server connection check failed:', error);
return 'offline';
}
}
/**
* Discover available MCP tools
*/
async discoverTools() {
const availableTools = {
// Neural Network Tools
neural: [
{ name: 'neural_train', description: 'Train neural patterns with WASM SIMD', params: ['pattern_type', 'training_data', 'epochs'] },
{ name: 'neural_predict', description: 'Make AI predictions', params: ['modelId', 'input'] },
{ name: 'neural_status', description: 'Check neural network status', params: ['modelId'] },
{ name: 'neural_patterns', description: 'Analyze cognitive patterns', params: ['action', 'operation', 'outcome'] },
{ name: 'model_load', description: 'Load pre-trained models', params: ['modelPath'] },
{ name: 'model_save', description: 'Save trained models', params: ['modelId', 'path'] },
{ name: 'pattern_recognize', description: 'Pattern recognition', params: ['data', 'patterns'] },
{ name: 'cognitive_analyze', description: 'Cognitive behavior analysis', params: ['behavior'] },
{ name: 'learning_adapt', description: 'Adaptive learning', params: ['experience'] },
{ name: 'neural_compress', description: 'Compress neural models', params: ['modelId', 'ratio'] },
{ name: 'ensemble_create', description: 'Create model ensembles', params: ['models', 'strategy'] },
{ name: 'transfer_learn', description: 'Transfer learning', params: ['sourceModel', 'targetDomain'] },
{ name: 'neural_explain', description: 'AI explainability', params: ['modelId', 'prediction'] },
{ name: 'wasm_optimize', description: 'WASM SIMD optimization', params: ['operation'] },
{ name: 'inference_run', description: 'Run neural inference', params: ['modelId', 'data'] }
],
// Memory & Persistence Tools
memory: [
{ name: 'memory_usage', description: 'Store/retrieve persistent memory', params: ['action', 'key', 'value', 'namespace', 'ttl'] },
{ name: 'memory_backup', description: 'Backup memory stores', params: ['path'] },
{ name: 'memory_restore', description: 'Restore from backups', params: ['backupPath'] },
{ name: 'memory_compress', description: 'Compress memory data', params: ['namespace'] },
{ name: 'memory_sync', description: 'Sync across instances', params: ['target'] },
{ name: 'cache_manage', description: 'Manage coordination cache', params: ['action', 'key'] },
{ name: 'state_snapshot', description: 'Create state snapshots', params: ['name'] },
{ name: 'context_restore', description: 'Restore execution context', params: ['snapshotId'] },
{ name: 'memory_analytics', description: 'Analyze memory usage', params: ['timeframe'] },
{ name: 'memory_persist', description: 'Cross-session persistence', params: ['sessionId'] },
{ name: 'memory_namespace', description: 'Namespace management', params: ['namespace', 'action'] }
],
// Monitoring & Analysis Tools
monitoring: [
{ name: 'performance_report', description: 'Generate performance reports', params: ['format', 'timeframe'] },
{ name: 'bottleneck_analyze', description: 'Identify performance bottlenecks', params: ['component', 'metrics'] },
{ name: 'token_usage', description: 'Analyze token consumption', params: ['operation', 'timeframe'] },
{ name: 'benchmark_run', description: 'Performance benchmarks', params: ['suite'] },
{ name: 'metrics_collect', description: 'Collect system metrics', params: ['components'] },
{ name: 'trend_analysis', description: 'Analyze performance trends', params: ['metric', 'period'] },
{ name: 'cost_analysis', description: 'Cost and resource analysis', params: ['timeframe'] },
{ name: 'quality_assess', description: 'Quality assessment', params: ['target', 'criteria'] },
{ name: 'error_analysis', description: 'Error pattern analysis', params: ['logs'] },
{ name: 'usage_stats', description: 'Usage statistics', params: ['component'] },
{ name: 'health_check', description: 'System health monitoring', params: ['components'] },
{ name: 'swarm_monitor', description: 'Real-time swarm monitoring', params: ['swarmId', 'interval'] },
{ name: 'agent_metrics', description: 'Agent performance metrics', params: ['agentId'] }
],
// Workflow & Automation Tools
workflow: [
{ name: 'workflow_create', description: 'Create custom workflows', params: ['name', 'steps', 'triggers'] },
{ name: 'workflow_execute', description: 'Execute predefined workflows', params: ['workflowId', 'params'] },
{ name: 'automation_setup', description: 'Setup automation rules', params: ['rules'] },
{ name: 'pipeline_create', description: 'Create CI/CD pipelines', params: ['config'] },
{ name: 'scheduler_manage', description: 'Manage task scheduling', params: ['action', 'schedule'] },
{ name: 'trigger_setup', description: 'Setup event triggers', params: ['events', 'actions'] },
{ name: 'workflow_template', description: 'Manage workflow templates', params: ['action', 'template'] },
{ name: 'batch_process', description: 'Batch processing', params: ['items', 'operation'] },
{ name: 'parallel_execute', description: 'Execute tasks in parallel', params: ['tasks'] },
{ name: 'sparc_mode', description: 'Run SPARC development modes', params: ['mode', 'task_description', 'options'] },
{ name: 'task_orchestrate', description: 'Orchestrate complex task workflows', params: ['task', 'strategy', 'priority', 'dependencies'] }
],
// GitHub Integration Tools
github: [
{ name: 'github_repo_analyze', description: 'Repository analysis', params: ['repo', 'analysis_type'] },
{ name: 'github_pr_manage', description: 'Pull request management', params: ['repo', 'action', 'pr_number'] },
{ name: 'github_issue_track', description: 'Issue tracking & triage', params: ['repo', 'action'] },
{ name: 'github_release_coord', description: 'Release coordination', params: ['repo', 'version'] },
{ name: 'github_workflow_auto', description: 'Workflow automation', params: ['repo', 'workflow'] },
{ name: 'github_code_review', description: 'Automated code review', params: ['repo', 'pr'] },
{ name: 'github_sync_coord', description: 'Multi-repo sync coordination', params: ['repos'] },
{ name: 'github_metrics', description: 'Repository metrics', params: ['repo'] }
],
// DAA Tools
daa: [
{ name: 'daa_agent_create', description: 'Create dynamic agents', params: ['agent_type', 'capabilities', 'resources'] },
{ name: 'daa_capability_match', description: 'Match capabilities to tasks', params: ['task_requirements', 'available_agents'] },
{ name: 'daa_resource_alloc', description: 'Resource allocation', params: ['resources', 'agents'] },
{ name: 'daa_lifecycle_manage', description: 'Agent lifecycle management', params: ['agentId', 'action'] },
{ name: 'daa_communication', description: 'Inter-agent communication', params: ['from', 'to', 'message'] },
{ name: 'daa_consensus', description: 'Consensus mechanisms', params: ['agents', 'proposal'] },
{ name: 'daa_fault_tolerance', description: 'Fault tolerance & recovery', params: ['agentId', 'strategy'] },
{ name: 'daa_optimization', description: 'Performance optimization', params: ['target', 'metrics'] }
],
// System & Utilities
system: [
{ name: 'security_scan', description: 'Security scanning', params: ['target', 'depth'] },
{ name: 'backup_create', description: 'Create system backups', params: ['components', 'destination'] },
{ name: 'restore_system', description: 'System restoration', params: ['backupId'] },
{ name: 'log_analysis', description: 'Log analysis & insights', params: ['logFile', 'patterns'] },
{ name: 'diagnostic_run', description: 'System diagnostics', params: ['components'] },
{ name: 'config_manage', description: 'Configuration management', params: ['action', 'config'] },
{ name: 'features_detect', description: 'Feature detection', params: ['component'] },
{ name: 'terminal_execute', description: 'Execute terminal commands', params: ['command', 'args'] }
]
};
// Register tools
for (const [category, tools] of Object.entries(availableTools)) {
this.toolCategories[category] = tools;
tools.forEach(tool => {
this.mcpTools.set(tool.name, {
...tool,
category,
lastUsed: null,
usageCount: 0
});
});
}
console.log(`🔧 Discovered ${this.mcpTools.size} MCP tools across ${Object.keys(this.toolCategories).length} categories`);
}
/**
* Execute MCP tool
*/
async executeTool(toolName, params = {}) {
if (!this.isInitialized) {
throw new Error('MCP Integration Layer not initialized');
}
const tool = this.mcpTools.get(toolName);
if (!tool) {
throw new Error(`Tool not found: ${toolName}`);
}
// Check if execution is already in progress
if (this.activeExecutions.has(toolName)) {
throw new Error(`Tool ${toolName} is already executing`);
}
// Check cache first
const cacheKey = this.getCacheKey(toolName, params);
const cached = this.cache.get(cacheKey);
if (cached && !this.isCacheExpired(cached)) {
return cached.result;
}
try {
// Mark as executing
this.activeExecutions.set(toolName, {
startTime: Date.now(),
params
});
// Execute based on MCP server status
let result;
if (this.mcpServerStatus === 'connected') {
result = await this.executeRealTool(toolName, params);
} else {
result = await this.executeMockTool(toolName, params);
}
// Update tool usage stats
tool.lastUsed = Date.now();
tool.usageCount++;
// Cache result
this.cacheResult(cacheKey, result);
// Store in results map
this.toolResults.set(toolName, {
result,
timestamp: Date.now(),
params
});
// Emit success event
this.eventBus.emit('tool:executed', {
tool: toolName,
result,
params,
duration: Date.now() - this.activeExecutions.get(toolName).startTime
});
return result;
} catch (error) {
this.eventBus.emit('tool:error', {
tool: toolName,
error: error.message,
params
});
throw error;
} finally {
// Remove from active executions
this.activeExecutions.delete(toolName);
}
}
/**
* Execute real MCP tool (when server is connected)
*/
async executeRealTool(toolName, params) {
// This would call the actual MCP tool
// For now, we'll simulate the call
const mcpToolName = `mcp__claude-flow__${toolName}`;
if (typeof window !== 'undefined' && window.claudeFlowMCP) {
return await window.claudeFlowMCP.execute(mcpToolName, params);
}
// Node.js environment
if (typeof process !== 'undefined') {
// This would import and execute the actual MCP tool
// For now, return mock data
return this.executeMockTool(toolName, params);
}
throw new Error('MCP server not available');
}
/**
* Execute mock tool (for development/testing)
*/
async executeMockTool(toolName, params) {
// Simulate execution delay
await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 500));
const mockResults = {
// Neural tools
neural_train: { success: true, epochs: params.epochs || 50, accuracy: 0.95, loss: 0.05 },
neural_predict: { prediction: 'sample_prediction', confidence: 0.87 },
neural_status: { modelId: params.modelId, status: 'ready', accuracy: 0.92 },
neural_patterns: { patterns: ['pattern1', 'pattern2'], insights: 'analysis complete' },
// Memory tools
memory_usage: {
action: params.action,
key: params.key,
success: true,
result: params.action === 'retrieve' ? 'sample_value' : 'stored'
},
memory_backup: { backupId: 'backup_' + Date.now(), size: '1.2MB', success: true },
memory_analytics: { entries: 42, size: '156KB', namespaces: 4 },
// Monitoring tools
performance_report: {
cpu: 45,
memory: 67,
uptime: 3600,
efficiency: 92,
bottlenecks: ['network_io', 'memory_allocation']
},
bottleneck_analyze: {
component: params.component,
issues: ['high_cpu_usage', 'memory_leaks'],
recommendations: ['optimize_queries', 'increase_cache']
},
// Workflow tools
workflow_create: { workflowId: 'wf_' + Date.now(), status: 'created' },
workflow_execute: { workflowId: params.workflowId, status: 'completed', duration: 1500 },
task_orchestrate: { taskId: 'task_' + Date.now(), status: 'orchestrated', agents: 3 },
// GitHub tools
github_repo_analyze: {
repo: params.repo,
score: 85,
issues: 12,
complexity: 'medium',
recommendations: ['add_tests', 'update_dependencies']
},
// DAA tools
daa_agent_create: { agentId: 'agent_' + Date.now(), type: params.agent_type, status: 'created' },
daa_capability_match: { matches: ['agent1', 'agent2'], confidence: 0.89 },
// System tools
security_scan: {
target: params.target,
vulnerabilities: 2,
score: 'A-',
issues: ['outdated_dependencies', 'weak_encryption']
},
health_check: { status: 'healthy', components: { all: 'ok' }, uptime: 3600 }
};
return mockResults[toolName] || { success: true, message: 'Mock execution completed' };
}
/**
* Get cache key for tool and params
*/
getCacheKey(toolName, params) {
return `${toolName}_${JSON.stringify(params)}`;
}
/**
* Cache tool result
*/
cacheResult(cacheKey, result) {
this.cache.set(cacheKey, {
result,
timestamp: Date.now(),
ttl: 5 * 60 * 1000 // 5 minutes
});
}
/**
* Check if cache entry is expired
*/
isCacheExpired(cacheEntry) {
return Date.now() - cacheEntry.timestamp > cacheEntry.ttl;
}
/**
* Setup tool execution handlers
*/
setupToolHandlers() {
this.eventBus.on('tool:execute', async (data) => {
try {
const result = await this.executeTool(data.tool, data.params);
this.eventBus.emit('tool:result', { tool: data.tool, result });
} catch (error) {
this.eventBus.emit('tool:error', { tool: data.tool, error });
}
});
}
/**
* Initialize caching system
*/
initializeCache() {
// Clean expired cache entries every 5 minutes
setInterval(() => {
for (const [key, entry] of this.cache.entries()) {
if (this.isCacheExpired(entry)) {
this.cache.delete(key);
}
}
}, 5 * 60 * 1000);
}
/**
* Get all available tools
*/
getAvailableTools() {
return Array.from(this.mcpTools.values());
}
/**
* Get tools by category
*/
getToolsByCategory(category) {
return this.toolCategories[category] || [];
}
/**
* Get tool usage statistics
*/
getToolUsageStats() {
const stats = {};
for (const [name, tool] of this.mcpTools) {
stats[name] = {
usageCount: tool.usageCount,
lastUsed: tool.lastUsed,
category: tool.category
};
}
return stats;
}
/**
* Get system status
*/
async getSystemStatus() {
return {
mcpServerStatus: this.mcpServerStatus,
toolsAvailable: this.mcpTools.size,
activeExecutions: this.activeExecutions.size,
cacheSize: this.cache.size,
isInitialized: this.isInitialized
};
}
/**
* Get system uptime
*/
async getSystemUptime() {
if (typeof process !== 'undefined') {
return process.uptime();
}
return Date.now() - (window.claudeFlowStartTime || Date.now());
}
/**
* Get active tools
*/
async getActiveTools() {
return Array.from(this.activeExecutions.keys());
}
/**
* Get memory usage
*/
async getMemoryUsage() {
if (typeof process !== 'undefined') {
const usage = process.memoryUsage();
return {
used: usage.heapUsed,
total: usage.heapTotal,
external: usage.external
};
}
return { used: 0, total: 0, external: 0 };
}
/**
* Get swarm status
*/
async getSwarmStatus() {
try {
const result = await this.executeTool('swarm_status');
return result;
} catch (error) {
return { status: 'offline', error: error.message };
}
}
/**
* Shutdown MCP integration
*/
async shutdown() {
// Cancel all active executions
this.activeExecutions.clear();
// Clear cache
this.cache.clear();
// Clear tool results
this.toolResults.clear();
this.eventBus.emit('mcp:shutdown');
}
}
export default MCPIntegrationLayer;