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

package/src/config/ruv-swarm-integration.ts

@@ -1,7 +1,6 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * ruv-swarm integration helper for Claude Code configuration
- * 
+ *
  * This module bridges the main claude-flow configuration with
  * ruv-swarm specific settings and provides utility functions
  * for seamless integration.
@@ -39,21 +38,21 @@ export class RuvSwarmIntegration {
         defaultTopology: mainConfig.defaultTopology,
         maxAgents: mainConfig.maxAgents,
         defaultStrategy: mainConfig.defaultStrategy,
-        enableHooks: mainConfig.enableHooks
+        enableHooks: mainConfig.enableHooks,
       });
 
       this.ruvSwarmManager.updateIntegrationConfig({
         enableMCPTools: true,
         enableCLICommands: true,
-        enableHooks: mainConfig.enableHooks
+        enableHooks: mainConfig.enableHooks,
       });
 
       this.ruvSwarmManager.updateMemoryConfig({
-        enablePersistence: mainConfig.enablePersistence
+        enablePersistence: mainConfig.enablePersistence,
       });
 
       this.ruvSwarmManager.updateNeuralConfig({
-        enableTraining: mainConfig.enableNeuralTraining
+        enableTraining: mainConfig.enableNeuralTraining,
       });
     }
 
@@ -69,12 +68,12 @@ export class RuvSwarmIntegration {
 
     // Main config takes precedence, then ruv-swarm specific
     const unified = [...mainArgs];
-    
+
     // Add ruv-swarm specific args that aren't in main config
     for (let i = 0; i < ruvSwarmArgs.length; i += 2) {
       const flag = ruvSwarmArgs[i];
       const value = ruvSwarmArgs[i + 1];
-      
+
       // Skip if already set by main config
       if (!unified.includes(flag)) {
         unified.push(flag, value);
@@ -93,7 +92,7 @@ export class RuvSwarmIntegration {
       if (!this.configManager.isRuvSwarmEnabled()) {
         return {
           success: false,
-          message: 'ruv-swarm is disabled in main configuration'
+          message: 'ruv-swarm is disabled in main configuration',
         };
       }
 
@@ -105,7 +104,7 @@ export class RuvSwarmIntegration {
       if (!mainValidation.valid) {
         return {
           success: false,
-          message: `Main config validation failed: ${mainValidation.errors.join(', ')}`
+          message: `Main config validation failed: ${mainValidation.errors.join(', ')}`,
         };
       }
 
@@ -113,24 +112,23 @@ export class RuvSwarmIntegration {
       if (!ruvSwarmValidation.valid) {
         return {
           success: false,
-          message: `ruv-swarm config validation failed: ${ruvSwarmValidation.errors.join(', ')}`
+          message: `ruv-swarm config validation failed: ${ruvSwarmValidation.errors.join(', ')}`,
         };
       }
 
       // logger.info('ruv-swarm integration initialized successfully');
-      
+
       return {
         success: true,
-        message: 'ruv-swarm integration initialized and configured'
+        message: 'ruv-swarm integration initialized and configured',
       };
-
     } catch (error) {
       const message = `Failed to initialize ruv-swarm integration: ${(error as Error).message}`;
       // logger.error(message, { error });
-      
+
       return {
         success: false,
-        message
+        message,
       };
     }
   }
@@ -157,7 +155,7 @@ export class RuvSwarmIntegration {
 
     return {
       valid: errors.length === 0,
-      errors
+      errors,
     };
   }
 
@@ -177,7 +175,7 @@ export class RuvSwarmIntegration {
       enabled: mainConfig.enabled,
       mainConfig,
       ruvSwarmConfig,
-      synchronized: this.isConfigurationSynchronized()
+      synchronized: this.isConfigurationSynchronized(),
     };
   }
 
@@ -234,7 +232,10 @@ export function getRuvSwarmIntegration(): RuvSwarmIntegration {
 /**
  * Initialize ruv-swarm integration with claude-flow
  */
-export async function initializeRuvSwarmIntegration(): Promise<{ success: boolean; message: string }> {
+export async function initializeRuvSwarmIntegration(): Promise<{
+  success: boolean;
+  message: string;
+}> {
   const integration = getRuvSwarmIntegration();
   return integration.initialize();
 }
@@ -243,13 +244,12 @@ export async function initializeRuvSwarmIntegration(): Promise<{ success: boolea
  * Helper functions for CLI commands
  */
 export class RuvSwarmConfigHelpers {
-  
   /**
    * Quick setup for development environment
    */
   static setupDevelopmentConfig(): void {
     const integration = getRuvSwarmIntegration();
-    
+
     integration.updateConfiguration({
       main: {
         enabled: true,
@@ -259,8 +259,8 @@ export class RuvSwarmConfigHelpers {
         autoInit: true,
         enableHooks: true,
         enablePersistence: true,
-        enableNeuralTraining: true
-      }
+        enableNeuralTraining: true,
+      },
     });
 
     // logger.info('Development configuration applied');
@@ -271,7 +271,7 @@ export class RuvSwarmConfigHelpers {
    */
   static setupResearchConfig(): void {
     const integration = getRuvSwarmIntegration();
-    
+
     integration.updateConfiguration({
       main: {
         enabled: true,
@@ -281,8 +281,8 @@ export class RuvSwarmConfigHelpers {
         autoInit: true,
         enableHooks: true,
         enablePersistence: true,
-        enableNeuralTraining: true
-      }
+        enableNeuralTraining: true,
+      },
     });
 
     // logger.info('Research configuration applied');
@@ -293,7 +293,7 @@ export class RuvSwarmConfigHelpers {
    */
   static setupProductionConfig(): void {
     const integration = getRuvSwarmIntegration();
-    
+
     integration.updateConfiguration({
       main: {
         enabled: true,
@@ -303,8 +303,8 @@ export class RuvSwarmConfigHelpers {
         autoInit: false,
         enableHooks: true,
         enablePersistence: true,
-        enableNeuralTraining: false
-      }
+        enableNeuralTraining: false,
+      },
     });
 
     // logger.info('Production configuration applied');
@@ -315,32 +315,32 @@ export class RuvSwarmConfigHelpers {
    */
   static getConfigForUseCase(useCase: 'development' | 'research' | 'production'): any {
     const integration = getRuvSwarmIntegration();
-    
+
     switch (useCase) {
       case 'development':
         return {
           topology: 'hierarchical',
           maxAgents: 8,
           strategy: 'specialized',
-          features: ['hooks', 'persistence', 'neural-training']
+          features: ['hooks', 'persistence', 'neural-training'],
         };
-      
+
       case 'research':
         return {
           topology: 'mesh',
           maxAgents: 12,
           strategy: 'adaptive',
-          features: ['hooks', 'persistence', 'neural-training', 'advanced-metrics']
+          features: ['hooks', 'persistence', 'neural-training', 'advanced-metrics'],
         };
-        
+
       case 'production':
         return {
           topology: 'star',
           maxAgents: 6,
           strategy: 'balanced',
-          features: ['hooks', 'persistence']
+          features: ['hooks', 'persistence'],
         };
-        
+
       default:
         return integration.getStatus().mainConfig;
     }
@@ -351,5 +351,5 @@ export default {
   RuvSwarmIntegration,
   getRuvSwarmIntegration,
   initializeRuvSwarmIntegration,
-  RuvSwarmConfigHelpers
-};
+  RuvSwarmConfigHelpers,
+};

package/src/constants/agent-types.ts

@@ -14,10 +14,10 @@ export const AGENT_TYPES = {
   OPTIMIZER: 'optimizer',
   DOCUMENTER: 'documenter',
   MONITOR: 'monitor',
-  SPECIALIST: 'specialist'
+  SPECIALIST: 'specialist',
 } as const;
 
-export type AgentType = typeof AGENT_TYPES[keyof typeof AGENT_TYPES];
+export type AgentType = (typeof AGENT_TYPES)[keyof typeof AGENT_TYPES];
 
 // Array of all valid agent types for runtime validation
 export const VALID_AGENT_TYPES = Object.values(AGENT_TYPES);
@@ -26,7 +26,7 @@ export const VALID_AGENT_TYPES = Object.values(AGENT_TYPES);
 export const AGENT_TYPE_SCHEMA = {
   type: 'string',
   enum: VALID_AGENT_TYPES,
-  description: 'Type of AI agent'
+  description: 'Type of AI agent',
 };
 
 // Helper function to validate agent type
@@ -43,10 +43,10 @@ export const SWARM_STRATEGIES = {
   TESTING: 'testing',
   OPTIMIZATION: 'optimization',
   MAINTENANCE: 'maintenance',
-  CUSTOM: 'custom'
+  CUSTOM: 'custom',
 } as const;
 
-export type SwarmStrategy = typeof SWARM_STRATEGIES[keyof typeof SWARM_STRATEGIES];
+export type SwarmStrategy = (typeof SWARM_STRATEGIES)[keyof typeof SWARM_STRATEGIES];
 export const VALID_SWARM_STRATEGIES = Object.values(SWARM_STRATEGIES);
 
 // Task orchestration strategies (different from swarm strategies)
@@ -54,8 +54,9 @@ export const ORCHESTRATION_STRATEGIES = {
   PARALLEL: 'parallel',
   SEQUENTIAL: 'sequential',
   ADAPTIVE: 'adaptive',
-  BALANCED: 'balanced'
+  BALANCED: 'balanced',
 } as const;
 
-export type OrchestrationStrategy = typeof ORCHESTRATION_STRATEGIES[keyof typeof ORCHESTRATION_STRATEGIES];
-export const VALID_ORCHESTRATION_STRATEGIES = Object.values(ORCHESTRATION_STRATEGIES);
+export type OrchestrationStrategy =
+  (typeof ORCHESTRATION_STRATEGIES)[keyof typeof ORCHESTRATION_STRATEGIES];
+export const VALID_ORCHESTRATION_STRATEGIES = Object.values(ORCHESTRATION_STRATEGIES);

package/src/coordination/README.md

@@ -5,6 +5,7 @@ A comprehensive, scalable, and fault-tolerant coordination system for multi-agen
 ## Overview
 
 The coordination system provides:
+
 - **Task Scheduling**: Intelligent agent selection and priority handling
 - **Resource Management**: Distributed locking with deadlock detection
 - **Message Passing**: Inter-agent communication with reliability
@@ -90,10 +91,9 @@ const resourceManager = new ResourceManager(config, eventBus, logger);
 try {
   // Acquire with timeout and priority
   await resourceManager.acquire('database-lock', agentId, priority);
-  
+
   // Critical section
   await performDatabaseOperation();
-  
 } finally {
   await resourceManager.release('database-lock', agentId);
 }
@@ -106,12 +106,16 @@ Dynamic load balancing:
 ```typescript
 import { WorkStealingCoordinator } from './coordination/index.ts';
 
-const workStealing = new WorkStealingCoordinator({
-  enabled: true,
-  stealThreshold: 3,    // Trigger when difference > 3 tasks
-  maxStealBatch: 2,     // Steal up to 2 tasks at once
-  stealInterval: 5000,  // Check every 5 seconds
-}, eventBus, logger);
+const workStealing = new WorkStealingCoordinator(
+  {
+    enabled: true,
+    stealThreshold: 3, // Trigger when difference > 3 tasks
+    maxStealBatch: 2, // Steal up to 2 tasks at once
+    stealInterval: 5000, // Check every 5 seconds
+  },
+  eventBus,
+  logger,
+);
 
 // Update agent workload
 workStealing.updateAgentWorkload(agentId, {
@@ -159,12 +163,17 @@ Fault tolerance and cascade failure prevention:
 ```typescript
 import { CircuitBreaker, CircuitState } from './coordination/index.ts';
 
-const breaker = new CircuitBreaker('external-api', {
-  failureThreshold: 5,    // Open after 5 failures
-  successThreshold: 3,    // Close after 3 successes in half-open
-  timeout: 60000,         // Try half-open after 60s
-  halfOpenLimit: 2,       // Max 2 requests in half-open
-}, logger, eventBus);
+const breaker = new CircuitBreaker(
+  'external-api',
+  {
+    failureThreshold: 5, // Open after 5 failures
+    successThreshold: 3, // Close after 3 successes in half-open
+    timeout: 60000, // Try half-open after 60s
+    halfOpenLimit: 2, // Max 2 requests in half-open
+  },
+  logger,
+  eventBus,
+);
 
 // Execute with protection
 try {
@@ -193,17 +202,19 @@ const resolver = new ConflictResolver(logger, eventBus);
 resolver.registerStrategy(new PriorityResolutionStrategy());
 
 // Report conflict
-const conflict = await resolver.reportResourceConflict(
-  'shared-file',
-  ['agent1', 'agent2', 'agent3']
-);
+const conflict = await resolver.reportResourceConflict('shared-file', [
+  'agent1',
+  'agent2',
+  'agent3',
+]);
 
 // Resolve using priority strategy
-const resolution = await resolver.resolveConflict(
-  conflict.id,
-  'priority',
-  { agentPriorities: new Map([['agent1', 10], ['agent2', 5]]) }
-);
+const resolution = await resolver.resolveConflict(conflict.id, 'priority', {
+  agentPriorities: new Map([
+    ['agent1', 10],
+    ['agent2', 5],
+  ]),
+});
 
 console.log(`Winner: ${resolution.winner}`); // agent1 (higher priority)
 ```
@@ -228,8 +239,9 @@ console.log({
 });
 
 // Get metric history
-const history = metrics.getMetricHistory('task.completed', 
-  new Date(Date.now() - 3600000) // Last hour
+const history = metrics.getMetricHistory(
+  'task.completed',
+  new Date(Date.now() - 3600000), // Last hour
 );
 ```
 
@@ -237,11 +249,11 @@ const history = metrics.getMetricHistory('task.completed',
 
 ```typescript
 interface CoordinationConfig {
-  maxRetries: number;           // Task retry attempts
-  retryDelay: number;          // Base retry delay (ms)
-  deadlockDetection: boolean;   // Enable deadlock detection
-  resourceTimeout: number;      // Resource acquisition timeout (ms)
-  messageTimeout: number;       // Message delivery timeout (ms)
+  maxRetries: number; // Task retry attempts
+  retryDelay: number; // Base retry delay (ms)
+  deadlockDetection: boolean; // Enable deadlock detection
+  resourceTimeout: number; // Resource acquisition timeout (ms)
+  messageTimeout: number; // Message delivery timeout (ms)
 }
 
 const config: CoordinationConfig = {
@@ -292,30 +304,35 @@ eventBus.on('circuitbreaker:state-change', ({ name, from, to }) => {
 ## Best Practices
 
 ### Task Design
+
 - Keep tasks small and focused
 - Minimize dependencies between tasks
 - Use appropriate priority levels
 - Include timeout information
 
 ### Resource Management
+
 - Always use try/finally for resource cleanup
 - Set appropriate timeouts
 - Use meaningful resource IDs
 - Avoid holding multiple resources simultaneously when possible
 
 ### Agent Registration
+
 - Register agents with accurate capability information
 - Update workload metrics regularly
 - Handle agent failures gracefully
 - Implement proper cleanup on termination
 
 ### Error Handling
+
 - Use circuit breakers for external dependencies
 - Implement proper retry logic
 - Log errors with sufficient context
 - Gracefully degrade functionality when possible
 
 ### Monitoring
+
 - Monitor key metrics regularly
 - Set up alerting for deadlocks and conflicts
 - Track agent utilization and task throughput
@@ -339,18 +356,21 @@ deno test --coverage=coverage tests/unit/coordination/
 ## Performance Characteristics
 
 ### Scalability
+
 - **Agents**: Supports 100+ concurrent agents
 - **Tasks**: Handles 1000+ tasks in queue
 - **Resources**: Manages 500+ shared resources
 - **Messages**: Processes 10,000+ messages/minute
 
 ### Latency
+
 - **Task Assignment**: < 10ms (99th percentile)
 - **Resource Acquisition**: < 50ms (99th percentile)
 - **Message Delivery**: < 5ms (99th percentile)
 - **Conflict Resolution**: < 100ms (99th percentile)
 
 ### Reliability
+
 - **Deadlock Detection**: Sub-second detection
 - **Circuit Breaker**: Configurable failure thresholds
 - **Retry Logic**: Exponential backoff with jitter
@@ -361,16 +381,19 @@ deno test --coverage=coverage tests/unit/coordination/
 ### Common Issues
 
 1. **Deadlocks**
+
    - Enable deadlock detection
    - Reduce resource holding time
    - Use consistent resource ordering
 
 2. **Performance Issues**
+
    - Enable work stealing
    - Monitor agent utilization
    - Optimize task granularity
 
 3. **Resource Contention**
+
    - Increase resource timeout
    - Implement priority queuing
    - Use optimistic locking where possible
@@ -397,4 +420,4 @@ const eventBus = new EventBus(true); // Enable debug mode
 - **Persistent State**: Task and resource state persistence
 - **Advanced Scheduling**: ML-based agent selection
 - **Custom Protocols**: Pluggable coordination protocols
-- **Visual Monitoring**: Web-based coordination dashboard
+- **Visual Monitoring**: Web-based coordination dashboard

package/src/coordination/advanced-scheduler.ts

@@ -1,9 +1,14 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Advanced task scheduler with intelligent agent selection and priority handling
  */
 
-import { Task, TaskStatus, CoordinationConfig, SystemEvents, AgentProfile } from '../utils/types.js';
+import {
+  Task,
+  TaskStatus,
+  CoordinationConfig,
+  SystemEvents,
+  AgentProfile,
+} from '../utils/types.js';
 import type { IEventBus } from '../core/event-bus.js';
 import type { ILogger } from '../core/logger.js';
 import { TaskScheduler } from './scheduler.js';
@@ -39,11 +44,9 @@ export class CapabilitySchedulingStrategy implements SchedulingStrategy {
 
   selectAgent(task: Task, agents: AgentProfile[], context: SchedulingContext): string | null {
     // Filter agents by capability match
-    const capableAgents = agents.filter(agent => {
+    const capableAgents = agents.filter((agent) => {
       const capabilities = context.agentCapabilities.get(agent.id) || agent.capabilities;
-      return task.type === 'any' || 
-             capabilities.includes(task.type) ||
-             capabilities.includes('*');
+      return task.type === 'any' || capabilities.includes(task.type) || capabilities.includes('*');
     });
 
     if (capableAgents.length === 0) {
@@ -54,14 +57,14 @@ export class CapabilitySchedulingStrategy implements SchedulingStrategy {
     capableAgents.sort((a, b) => {
       const loadA = context.taskLoads.get(a.id) || 0;
       const loadB = context.taskLoads.get(b.id) || 0;
-      
+
       if (loadA !== loadB) {
         return loadA - loadB;
       }
-      
+
       const priorityA = context.agentPriorities.get(a.id) || a.priority;
       const priorityB = context.agentPriorities.get(b.id) || b.priority;
-      
+
       return priorityB - priorityA;
     });
 
@@ -120,10 +123,10 @@ export class AffinitySchedulingStrategy implements SchedulingStrategy {
 
   selectAgent(task: Task, agents: AgentProfile[], context: SchedulingContext): string | null {
     const taskStats = context.taskHistory.get(task.type);
-    
+
     if (taskStats?.lastAgent) {
       // Check if the last agent is available
-      const lastAgent = agents.find(a => a.id === taskStats.lastAgent);
+      const lastAgent = agents.find((a) => a.id === taskStats.lastAgent);
       if (lastAgent) {
         const load = context.taskLoads.get(lastAgent.id) || 0;
         // Use last agent if not overloaded
@@ -150,11 +153,7 @@ export class AdvancedTaskScheduler extends TaskScheduler {
   private circuitBreakers: CircuitBreakerManager;
   private defaultStrategy = 'capability';
 
-  constructor(
-    config: CoordinationConfig,
-    eventBus: IEventBus,
-    logger: ILogger,
-  ) {
+  constructor(config: CoordinationConfig, eventBus: IEventBus, logger: ILogger) {
     super(config, eventBus, logger);
 
     // Initialize components
@@ -192,7 +191,7 @@ export class AdvancedTaskScheduler extends TaskScheduler {
   override async initialize(): Promise<void> {
     await super.initialize();
     await this.workStealing.initialize();
-    
+
     this.logger.info('Advanced task scheduler initialized');
   }
 
@@ -319,9 +318,7 @@ export class AdvancedTaskScheduler extends TaskScheduler {
     }
 
     // Calculate duration
-    const duration = task.startedAt 
-      ? new Date().getTime() - task.startedAt.getTime()
-      : 0;
+    const duration = task.startedAt ? new Date().getTime() - task.startedAt.getTime() : 0;
 
     // Update task stats
     this.updateTaskStats(task.type, true, duration);
@@ -390,11 +387,11 @@ export class AdvancedTaskScheduler extends TaskScheduler {
     };
 
     stats.totalExecutions++;
-    
+
     if (success) {
       const successCount = Math.round(stats.successRate * (stats.totalExecutions - 1));
       stats.successRate = (successCount + 1) / stats.totalExecutions;
-      
+
       if (duration > 0) {
         const totalDuration = stats.avgDuration * (stats.totalExecutions - 1);
         stats.avgDuration = (totalDuration + duration) / stats.totalExecutions;
@@ -414,11 +411,11 @@ export class AdvancedTaskScheduler extends TaskScheduler {
     // Handle work stealing requests
     this.eventBus.on('workstealing:request', async (data: any) => {
       const { sourceAgent, targetAgent, taskCount } = data;
-      
+
       try {
         const tasks = await this.getAgentTasks(sourceAgent);
         const tasksToSteal = tasks
-          .filter(t => t.status === 'queued' || t.status === 'assigned')
+          .filter((t) => t.status === 'queued' || t.status === 'assigned')
           .slice(0, taskCount);
 
         for (const task of tasksToSteal) {
@@ -455,7 +452,7 @@ export class AdvancedTaskScheduler extends TaskScheduler {
   private async reassignTask(taskId: string, newAgentId: string): Promise<void> {
     // Cancel the current assignment
     await this.cancelTask(taskId, 'Reassigning to different agent');
-    
+
     // Get the task
     const task = await this.getTask(taskId);
     if (!task) {
@@ -485,4 +482,4 @@ export class AdvancedTaskScheduler extends TaskScheduler {
       defaultStrategy: this.defaultStrategy,
     };
   }
-}
+}