claude-flow 2.0.0-alpha.2 → 2.0.0-alpha.21

package/src/hive-mind/core/Communication.ts

@@ -41,18 +41,7 @@ export class Communication extends EventEmitter {
       totalMessages: 0,
       avgLatency: 0,
       activeChannels: 0,
-      messagesByType: {
-        direct: 0,
-        broadcast: 0,
-        consensus: 0,
-        query: 0,
-        response: 0,
-        notification: 0,
-        task_assignment: 0,
-        progress_update: 0,
-        coordination: 0,
-        channel: 0
-      },
+      messagesByType: {},
       throughput: 0
     };
   }
@@ -391,8 +380,7 @@ export class Communication extends EventEmitter {
       if (!this.isActive) return;
       
       // Process messages by priority
-      const messageQueueArray = Array.from(this.messageQueue.entries());
-      for (const [priority, messages] of messageQueueArray) {
+      for (const [priority, messages] of this.messageQueue) {
         if (messages.length === 0) continue;
         
         // Process batch of messages
@@ -421,8 +409,7 @@ export class Communication extends EventEmitter {
         }
       } else {
         // Broadcast message
-        const agentArray = Array.from(this.agents.values());
-        for (const agent of agentArray) {
+        for (const agent of this.agents.values()) {
           if (agent.id !== message.fromAgentId) {
             await agent.receiveMessage(message);
           }

package/src/hive-mind/core/DatabaseManager.ts

@@ -622,16 +622,16 @@ export class DatabaseManager extends EventEmitter {
   // Utility operations
 
   async deleteMemoryEntry(key: string, namespace: string): Promise<void> {
-    const startTime = Date.now();
+    const startTime = performance.now();
     
     try {
       this.db.prepare('DELETE FROM memory WHERE key = ? AND namespace = ?').run(key, namespace);
       
-      const duration = Date.now() - startTime;
+      const duration = performance.now() - startTime;
       this.recordPerformance('delete_memory', duration);
       
     } catch (error) {
-      this.recordPerformance('delete_memory_error', Date.now() - startTime);
+      this.recordPerformance('delete_memory_error', performance.now() - startTime);
       throw error;
     }
   }
@@ -664,21 +664,6 @@ export class DatabaseManager extends EventEmitter {
     console.debug(`DB Operation ${operation}: ${duration.toFixed(2)}ms`);
   }
 
-  // Additional Consensus operations
-
-  async getConsensusProposal(id: string): Promise<any> {
-    return this.db.prepare('SELECT * FROM consensus WHERE id = ?').get(id);
-  }
-
-  async updateConsensusStatus(id: string, status: string): Promise<void> {
-    this.db.prepare('UPDATE consensus SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?')
-      .run(status, id);
-  }
-
-  async getRecentConsensusProposals(limit: number): Promise<any[]> {
-    return this.db.prepare('SELECT * FROM consensus ORDER BY created_at DESC LIMIT ?').all(limit);
-  }
-
   /**
    * Close database connection
    */

package/src/hive-mind/core/HiveMind.ts

@@ -27,7 +27,7 @@ import {
 } from '../types.js';
 
 export class HiveMind extends EventEmitter {
-  public readonly id: string;
+  private id: string;
   private config: HiveMindConfig;
   private queen: Queen;
   private agents: Map<string, Agent>;
@@ -120,8 +120,7 @@ export class HiveMind extends EventEmitter {
     
     const config = JSON.parse(swarmData.config);
     const hiveMind = new HiveMind(config);
-    // Set the ID using the private property access
-    (hiveMind as any).id = swarmId;
+    hiveMind.id = swarmId;
     
     await hiveMind.initialize();
     
@@ -200,7 +199,7 @@ export class HiveMind extends EventEmitter {
       name: options.name || `${options.type}-${Date.now()}`,
       type: options.type,
       swarmId: this.id,
-      capabilities: (options.capabilities || this.getDefaultCapabilities(options.type)) as AgentCapability[]
+      capabilities: options.capabilities || this.getDefaultCapabilities(options.type)
     });
     
     await agent.initialize();
@@ -303,7 +302,7 @@ export class HiveMind extends EventEmitter {
     const performance = await this.calculatePerformanceMetrics();
     
     // Determine health status
-    const health = this.determineHealth(agents, tasks, performance) as 'healthy' | 'degraded' | 'critical' | 'unknown';
+    const health = this.determineHealth(agents, tasks, performance);
     
     // Get any warnings
     const warnings = this.getSystemWarnings(agents, tasks, performance);
@@ -427,8 +426,7 @@ export class HiveMind extends EventEmitter {
     this.started = false;
     
     // Shutdown all agents
-    const agentArray = Array.from(this.agents.values());
-    for (const agent of agentArray) {
+    for (const agent of this.agents.values()) {
       await agent.shutdown();
     }
     
@@ -470,7 +468,7 @@ export class HiveMind extends EventEmitter {
       const requiredCapabilities = JSON.parse(task.required_capabilities || '[]');
       
       // Check if agent has required capabilities
-      if (requiredCapabilities.every((cap: string) => agent.capabilities.includes(cap as AgentCapability))) {
+      if (requiredCapabilities.every((cap: string) => agent.capabilities.includes(cap))) {
         await this.orchestrator.assignTaskToAgent(task.id, agent.id);
         break; // Only assign one task at a time
       }

package/src/hive-mind/core/Memory.ts

@@ -627,8 +627,7 @@ export class Memory extends EventEmitter {
     const stats = await this.db.getMemoryStats();
     
     const byNamespace: Record<string, any> = {};
-    const namespaceArray = Array.from(this.namespaces.values());
-    for (const ns of namespaceArray) {
+    for (const ns of this.namespaces.values()) {
       const nsStats = await this.db.getNamespaceStats(ns.name);
       byNamespace[ns.name] = nsStats;
     }
@@ -1061,8 +1060,7 @@ export class Memory extends EventEmitter {
     const metrics: any = {};
     
     // Calculate averages for each operation
-    const performanceArray = Array.from(this.performanceMetrics.entries());
-    for (const [operation, durations] of performanceArray) {
+    for (const [operation, durations] of this.performanceMetrics) {
       if (durations.length > 0) {
         metrics[`${operation}_avg`] = durations.reduce((a, b) => a + b, 0) / durations.length;
         metrics[`${operation}_count`] = durations.length;
@@ -1078,8 +1076,7 @@ export class Memory extends EventEmitter {
     // Add pool statistics
     if (this.objectPools.size > 0) {
       metrics.pools = {};
-      const poolArray = Array.from(this.objectPools.entries());
-      for (const [name, pool] of poolArray) {
+      for (const [name, pool] of this.objectPools) {
         metrics.pools[name] = pool.getStats();
       }
     }
@@ -1091,8 +1088,7 @@ export class Memory extends EventEmitter {
    * Optimize object pools
    */
   private optimizeObjectPools(): void {
-    const poolArray = Array.from(this.objectPools.entries());
-    for (const [name, pool] of poolArray) {
+    for (const [name, pool] of this.objectPools) {
       const stats = pool.getStats();
       
       // If reuse rate is low, the pool might be too small
@@ -1251,19 +1247,34 @@ export class Memory extends EventEmitter {
   }
 
   private async evictExpiredEntries(): Promise<void> {
-    // Note: Cache eviction would need to be implemented with proper iteration
-    // For now, this is a placeholder for future cache optimization
-    this.emit('cacheEvictionNeeded');
+    const now = Date.now();
+    const toEvict: string[] = [];
+    
+    for (const [cacheKey, entry] of this.cache) {
+      if (entry.ttl && entry.createdAt.getTime() + (entry.ttl * 1000) < now) {
+        toEvict.push(cacheKey);
+      }
+    }
+    
+    for (const key of toEvict) {
+      const entry = this.cache.get(key)!;
+      await this.delete(entry.key, entry.namespace);
+    }
   }
 
   private async manageCacheSize(): Promise<void> {
     const maxCacheSize = 1000;
-    const stats = this.cache.getStats();
     
-    if (stats.size > maxCacheSize) {
-      // Simple eviction - remove oldest entries
-      // Note: This would need proper LRU implementation in a production system
-      this.emit('cacheCapacityExceeded', { size: stats.size, maxSize: maxCacheSize });
+    if (this.cache.size > maxCacheSize) {
+      // Evict least recently used entries
+      const entries = Array.from(this.cache.entries())
+        .sort((a, b) => a[1].lastAccessedAt.getTime() - b[1].lastAccessedAt.getTime());
+      
+      const toEvict = entries.slice(0, entries.length - maxCacheSize);
+      
+      for (const [cacheKey] of toEvict) {
+        this.cache.delete(cacheKey);
+      }
     }
   }
 
@@ -1284,8 +1295,7 @@ export class Memory extends EventEmitter {
   }
 
   private async optimizeNamespaces(): Promise<void> {
-    const namespaceArray = Array.from(this.namespaces.values());
-    for (const namespace of namespaceArray) {
+    for (const namespace of this.namespaces.values()) {
       const stats = await this.db.getNamespaceStats(namespace.name);
       
       // Apply retention policies
@@ -1320,8 +1330,7 @@ export class Memory extends EventEmitter {
     
     // Clear cache and pools
     this.cache.clear();
-    const poolArray = Array.from(this.objectPools.values());
-    for (const pool of poolArray) {
+    for (const pool of this.objectPools.values()) {
       // Pools will be garbage collected
     }
     this.objectPools.clear();
@@ -1347,15 +1356,12 @@ export class Memory extends EventEmitter {
           }
         ])
       ),
-      pools: (() => {
-        const poolEntries = Array.from(this.objectPools.entries());
-        return Object.fromEntries(
-          poolEntries.map(([name, pool]) => [
-            name,
-            pool.getStats()
-          ])
-        );
-      })(),
+      pools: Object.fromEntries(
+        Array.from(this.objectPools.entries()).map(([name, pool]) => [
+          name,
+          pool.getStats()
+        ])
+      ),
       accessPatterns: {
         total: this.accessPatterns.size,
         hotKeys: Array.from(this.accessPatterns.entries())

package/src/hive-mind/integration/ConsensusEngine.ts

@@ -110,7 +110,7 @@ export class ConsensusEngine extends EventEmitter {
    * Get proposal status
    */
   async getProposalStatus(proposalId: string): Promise<any> {
-    const dbProposal = this.db.getConsensusProposal(proposalId);
+    const dbProposal = await this.db.getConsensusProposal(proposalId);
     if (!dbProposal) {
       throw new Error('Proposal not found');
     }
@@ -333,7 +333,7 @@ export class ConsensusEngine extends EventEmitter {
     result: ConsensusResult
   ): Promise<void> {
     // Update proposal status
-    this.db.updateConsensusStatus(proposal.id, 'achieved');
+    await this.db.updateConsensusStatus(proposal.id, 'achieved');
     
     // Remove from active proposals
     this.activeProposals.delete(proposal.id);
@@ -361,7 +361,7 @@ export class ConsensusEngine extends EventEmitter {
     result: ConsensusResult
   ): Promise<void> {
     // Update proposal status
-    this.db.updateConsensusStatus(proposal.id, 'failed');
+    await this.db.updateConsensusStatus(proposal.id, 'failed');
     
     // Remove from active proposals
     this.activeProposals.delete(proposal.id);
@@ -508,7 +508,7 @@ export class ConsensusEngine extends EventEmitter {
       
       try {
         // Calculate average voting time
-        const recentProposals = this.db.getRecentConsensusProposals(10);
+        const recentProposals = await this.db.getRecentConsensusProposals(10);
         
         if (recentProposals.length > 0) {
           const votingTimes = recentProposals
@@ -543,6 +543,21 @@ export class ConsensusEngine extends EventEmitter {
     });
   }
 
+  /**
+   * Database helper methods (to be implemented in DatabaseManager)
+   */
+  private async getConsensusProposal(id: string): Promise<any> {
+    return this.db.prepare('SELECT * FROM consensus WHERE id = ?').get(id);
+  }
+
+  private async updateConsensusStatus(id: string, status: string): Promise<void> {
+    this.db.prepare('UPDATE consensus SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?')
+      .run(status, id);
+  }
+
+  private async getRecentConsensusProposals(limit: number): Promise<any[]> {
+    return this.db.prepare('SELECT * FROM consensus ORDER BY created_at DESC LIMIT ?').all(limit);
+  }
 
   /**
    * Shutdown consensus engine

package/src/hive-mind/integration/MCPToolWrapper.ts

@@ -9,6 +9,7 @@
 import { EventEmitter } from 'events';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { getErrorMessage } from '../../utils/type-guards.js';
 
 const execAsync = promisify(exec);
 
@@ -71,7 +72,7 @@ export class MCPToolWrapper extends EventEmitter {
       return { success: true, data: result };
       
     } catch (error) {
-      return { success: false, error: error.message };
+      return { success: false, error: getErrorMessage(error) };
     }
   }
 

package/src/hive-mind/integration/SwarmOrchestrator.ts

@@ -693,12 +693,11 @@ export class SwarmOrchestrator extends EventEmitter {
    * Notify agent of task cancellation
    */
   private async notifyAgentTaskCancelled(agentId: string, taskId: string): Promise<void> {
-    const status = await this.hiveMind.getFullStatus();
     // Send cancellation message to agent
     await this.db.createCommunication({
       from_agent_id: 'orchestrator',
       to_agent_id: agentId,
-      swarm_id: status.swarmId,
+      swarm_id: this.hiveMind.id,
       message_type: 'task_cancellation',
       content: JSON.stringify({ taskId, reason: 'User cancelled' }),
       priority: 'urgent'
@@ -710,8 +709,7 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   private async analyzeLoadDistribution(): Promise<any> {
     const agents = await this.hiveMind.getAgents();
-    const status = await this.hiveMind.getFullStatus();
-    const tasks = await this.db.getActiveTasks(status.swarmId);
+    const tasks = await this.db.getActiveTasks(this.hiveMind.id);
     
     const busyAgents = agents.filter(a => a.status === 'busy');
     const idleAgents = agents.filter(a => a.status === 'idle');
@@ -766,12 +764,11 @@ export class SwarmOrchestrator extends EventEmitter {
    * Notify agents of reassignment
    */
   private async notifyAgentReassignment(fromAgentId: string, toAgentId: string, taskId: string): Promise<void> {
-    const status = await this.hiveMind.getFullStatus();
     // Notify source agent
     await this.db.createCommunication({
       from_agent_id: 'orchestrator',
       to_agent_id: fromAgentId,
-      swarm_id: status.swarmId,
+      swarm_id: this.hiveMind.id,
       message_type: 'task_reassignment',
       content: JSON.stringify({ taskId, reassignedTo: toAgentId }),
       priority: 'high'
@@ -784,7 +781,7 @@ export class SwarmOrchestrator extends EventEmitter {
     await this.db.createCommunication({
       from_agent_id: 'orchestrator',
       to_agent_id: toAgentId,
-      swarm_id: status.swarmId,
+      swarm_id: this.hiveMind.id,
       message_type: 'task_assignment',
       content: JSON.stringify({ 
         taskId, 

package/src/integration/mock-components.ts

@@ -175,9 +175,9 @@ export class MockSwarmCoordinator {
   private swarms: Map<string, any> = new Map();
 
   constructor(
-    eventBus?: EventBus,
-    logger?: Logger,
-    memoryManager?: MockMemoryManager
+    private eventBus: EventBus,
+    private logger: Logger,
+    private memoryManager: MockMemoryManager
   ) {}
 
   async initialize(): Promise<void> {
@@ -240,9 +240,9 @@ export class MockTaskEngine {
   private tasks: Map<string, any> = new Map();
 
   constructor(
-    eventBus?: EventBus,
-    logger?: Logger,
-    memoryManager?: MockMemoryManager
+    private eventBus: EventBus,
+    private logger: Logger,
+    private memoryManager: MockMemoryManager
   ) {}
 
   async initialize(): Promise<void> {
@@ -296,7 +296,7 @@ export class MockTaskEngine {
 }
 
 export class MockRealTimeMonitor {
-  constructor(eventBus?: EventBus, logger?: Logger) {}
+  constructor(private eventBus: EventBus, private logger: Logger) {}
 
   async initialize(): Promise<void> {
     // Mock initialization
@@ -333,7 +333,7 @@ export class MockRealTimeMonitor {
 }
 
 export class MockMcpServer {
-  constructor(eventBus?: EventBus, logger?: Logger) {}
+  constructor(private eventBus: EventBus, private logger: Logger) {}
 
   async initialize(): Promise<void> {
     // Mock initialization

package/src/integration/system-integration.ts

@@ -10,7 +10,7 @@ import { MemoryManager } from '../memory/manager.js';
 import { AgentManager } from '../agents/agent-manager.js';
 import { TaskEngine } from '../task/engine.js';
 import { RealTimeMonitor } from '../monitoring/real-time-monitor.js';
-import { MCPServer } from '../mcp/server.js';
+import { McpServer } from '../mcp/server.js';
 import { getErrorMessage } from '../utils/error-handler.js';
 import type { IntegrationConfig, SystemHealth, ComponentStatus } from './types.js';
 
@@ -147,11 +147,7 @@ export class SystemIntegration {
       // Initialize memory manager
       try {
         const { MemoryManager } = await import('../memory/manager.js');
-        this.memoryManager = new MemoryManager(
-          { backend: 'memory', cacheSizeMB: 64 },
-          this.eventBus,
-          this.logger
-        );
+        this.memoryManager = new MemoryManager();
         if (typeof this.memoryManager.initialize === 'function') {
           await this.memoryManager.initialize();
         }
@@ -178,12 +174,7 @@ export class SystemIntegration {
       // Initialize agent manager
       try {
         const { AgentManager } = await import('../agents/agent-manager.js');
-        this.agentManager = new AgentManager(
-          { maxAgents: 10 },
-          this.logger,
-          this.eventBus,
-          this.memoryManager
-        );
+        this.agentManager = new AgentManager(this.eventBus, this.logger);
         if (typeof this.agentManager.initialize === 'function') {
           await this.agentManager.initialize();
         }
@@ -199,7 +190,11 @@ export class SystemIntegration {
       // Initialize swarm coordinator
       try {
         const { SwarmCoordinator } = await import('../coordination/swarm-coordinator.js');
-        this.swarmCoordinator = new SwarmCoordinator();
+        this.swarmCoordinator = new SwarmCoordinator(
+          this.eventBus,
+          this.logger,
+          this.memoryManager!
+        );
         if (typeof this.swarmCoordinator.initialize === 'function') {
           await this.swarmCoordinator.initialize();
         }
@@ -207,7 +202,7 @@ 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.swarmCoordinator = new MockSwarmCoordinator(this.eventBus, this.logger, this.memoryManager!);
         await this.swarmCoordinator.initialize();
         this.updateComponentStatus('swarm', 'warning', 'Using mock swarm coordinator');
       }
@@ -230,7 +225,8 @@ export class SystemIntegration {
       try {
         const { TaskEngine } = await import('../task/engine.js');
         this.taskEngine = new TaskEngine(
-          10,
+          this.eventBus,
+          this.logger,
           this.memoryManager!
         );
         if (typeof this.taskEngine.initialize === 'function') {
@@ -240,7 +236,7 @@ export class SystemIntegration {
       } catch (error) {
         this.logger.warn('Task engine not available, using mock:', getErrorMessage(error));
         const { MockTaskEngine } = await import('./mock-components.js');
-        this.taskEngine = new MockTaskEngine();
+        this.taskEngine = new MockTaskEngine(this.eventBus, this.logger, this.memoryManager!);
         await this.taskEngine.initialize();
         this.updateComponentStatus('tasks', 'warning', 'Using mock task engine');
       }
@@ -262,12 +258,7 @@ export class SystemIntegration {
       // Initialize real-time monitor
       try {
         const { RealTimeMonitor } = await import('../monitoring/real-time-monitor.js');
-        this.monitor = new RealTimeMonitor(
-          { updateInterval: 5000 },
-          this.logger,
-          this.eventBus,
-          this.memoryManager!
-        );
+        this.monitor = new RealTimeMonitor(this.eventBus, this.logger);
         if (typeof this.monitor.initialize === 'function') {
           await this.monitor.initialize();
         }
@@ -275,19 +266,15 @@ export class SystemIntegration {
       } catch (error) {
         this.logger.warn('Real-time monitor not available, using mock:', getErrorMessage(error));
         const { MockRealTimeMonitor } = await import('./mock-components.js');
-        this.monitor = new MockRealTimeMonitor();
+        this.monitor = new MockRealTimeMonitor(this.eventBus, this.logger);
         await this.monitor.initialize();
         this.updateComponentStatus('monitor', 'warning', 'Using mock monitor');
       }
       
       // Initialize MCP server
       try {
-        const { MCPServer } = await import('../mcp/server.js');
-        this.mcpServer = new MCPServer(
-          { transport: 'stdio' },
-          this.eventBus,
-          this.logger
-        );
+        const { McpServer } = await import('../mcp/server.js');
+        this.mcpServer = new McpServer(this.eventBus, this.logger);
         if (typeof this.mcpServer.initialize === 'function') {
           await this.mcpServer.initialize();
         }
@@ -295,7 +282,7 @@ export class SystemIntegration {
       } catch (error) {
         this.logger.warn('MCP server not available, using mock:', getErrorMessage(error));
         const { MockMcpServer } = await import('./mock-components.js');
-        this.mcpServer = new MockMcpServer();
+        this.mcpServer = new MockMcpServer(this.eventBus, this.logger);
         await this.mcpServer.initialize();
         this.updateComponentStatus('mcp', 'warning', 'Using mock MCP server');
       }
@@ -351,18 +338,18 @@ export class SystemIntegration {
    */
   private setupEventHandlers(): void {
     // System health monitoring
-    this.eventBus.on('component:status', (event: any) => {
+    this.eventBus.on('component:status', (event) => {
       this.updateComponentStatus(event.component, event.status, event.message);
     });
     
     // Error handling
-    this.eventBus.on('system:error', (event: any) => {
+    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: any) => {
+    this.eventBus.on('performance:metric', (event) => {
       this.logger.debug(`Performance Metric: ${event.metric} = ${event.value}`);
     });
   }

package/src/mcp/index.ts

@@ -36,10 +36,12 @@ export {
 export { 
   AuthManager,
   type IAuthManager,
+  type AuthContext,
   type AuthResult,
-  type TokenValidation,
-  Permissions,
-  type Permission 
+  type TokenInfo,
+  type TokenGenerationOptions,
+  type AuthSession,
+  Permissions 
 } from './auth.js';
 
 // Performance Monitoring
@@ -88,13 +90,12 @@ export class MCPIntegrationFactory {
    */
   static async createIntegration(config: {
     mcpConfig: import('../utils/types.js').MCPConfig;
-    orchestrationConfig?: Partial<import('./orchestration-integration.js').MCPOrchestrationConfig>;
-    components?: Partial<import('./orchestration-integration.js').OrchestrationComponents>;
+    orchestrationConfig?: Partial<MCPOrchestrationConfig>;
+    components?: Partial<OrchestrationComponents>;
     logger: import('../core/logger.js').ILogger;
-  }): Promise<import('./orchestration-integration.js').MCPOrchestrationIntegration> {
+  }): Promise<MCPOrchestrationIntegration> {
     const { mcpConfig, orchestrationConfig = {}, components = {}, logger } = config;
 
-    const { MCPOrchestrationIntegration } = await import('./orchestration-integration.js');
     const integration = new MCPOrchestrationIntegration(
       mcpConfig,
       {
@@ -131,9 +132,9 @@ export class MCPIntegrationFactory {
     enableLifecycleManagement?: boolean;
     enablePerformanceMonitoring?: boolean;
   }): Promise<{
-    server: import('./server.js').MCPServer;
-    lifecycleManager?: import('./lifecycle-manager.js').MCPLifecycleManager;
-    performanceMonitor?: import('./performance-monitor.js').MCPPerformanceMonitor;
+    server: MCPServer;
+    lifecycleManager?: MCPLifecycleManager;
+    performanceMonitor?: MCPPerformanceMonitor;
   }> {
     const { 
       mcpConfig, 
@@ -143,14 +144,12 @@ export class MCPIntegrationFactory {
     } = config;
 
     const eventBus = new (await import('node:events')).EventEmitter();
-    const { MCPServer } = await import('./server.js');
     const server = new MCPServer(mcpConfig, eventBus, logger);
 
-    let lifecycleManager: import('./lifecycle-manager.js').MCPLifecycleManager | undefined;
-    let performanceMonitor: import('./performance-monitor.js').MCPPerformanceMonitor | undefined;
+    let lifecycleManager: MCPLifecycleManager | undefined;
+    let performanceMonitor: MCPPerformanceMonitor | undefined;
 
     if (enableLifecycleManagement) {
-      const { MCPLifecycleManager } = await import('./lifecycle-manager.js');
       lifecycleManager = new MCPLifecycleManager(
         mcpConfig,
         logger,
@@ -159,7 +158,6 @@ export class MCPIntegrationFactory {
     }
 
     if (enablePerformanceMonitoring) {
-      const { MCPPerformanceMonitor } = await import('./performance-monitor.js');
       performanceMonitor = new MCPPerformanceMonitor(logger);
     }
 
@@ -174,10 +172,10 @@ export class MCPIntegrationFactory {
    * Create a development/testing MCP setup
    */
   static async createDevelopmentSetup(logger: import('../core/logger.js').ILogger): Promise<{
-    server: import('./server.js').MCPServer;
-    lifecycleManager: import('./lifecycle-manager.js').MCPLifecycleManager;
-    performanceMonitor: import('./performance-monitor.js').MCPPerformanceMonitor;
-    protocolManager: import('./protocol-manager.js').MCPProtocolManager;
+    server: MCPServer;
+    lifecycleManager: MCPLifecycleManager;
+    performanceMonitor: MCPPerformanceMonitor;
+    protocolManager: MCPProtocolManager;
   }> {
     const mcpConfig: import('../utils/types.js').MCPConfig = {
       transport: 'stdio',
@@ -195,7 +193,6 @@ export class MCPIntegrationFactory {
       enablePerformanceMonitoring: true,
     });
 
-    const { MCPProtocolManager } = await import('./protocol-manager.js');
     const protocolManager = new MCPProtocolManager(logger);
 
     return {