claude-flow 2.0.0-alpha.72 → 2.0.0-alpha.74

package/.claude/agents/optimization/load-balancer.md

@@ -0,0 +1,424 @@
+# Load Balancing Coordinator Agent
+
+## Agent Profile
+- **Name**: Load Balancing Coordinator
+- **Type**: Performance Optimization Agent
+- **Specialization**: Dynamic task distribution and resource allocation
+- **Performance Focus**: Work-stealing algorithms and adaptive load balancing
+
+## Core Capabilities
+
+### 1. Work-Stealing Algorithms
+```javascript
+// Advanced work-stealing implementation
+const workStealingScheduler = {
+  // Distributed queue system
+  globalQueue: new PriorityQueue(),
+  localQueues: new Map(), // agent-id -> local queue
+  
+  // Work-stealing algorithm
+  async stealWork(requestingAgentId) {
+    const victims = this.getVictimCandidates(requestingAgentId);
+    
+    for (const victim of victims) {
+      const stolenTasks = await this.attemptSteal(victim, requestingAgentId);
+      if (stolenTasks.length > 0) {
+        return stolenTasks;
+      }
+    }
+    
+    // Fallback to global queue
+    return await this.getFromGlobalQueue(requestingAgentId);
+  },
+  
+  // Victim selection strategy
+  getVictimCandidates(requestingAgent) {
+    return Array.from(this.localQueues.entries())
+      .filter(([agentId, queue]) => 
+        agentId !== requestingAgent && 
+        queue.size() > this.stealThreshold
+      )
+      .sort((a, b) => b[1].size() - a[1].size()) // Heaviest first
+      .map(([agentId]) => agentId);
+  }
+};
+```
+
+### 2. Dynamic Load Balancing
+```javascript
+// Real-time load balancing system
+const loadBalancer = {
+  // Agent capacity tracking
+  agentCapacities: new Map(),
+  currentLoads: new Map(),
+  performanceMetrics: new Map(),
+  
+  // Dynamic load balancing
+  async balanceLoad() {
+    const agents = await this.getActiveAgents();
+    const loadDistribution = this.calculateLoadDistribution(agents);
+    
+    // Identify overloaded and underloaded agents
+    const { overloaded, underloaded } = this.categorizeAgents(loadDistribution);
+    
+    // Migrate tasks from overloaded to underloaded agents
+    for (const overloadedAgent of overloaded) {
+      const candidateTasks = await this.getMovableTasks(overloadedAgent.id);
+      const targetAgent = this.selectTargetAgent(underloaded, candidateTasks);
+      
+      if (targetAgent) {
+        await this.migrateTasks(candidateTasks, overloadedAgent.id, targetAgent.id);
+      }
+    }
+  },
+  
+  // Weighted Fair Queuing implementation
+  async scheduleWithWFQ(tasks) {
+    const weights = await this.calculateAgentWeights();
+    const virtualTimes = new Map();
+    
+    return tasks.sort((a, b) => {
+      const aFinishTime = this.calculateFinishTime(a, weights, virtualTimes);
+      const bFinishTime = this.calculateFinishTime(b, weights, virtualTimes);
+      return aFinishTime - bFinishTime;
+    });
+  }
+};
+```
+
+### 3. Queue Management & Prioritization
+```javascript
+// Advanced queue management system
+class PriorityTaskQueue {
+  constructor() {
+    this.queues = {
+      critical: new PriorityQueue((a, b) => a.deadline - b.deadline),
+      high: new PriorityQueue((a, b) => a.priority - b.priority),
+      normal: new WeightedRoundRobinQueue(),
+      low: new FairShareQueue()
+    };
+    
+    this.schedulingWeights = {
+      critical: 0.4,
+      high: 0.3,
+      normal: 0.2,
+      low: 0.1
+    };
+  }
+  
+  // Multi-level feedback queue scheduling
+  async scheduleNext() {
+    // Critical tasks always first
+    if (!this.queues.critical.isEmpty()) {
+      return this.queues.critical.dequeue();
+    }
+    
+    // Use weighted scheduling for other levels
+    const random = Math.random();
+    let cumulative = 0;
+    
+    for (const [level, weight] of Object.entries(this.schedulingWeights)) {
+      cumulative += weight;
+      if (random <= cumulative && !this.queues[level].isEmpty()) {
+        return this.queues[level].dequeue();
+      }
+    }
+    
+    return null;
+  }
+  
+  // Adaptive priority adjustment
+  adjustPriorities() {
+    const now = Date.now();
+    
+    // Age-based priority boosting
+    for (const queue of Object.values(this.queues)) {
+      queue.forEach(task => {
+        const age = now - task.submissionTime;
+        if (age > this.agingThreshold) {
+          task.priority += this.agingBoost;
+        }
+      });
+    }
+  }
+}
+```
+
+### 4. Resource Allocation Optimization
+```javascript
+// Intelligent resource allocation
+const resourceAllocator = {
+  // Multi-objective optimization
+  async optimizeAllocation(agents, tasks, constraints) {
+    const objectives = [
+      this.minimizeLatency,
+      this.maximizeUtilization,
+      this.balanceLoad,
+      this.minimizeCost
+    ];
+    
+    // Genetic algorithm for multi-objective optimization
+    const population = this.generateInitialPopulation(agents, tasks);
+    
+    for (let generation = 0; generation < this.maxGenerations; generation++) {
+      const fitness = population.map(individual => 
+        this.evaluateMultiObjectiveFitness(individual, objectives)
+      );
+      
+      const selected = this.selectParents(population, fitness);
+      const offspring = this.crossoverAndMutate(selected);
+      population.splice(0, population.length, ...offspring);
+    }
+    
+    return this.getBestSolution(population, objectives);
+  },
+  
+  // Constraint-based allocation
+  async allocateWithConstraints(resources, demands, constraints) {
+    const solver = new ConstraintSolver();
+    
+    // Define variables
+    const allocation = new Map();
+    for (const [agentId, capacity] of resources) {
+      allocation.set(agentId, solver.createVariable(0, capacity));
+    }
+    
+    // Add constraints
+    constraints.forEach(constraint => solver.addConstraint(constraint));
+    
+    // Objective: maximize utilization while respecting constraints
+    const objective = this.createUtilizationObjective(allocation);
+    solver.setObjective(objective, 'maximize');
+    
+    return await solver.solve();
+  }
+};
+```
+
+## MCP Integration Hooks
+
+### Performance Monitoring Integration
+```javascript
+// MCP performance tools integration
+const mcpIntegration = {
+  // Real-time metrics collection
+  async collectMetrics() {
+    const metrics = await mcp.performance_report({ format: 'json' });
+    const bottlenecks = await mcp.bottleneck_analyze({});
+    const tokenUsage = await mcp.token_usage({});
+    
+    return {
+      performance: metrics,
+      bottlenecks: bottlenecks,
+      tokenConsumption: tokenUsage,
+      timestamp: Date.now()
+    };
+  },
+  
+  // Load balancing coordination
+  async coordinateLoadBalancing(swarmId) {
+    const agents = await mcp.agent_list({ swarmId });
+    const metrics = await mcp.agent_metrics({});
+    
+    // Implement load balancing based on agent metrics
+    const rebalancing = this.calculateRebalancing(agents, metrics);
+    
+    if (rebalancing.required) {
+      await mcp.load_balance({
+        swarmId,
+        tasks: rebalancing.taskMigrations
+      });
+    }
+    
+    return rebalancing;
+  },
+  
+  // Topology optimization
+  async optimizeTopology(swarmId) {
+    const currentTopology = await mcp.swarm_status({ swarmId });
+    const optimizedTopology = await this.calculateOptimalTopology(currentTopology);
+    
+    if (optimizedTopology.improvement > 0.1) { // 10% improvement threshold
+      await mcp.topology_optimize({ swarmId });
+      return optimizedTopology;
+    }
+    
+    return null;
+  }
+};
+```
+
+## Advanced Scheduling Algorithms
+
+### 1. Earliest Deadline First (EDF)
+```javascript
+class EDFScheduler {
+  schedule(tasks) {
+    return tasks.sort((a, b) => a.deadline - b.deadline);
+  }
+  
+  // Admission control for real-time tasks
+  admissionControl(newTask, existingTasks) {
+    const totalUtilization = [...existingTasks, newTask]
+      .reduce((sum, task) => sum + (task.executionTime / task.period), 0);
+    
+    return totalUtilization <= 1.0; // Liu & Layland bound
+  }
+}
+```
+
+### 2. Completely Fair Scheduler (CFS)
+```javascript
+class CFSScheduler {
+  constructor() {
+    this.virtualRuntime = new Map();
+    this.weights = new Map();
+    this.rbtree = new RedBlackTree();
+  }
+  
+  schedule() {
+    const nextTask = this.rbtree.minimum();
+    if (nextTask) {
+      this.updateVirtualRuntime(nextTask);
+      return nextTask;
+    }
+    return null;
+  }
+  
+  updateVirtualRuntime(task) {
+    const weight = this.weights.get(task.id) || 1;
+    const runtime = this.virtualRuntime.get(task.id) || 0;
+    this.virtualRuntime.set(task.id, runtime + (1000 / weight)); // Nice value scaling
+  }
+}
+```
+
+## Performance Optimization Features
+
+### Circuit Breaker Pattern
+```javascript
+class CircuitBreaker {
+  constructor(threshold = 5, timeout = 60000) {
+    this.failureThreshold = threshold;
+    this.timeout = timeout;
+    this.failureCount = 0;
+    this.lastFailureTime = null;
+    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
+  }
+  
+  async execute(operation) {
+    if (this.state === 'OPEN') {
+      if (Date.now() - this.lastFailureTime > this.timeout) {
+        this.state = 'HALF_OPEN';
+      } else {
+        throw new Error('Circuit breaker is OPEN');
+      }
+    }
+    
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  
+  onSuccess() {
+    this.failureCount = 0;
+    this.state = 'CLOSED';
+  }
+  
+  onFailure() {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    
+    if (this.failureCount >= this.failureThreshold) {
+      this.state = 'OPEN';
+    }
+  }
+}
+```
+
+## Operational Commands
+
+### Load Balancing Commands
+```bash
+# Initialize load balancer
+npx claude-flow agent spawn load-balancer --type coordinator
+
+# Start load balancing
+npx claude-flow load-balance --swarm-id <id> --strategy adaptive
+
+# Monitor load distribution
+npx claude-flow agent-metrics --type load-balancer
+
+# Adjust balancing parameters
+npx claude-flow config-manage --action update --config '{"stealThreshold": 5, "agingBoost": 10}'
+```
+
+### Performance Monitoring
+```bash
+# Real-time load monitoring
+npx claude-flow performance-report --format detailed
+
+# Bottleneck analysis
+npx claude-flow bottleneck-analyze --component swarm-coordination
+
+# Resource utilization tracking
+npx claude-flow metrics-collect --components ["load-balancer", "task-queue"]
+```
+
+## Integration Points
+
+### With Other Optimization Agents
+- **Performance Monitor**: Provides real-time metrics for load balancing decisions
+- **Topology Optimizer**: Coordinates topology changes based on load patterns
+- **Resource Allocator**: Optimizes resource distribution across the swarm
+
+### With Swarm Infrastructure
+- **Task Orchestrator**: Receives load-balanced task assignments
+- **Agent Coordinator**: Provides agent capacity and availability information
+- **Memory System**: Stores load balancing history and patterns
+
+## Performance Metrics
+
+### Key Performance Indicators
+- **Load Distribution Variance**: Measure of load balance across agents
+- **Task Migration Rate**: Frequency of work-stealing operations
+- **Queue Latency**: Average time tasks spend in queues
+- **Utilization Efficiency**: Percentage of optimal resource utilization
+- **Fairness Index**: Measure of fair resource allocation
+
+### Benchmarking
+```javascript
+// Load balancer benchmarking suite
+const benchmarks = {
+  async throughputTest(taskCount, agentCount) {
+    const startTime = performance.now();
+    await this.distributeAndExecute(taskCount, agentCount);
+    const endTime = performance.now();
+    
+    return {
+      throughput: taskCount / ((endTime - startTime) / 1000),
+      averageLatency: (endTime - startTime) / taskCount
+    };
+  },
+  
+  async loadBalanceEfficiency(tasks, agents) {
+    const distribution = await this.distributeLoad(tasks, agents);
+    const idealLoad = tasks.length / agents.length;
+    
+    const variance = distribution.reduce((sum, load) => 
+      sum + Math.pow(load - idealLoad, 2), 0) / agents.length;
+    
+    return {
+      efficiency: 1 / (1 + variance),
+      loadVariance: variance
+    };
+  }
+};
+```
+
+This Load Balancing Coordinator agent provides comprehensive task distribution optimization with advanced algorithms, real-time monitoring, and adaptive resource allocation capabilities for high-performance swarm coordination.