claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

package/src/integration/system-integration.ts

@@ -33,16 +33,18 @@ export class SystemIntegration {
   private constructor() {
     this.eventBus = EventBus.getInstance();
     this.logger = new Logger({ level: 'info', format: 'text', destination: 'console' });
-    
+
     // Initialize configManager safely
     try {
       // Dynamic import for ConfigManager if available
-      this.configManager = { getInstance: () => ({ load: async () => {}, get: () => null, set: () => {} }) };
+      this.configManager = {
+        getInstance: () => ({ load: async () => {}, get: () => null, set: () => {} }),
+      };
     } catch (error) {
       this.logger.warn('ConfigManager not available, using mock');
       this.configManager = { load: async () => {}, get: () => null, set: () => {} };
     }
-    
+
     this.setupEventHandlers();
   }
 
@@ -63,36 +65,35 @@ export class SystemIntegration {
     }
 
     this.logger.info('🚀 Starting Claude Flow v2.0.0 System Integration');
-    
+
     try {
       // Phase 1: Core Infrastructure
       await this.initializeCore(config);
-      
+
       // Phase 2: Memory and Configuration
       await this.initializeMemoryAndConfig();
-      
+
       // Phase 3: Agents and Coordination
       await this.initializeAgentsAndCoordination();
-      
+
       // Phase 4: Task Management
       await this.initializeTaskManagement();
-      
+
       // Phase 5: Monitoring and MCP
       await this.initializeMonitoringAndMcp();
-      
+
       // Phase 6: Cross-component wiring
       await this.wireComponents();
-      
+
       this.initialized = true;
       this.logger.info('✅ Claude Flow v2.0.0 System Integration Complete');
-      
+
       // Emit system ready event
       this.eventBus.emit('system:ready', {
         timestamp: Date.now(),
         components: Array.from(this.componentStatuses.keys()),
-        health: await this.getSystemHealth()
+        health: await this.getSystemHealth(),
       });
-      
     } catch (error) {
       this.logger.error('❌ System Integration Failed:', getErrorMessage(error));
       throw error;
@@ -104,7 +105,7 @@ export class SystemIntegration {
    */
   private async initializeCore(config?: IntegrationConfig): Promise<void> {
     this.logger.info('🔧 Phase 1: Initializing Core Infrastructure');
-    
+
     try {
       // Initialize configuration
       if (this.configManager && typeof this.configManager.load === 'function') {
@@ -113,15 +114,11 @@ export class SystemIntegration {
       } else {
         this.updateComponentStatus('config', 'warning', 'Configuration manager not available');
       }
-      
+
       // Try to initialize orchestrator if available
       try {
         const { Orchestrator } = await import('../core/orchestrator-fixed.js');
-        this.orchestrator = new Orchestrator(
-          this.configManager,
-          this.eventBus,
-          this.logger
-        );
+        this.orchestrator = new Orchestrator(this.configManager, this.eventBus, this.logger);
         if (typeof this.orchestrator.initialize === 'function') {
           await this.orchestrator.initialize();
         }
@@ -130,7 +127,7 @@ export class SystemIntegration {
         this.logger.warn('Orchestrator not available:', getErrorMessage(error));
         this.updateComponentStatus('orchestrator', 'warning', 'Orchestrator not available');
       }
-      
+
       this.logger.info('✅ Core Infrastructure Ready');
     } catch (error) {
       this.logger.error('Core initialization failed:', getErrorMessage(error));
@@ -143,12 +140,12 @@ export class SystemIntegration {
    */
   private async initializeMemoryAndConfig(): Promise<void> {
     this.logger.info('🧠 Phase 2: Initializing Memory and Configuration');
-    
+
     try {
       // Initialize memory manager
       try {
         const { MemoryManager } = await import('../memory/manager.js');
-        
+
         // Create default memory configuration
         const memoryConfig: MemoryConfig = {
           backend: 'sqlite',
@@ -156,30 +153,30 @@ export class SystemIntegration {
           syncInterval: 30000, // 30 seconds
           conflictResolution: 'last-write',
           retentionDays: 30,
-          sqlitePath: './.swarm/memory.db'
+          sqlitePath: './.swarm/memory.db',
         };
-        
+
         // Initialize MemoryManager with required parameters
-        this.memoryManager = new MemoryManager(
-          memoryConfig,
-          this.eventBus,
-          this.logger
-        );
-        
+        this.memoryManager = new MemoryManager(memoryConfig, this.eventBus, this.logger);
+
         if (typeof this.memoryManager.initialize === 'function') {
           await this.memoryManager.initialize();
         }
-        this.updateComponentStatus('memory', 'healthy', 'Memory manager initialized with SQLite backend');
-        this.logger.info('Memory manager initialized successfully', { 
+        this.updateComponentStatus(
+          'memory',
+          'healthy',
+          'Memory manager initialized with SQLite backend',
+        );
+        this.logger.info('Memory manager initialized successfully', {
           backend: memoryConfig.backend,
           cacheSizeMB: memoryConfig.cacheSizeMB,
-          sqlitePath: memoryConfig.sqlitePath 
+          sqlitePath: memoryConfig.sqlitePath,
         });
       } catch (error) {
         this.logger.warn('Memory manager initialization failed:', getErrorMessage(error));
         this.updateComponentStatus('memory', 'warning', 'Memory manager not available');
       }
-      
+
       this.logger.info('✅ Memory and Configuration Ready');
     } catch (error) {
       this.logger.error('Memory initialization failed:', getErrorMessage(error));
@@ -192,7 +189,7 @@ export class SystemIntegration {
    */
   private async initializeAgentsAndCoordination(): Promise<void> {
     this.logger.info('🤖 Phase 3: Initializing Agents and Coordination');
-    
+
     try {
       // Initialize agent manager
       try {
@@ -209,14 +206,14 @@ export class SystemIntegration {
         await this.agentManager.initialize();
         this.updateComponentStatus('agents', 'warning', 'Using mock agent manager');
       }
-      
+
       // Initialize swarm coordinator
       try {
         const { SwarmCoordinator } = await import('../coordination/swarm-coordinator.js');
         this.swarmCoordinator = new SwarmCoordinator(
           this.eventBus,
           this.logger,
-          this.memoryManager!
+          this.memoryManager!,
         );
         if (typeof this.swarmCoordinator.initialize === 'function') {
           await this.swarmCoordinator.initialize();
@@ -225,11 +222,15 @@ export class SystemIntegration {
       } catch (error) {
         this.logger.warn('Swarm coordinator not available, using mock:', getErrorMessage(error));
         const { MockSwarmCoordinator } = await import('./mock-components.js');
-        this.swarmCoordinator = new MockSwarmCoordinator(this.eventBus, this.logger, this.memoryManager!);
+        this.swarmCoordinator = new MockSwarmCoordinator(
+          this.eventBus,
+          this.logger,
+          this.memoryManager!,
+        );
         await this.swarmCoordinator.initialize();
         this.updateComponentStatus('swarm', 'warning', 'Using mock swarm coordinator');
       }
-      
+
       this.logger.info('✅ Agents and Coordination Ready');
     } catch (error) {
       this.logger.error('Agents and coordination initialization failed:', getErrorMessage(error));
@@ -242,16 +243,12 @@ export class SystemIntegration {
    */
   private async initializeTaskManagement(): Promise<void> {
     this.logger.info('📋 Phase 4: Initializing Task Management');
-    
+
     try {
       // Initialize task engine
       try {
         const { TaskEngine } = await import('../task/engine.js');
-        this.taskEngine = new TaskEngine(
-          this.eventBus,
-          this.logger,
-          this.memoryManager!
-        );
+        this.taskEngine = new TaskEngine(this.eventBus, this.logger, this.memoryManager!);
         if (typeof this.taskEngine.initialize === 'function') {
           await this.taskEngine.initialize();
         }
@@ -263,7 +260,7 @@ export class SystemIntegration {
         await this.taskEngine.initialize();
         this.updateComponentStatus('tasks', 'warning', 'Using mock task engine');
       }
-      
+
       this.logger.info('✅ Task Management Ready');
     } catch (error) {
       this.logger.error('Task management initialization failed:', getErrorMessage(error));
@@ -276,7 +273,7 @@ export class SystemIntegration {
    */
   private async initializeMonitoringAndMcp(): Promise<void> {
     this.logger.info('📊 Phase 5: Initializing Monitoring and MCP');
-    
+
     try {
       // Initialize real-time monitor
       try {
@@ -293,7 +290,7 @@ export class SystemIntegration {
         await this.monitor.initialize();
         this.updateComponentStatus('monitor', 'warning', 'Using mock monitor');
       }
-      
+
       // Initialize MCP server
       try {
         const { McpServer } = await import('../mcp/server.js');
@@ -309,7 +306,7 @@ export class SystemIntegration {
         await this.mcpServer.initialize();
         this.updateComponentStatus('mcp', 'warning', 'Using mock MCP server');
       }
-      
+
       this.logger.info('✅ Monitoring and MCP Ready');
     } catch (error) {
       this.logger.error('Monitoring and MCP initialization failed:', getErrorMessage(error));
@@ -322,20 +319,20 @@ export class SystemIntegration {
    */
   private async wireComponents(): Promise<void> {
     this.logger.info('🔗 Phase 6: Wiring Components');
-    
+
     // Wire orchestrator to agents
     if (this.orchestrator && this.agentManager) {
       this.orchestrator.setAgentManager(this.agentManager);
       this.agentManager.setOrchestrator(this.orchestrator);
     }
-    
+
     // Wire swarm coordinator to agents and tasks
     if (this.swarmCoordinator && this.agentManager && this.taskEngine) {
       this.swarmCoordinator.setAgentManager(this.agentManager);
       this.swarmCoordinator.setTaskEngine(this.taskEngine);
       this.taskEngine.setSwarmCoordinator(this.swarmCoordinator);
     }
-    
+
     // Wire monitor to all components
     if (this.monitor) {
       this.monitor.attachToOrchestrator(this.orchestrator!);
@@ -343,7 +340,7 @@ export class SystemIntegration {
       this.monitor.attachToSwarmCoordinator(this.swarmCoordinator!);
       this.monitor.attachToTaskEngine(this.taskEngine!);
     }
-    
+
     // Wire MCP server to core components
     if (this.mcpServer) {
       this.mcpServer.attachToOrchestrator(this.orchestrator!);
@@ -352,7 +349,7 @@ export class SystemIntegration {
       this.mcpServer.attachToTaskEngine(this.taskEngine!);
       this.mcpServer.attachToMemoryManager(this.memoryManager!);
     }
-    
+
     this.logger.info('✅ Component Wiring Complete');
   }
 
@@ -364,13 +361,13 @@ export class SystemIntegration {
     this.eventBus.on('component:status', (event) => {
       this.updateComponentStatus(event.component, event.status, event.message);
     });
-    
+
     // Error handling
     this.eventBus.on('system:error', (event) => {
       this.logger.error(`System Error in ${event.component}:`, event.error);
       this.updateComponentStatus(event.component, 'unhealthy', event.error.message);
     });
-    
+
     // Performance monitoring
     this.eventBus.on('performance:metric', (event) => {
       this.logger.debug(`Performance Metric: ${event.metric} = ${event.value}`);
@@ -380,17 +377,21 @@ export class SystemIntegration {
   /**
    * Update component status
    */
-  private updateComponentStatus(component: string, status: 'healthy' | 'unhealthy' | 'warning', message?: string): void {
+  private updateComponentStatus(
+    component: string,
+    status: 'healthy' | 'unhealthy' | 'warning',
+    message?: string,
+  ): void {
     const statusInfo: ComponentStatus = {
       component,
       status,
       message: message || '',
       timestamp: Date.now(),
-      lastHealthCheck: Date.now()
+      lastHealthCheck: Date.now(),
     };
-    
+
     this.componentStatuses.set(component, statusInfo);
-    
+
     // Emit status update
     this.eventBus.emit('component:status:updated', statusInfo);
   }
@@ -400,17 +401,17 @@ export class SystemIntegration {
    */
   async getSystemHealth(): Promise<SystemHealth> {
     const components = Array.from(this.componentStatuses.values());
-    const healthyComponents = components.filter(c => c.status === 'healthy').length;
-    const unhealthyComponents = components.filter(c => c.status === 'unhealthy').length;
-    const warningComponents = components.filter(c => c.status === 'warning').length;
-    
+    const healthyComponents = components.filter((c) => c.status === 'healthy').length;
+    const unhealthyComponents = components.filter((c) => c.status === 'unhealthy').length;
+    const warningComponents = components.filter((c) => c.status === 'warning').length;
+
     let overallStatus: 'healthy' | 'unhealthy' | 'warning' = 'healthy';
     if (unhealthyComponents > 0) {
       overallStatus = 'unhealthy';
     } else if (warningComponents > 0) {
       overallStatus = 'warning';
     }
-    
+
     return {
       overall: overallStatus,
       components: Object.fromEntries(this.componentStatuses),
@@ -419,9 +420,9 @@ export class SystemIntegration {
         healthyComponents,
         unhealthyComponents,
         warningComponents,
-        uptime: Date.now() - (this.initialized ? Date.now() : 0)
+        uptime: Date.now() - (this.initialized ? Date.now() : 0),
       },
-      timestamp: Date.now()
+      timestamp: Date.now(),
     };
   }
 
@@ -460,36 +461,36 @@ export class SystemIntegration {
    */
   async shutdown(): Promise<void> {
     this.logger.info('🛑 Shutting down Claude Flow v2.0.0');
-    
+
     // Shutdown in reverse order
     if (this.mcpServer) {
       await this.mcpServer.shutdown();
     }
-    
+
     if (this.monitor) {
       await this.monitor.shutdown();
     }
-    
+
     if (this.taskEngine) {
       await this.taskEngine.shutdown();
     }
-    
+
     if (this.swarmCoordinator) {
       await this.swarmCoordinator.shutdown();
     }
-    
+
     if (this.agentManager) {
       await this.agentManager.shutdown();
     }
-    
+
     if (this.memoryManager) {
       await this.memoryManager.shutdown();
     }
-    
+
     if (this.orchestrator) {
       await this.orchestrator.shutdown();
     }
-    
+
     this.initialized = false;
     this.logger.info('✅ Claude Flow v2.0.0 Shutdown Complete');
   }
@@ -512,10 +513,10 @@ export class SystemIntegration {
     return {
       initialized: this.initialized,
       components: Array.from(this.componentStatuses.keys()),
-      health: this.initialized ? null : null // Will be populated after initialization
+      health: this.initialized ? null : null, // Will be populated after initialization
     };
   }
 }
 
 // Export singleton instance
-export const systemIntegration = SystemIntegration.getInstance();
+export const systemIntegration = SystemIntegration.getInstance();

package/src/integration/types.ts

@@ -6,36 +6,36 @@ export interface IntegrationConfig {
   // Core configuration
   logLevel?: 'debug' | 'info' | 'warn' | 'error';
   environment?: 'development' | 'production' | 'testing';
-  
+
   // Component-specific configuration
   orchestrator?: {
     maxConcurrency?: number;
     timeout?: number;
   };
-  
+
   agents?: {
     maxAgents?: number;
     defaultStrategy?: string;
   };
-  
+
   swarm?: {
     topology?: 'centralized' | 'distributed' | 'hierarchical' | 'mesh';
     maxDepth?: number;
     enablePersistence?: boolean;
   };
-  
+
   memory?: {
     backend?: 'memory' | 'file' | 'redis';
     ttl?: number;
     maxSize?: number;
   };
-  
+
   monitoring?: {
     enabled?: boolean;
     metrics?: boolean;
     realTime?: boolean;
   };
-  
+
   mcp?: {
     port?: number;
     host?: string;
@@ -135,4 +135,4 @@ export interface EdgeCaseHandler {
   handler: string;
   priority: number;
   timeout?: number;
-}
+}

package/src/mcp/README.md

@@ -42,6 +42,7 @@ The MCP implementation provides:
 ### 1. MCP Server (`server.ts`)
 
 The main MCP server implementation providing:
+
 - Protocol-compliant request/response handling
 - Tool execution and management
 - Session management
@@ -58,6 +59,7 @@ await server.start();
 ### 2. Lifecycle Manager (`lifecycle-manager.ts`)
 
 Manages server lifecycle with robust error handling:
+
 - State management (stopped, starting, running, stopping, error)
 - Health monitoring with configurable intervals
 - Auto-restart with exponential backoff
@@ -74,6 +76,7 @@ await lifecycle.start();
 ### 3. Tool Registry (`tools.ts`)
 
 Enhanced tool registration and discovery:
+
 - Capability-based tool registration
 - Tool discovery by category, tags, and permissions
 - Metrics tracking (invocations, success rate, execution time)
@@ -91,6 +94,7 @@ const tools = registry.discoverTools({ category: 'filesystem' });
 ### 4. Protocol Manager (`protocol-manager.ts`)
 
 Handles protocol version negotiation:
+
 - Version compatibility checking
 - Capability negotiation
 - Feature support detection
@@ -107,6 +111,7 @@ const result = await protocolManager.negotiateProtocol(clientParams);
 ### 5. Authentication Manager (`auth.ts`)
 
 Comprehensive security implementation:
+
 - Multiple auth methods (token, basic, OAuth)
 - Session management with timeouts
 - Permission-based authorization
@@ -123,6 +128,7 @@ const result = await auth.authenticate(request, session, context);
 ### 6. Performance Monitor (`performance-monitor.ts`)
 
 Real-time performance monitoring:
+
 - Request/response time tracking
 - Percentile calculations (P50, P95, P99)
 - Custom alerting rules
@@ -140,6 +146,7 @@ monitor.recordRequestEnd(requestId, response);
 ### 7. Orchestration Integration (`orchestration-integration.ts`)
 
 Seamless integration with Claude-Flow:
+
 - Component health monitoring
 - Tool registration for orchestration features
 - Event forwarding and coordination
@@ -153,7 +160,7 @@ const integration = new MCPOrchestrationIntegration(
   mcpConfig,
   orchestrationConfig,
   components,
-  logger
+  logger,
 );
 await integration.start();
 ```
@@ -166,7 +173,7 @@ await integration.start();
 import { MCPIntegrationFactory } from './mcp/index.js';
 
 // Development setup
-const { server, lifecycleManager, performanceMonitor } = 
+const { server, lifecycleManager, performanceMonitor } =
   await MCPIntegrationFactory.createDevelopmentSetup(logger);
 
 await lifecycleManager.start();
@@ -204,7 +211,7 @@ const integration = new MCPOrchestrationIntegration(
     eventBus,
     terminalManager,
   },
-  logger
+  logger,
 );
 
 await integration.start();
@@ -304,6 +311,7 @@ const orchestrationConfig: MCPOrchestrationConfig = {
 ### Performance Metrics
 
 The performance monitor tracks:
+
 - Request count and success rate
 - Response time percentiles (P50, P95, P99)
 - Throughput (requests per second)
@@ -329,6 +337,7 @@ performanceMonitor.addAlertRule({
 ### Optimization Suggestions
 
 The system automatically generates optimization suggestions based on:
+
 - Response time patterns
 - Memory usage trends
 - Throughput bottlenecks
@@ -376,6 +385,7 @@ The system automatically generates optimization suggestions based on:
 ## Testing
 
 Comprehensive test suite covering:
+
 - Unit tests for all components
 - Integration tests for cross-component interaction
 - Performance benchmarks
@@ -391,6 +401,7 @@ npm test src/mcp/tests/mcp-integration.test.ts
 ### Stdio Transport (`transports/stdio.ts`)
 
 For command-line and process-based communication:
+
 - Standard input/output handling
 - Process lifecycle management
 - Error stream handling
@@ -398,6 +409,7 @@ For command-line and process-based communication:
 ### HTTP Transport (`transports/http.ts`)
 
 For web-based communication:
+
 - RESTful API endpoints
 - WebSocket upgrade support
 - CORS handling
@@ -406,6 +418,7 @@ For web-based communication:
 ### WebSocket Transport (Planned)
 
 For real-time bidirectional communication:
+
 - Connection management
 - Message framing
 - Reconnection handling
@@ -415,6 +428,7 @@ For real-time bidirectional communication:
 ### Custom Tools
 
 Implement custom tools by providing:
+
 - Tool definition with schema
 - Handler function
 - Capability information
@@ -423,6 +437,7 @@ Implement custom tools by providing:
 ### Custom Transports
 
 Implement the `ITransport` interface:
+
 - Request/response handling
 - Connection management
 - Health status reporting
@@ -430,6 +445,7 @@ Implement the `ITransport` interface:
 ### Custom Authentication
 
 Extend the `AuthManager` class:
+
 - Custom authentication methods
 - Integration with external providers
 - Custom permission models
@@ -476,6 +492,7 @@ Extend the `AuthManager` class:
 ### Debug Mode
 
 Enable debug logging:
+
 ```typescript
 const logger = createLogger({ level: 'debug' });
 ```
@@ -483,6 +500,7 @@ const logger = createLogger({ level: 'debug' });
 ### Health Checks
 
 Monitor component health:
+
 ```typescript
 const health = await server.getHealthStatus();
 console.log('Server healthy:', health.healthy);
@@ -501,10 +519,11 @@ console.log('Metrics:', health.metrics);
 ## API Reference
 
 See the individual component files for detailed API documentation:
+
 - [Server API](./server.ts)
 - [Lifecycle Manager API](./lifecycle-manager.ts)
 - [Tool Registry API](./tools.ts)
 - [Protocol Manager API](./protocol-manager.ts)
 - [Auth Manager API](./auth.ts)
 - [Performance Monitor API](./performance-monitor.ts)
-- [Orchestration Integration API](./orchestration-integration.ts)
+- [Orchestration Integration API](./orchestration-integration.ts)