@claude-flow/cli 3.7.0-alpha.1 → 3.7.0-alpha.11

package/.claude/skills/v3-performance-optimization/SKILL.md

@@ -1,390 +1,390 @@
----
-name: "V3 Performance Optimization"
-description: "Achieve aggressive v3 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite."
----
-
-# V3 Performance Optimization
-
-## What This Skill Does
-
-Validates and optimizes claude-flow v3 to achieve industry-leading performance through Flash Attention, AgentDB HNSW indexing, and comprehensive system optimization with continuous benchmarking.
-
-## Quick Start
-
-```bash
-# Initialize performance optimization
-Task("Performance baseline", "Establish v2 performance benchmarks", "v3-performance-engineer")
-
-# Target validation (parallel)
-Task("Flash Attention", "Validate 2.49x-7.47x speedup target", "v3-performance-engineer")
-Task("Search optimization", "Validate 150x-12,500x search improvement", "v3-performance-engineer")
-Task("Memory optimization", "Achieve 50-75% memory reduction", "v3-performance-engineer")
-```
-
-## Performance Target Matrix
-
-### Flash Attention Revolution
-```
-┌─────────────────────────────────────────┐
-│           FLASH ATTENTION               │
-├─────────────────────────────────────────┤
-│  Baseline: Standard attention           │
-│  Target:   2.49x - 7.47x speedup       │
-│  Memory:   50-75% reduction             │
-│  Latency:  Sub-millisecond processing   │
-└─────────────────────────────────────────┘
-```
-
-### Search Performance Revolution
-```
-┌─────────────────────────────────────────┐
-│            SEARCH OPTIMIZATION         │
-├─────────────────────────────────────────┤
-│  Current:  O(n) linear search           │
-│  Target:   150x - 12,500x improvement   │
-│  Method:   HNSW indexing                │
-│  Latency:  <100ms for 1M+ entries       │
-└─────────────────────────────────────────┘
-```
-
-## Comprehensive Benchmark Suite
-
-### Startup Performance
-```typescript
-class StartupBenchmarks {
-  async benchmarkColdStart(): Promise<BenchmarkResult> {
-    const startTime = performance.now();
-
-    await this.initializeCLI();
-    await this.initializeMCPServer();
-    await this.spawnTestAgent();
-
-    const totalTime = performance.now() - startTime;
-
-    return {
-      total: totalTime,
-      target: 500, // ms
-      achieved: totalTime < 500
-    };
-  }
-}
-```
-
-### Memory Operation Benchmarks
-```typescript
-class MemoryBenchmarks {
-  async benchmarkVectorSearch(): Promise<SearchBenchmark> {
-    const queries = this.generateTestQueries(10000);
-
-    // Baseline: Current linear search
-    const baselineTime = await this.timeOperation(() =>
-      this.currentMemory.searchAll(queries)
-    );
-
-    // Target: HNSW search
-    const hnswTime = await this.timeOperation(() =>
-      this.agentDBMemory.hnswSearchAll(queries)
-    );
-
-    const improvement = baselineTime / hnswTime;
-
-    return {
-      baseline: baselineTime,
-      hnsw: hnswTime,
-      improvement,
-      targetRange: [150, 12500],
-      achieved: improvement >= 150
-    };
-  }
-
-  async benchmarkMemoryUsage(): Promise<MemoryBenchmark> {
-    const baseline = process.memoryUsage().heapUsed;
-
-    await this.loadTestDataset();
-    const withData = process.memoryUsage().heapUsed;
-
-    await this.enableOptimization();
-    const optimized = process.memoryUsage().heapUsed;
-
-    const reduction = (withData - optimized) / withData;
-
-    return {
-      baseline,
-      withData,
-      optimized,
-      reductionPercent: reduction * 100,
-      targetReduction: [50, 75],
-      achieved: reduction >= 0.5
-    };
-  }
-}
-```
-
-### Swarm Coordination Benchmarks
-```typescript
-class SwarmBenchmarks {
-  async benchmark15AgentCoordination(): Promise<SwarmBenchmark> {
-    const agents = await this.spawn15Agents();
-
-    // Coordination latency
-    const coordinationTime = await this.timeOperation(() =>
-      this.coordinateSwarmTask(agents)
-    );
-
-    // Task decomposition
-    const decompositionTime = await this.timeOperation(() =>
-      this.decomposeComplexTask()
-    );
-
-    // Consensus achievement
-    const consensusTime = await this.timeOperation(() =>
-      this.achieveSwarmConsensus(agents)
-    );
-
-    return {
-      coordination: coordinationTime,
-      decomposition: decompositionTime,
-      consensus: consensusTime,
-      agentCount: 15,
-      efficiency: this.calculateEfficiency(agents)
-    };
-  }
-}
-```
-
-### Flash Attention Benchmarks
-```typescript
-class AttentionBenchmarks {
-  async benchmarkFlashAttention(): Promise<AttentionBenchmark> {
-    const sequences = this.generateSequences([512, 1024, 2048, 4096]);
-    const results = [];
-
-    for (const sequence of sequences) {
-      // Baseline attention
-      const baselineResult = await this.benchmarkStandardAttention(sequence);
-
-      // Flash attention
-      const flashResult = await this.benchmarkFlashAttention(sequence);
-
-      results.push({
-        sequenceLength: sequence.length,
-        speedup: baselineResult.time / flashResult.time,
-        memoryReduction: (baselineResult.memory - flashResult.memory) / baselineResult.memory,
-        targetSpeedup: [2.49, 7.47],
-        achieved: this.checkTarget(flashResult, [2.49, 7.47])
-      });
-    }
-
-    return {
-      results,
-      averageSpeedup: this.calculateAverage(results, 'speedup'),
-      averageMemoryReduction: this.calculateAverage(results, 'memoryReduction')
-    };
-  }
-}
-```
-
-### SONA Learning Benchmarks
-```typescript
-class SONABenchmarks {
-  async benchmarkAdaptationTime(): Promise<SONABenchmark> {
-    const scenarios = [
-      'pattern_recognition',
-      'task_optimization',
-      'error_correction',
-      'performance_tuning'
-    ];
-
-    const results = [];
-
-    for (const scenario of scenarios) {
-      const startTime = performance.hrtime.bigint();
-      await this.sona.adapt(scenario);
-      const endTime = performance.hrtime.bigint();
-
-      const adaptationTimeMs = Number(endTime - startTime) / 1000000;
-
-      results.push({
-        scenario,
-        adaptationTime: adaptationTimeMs,
-        target: 0.05, // ms
-        achieved: adaptationTimeMs <= 0.05
-      });
-    }
-
-    return {
-      scenarios: results,
-      averageTime: results.reduce((sum, r) => sum + r.adaptationTime, 0) / results.length,
-      successRate: results.filter(r => r.achieved).length / results.length
-    };
-  }
-}
-```
-
-## Performance Monitoring Dashboard
-
-### Real-time Metrics
-```typescript
-class PerformanceMonitor {
-  async collectMetrics(): Promise<PerformanceSnapshot> {
-    return {
-      timestamp: Date.now(),
-      flashAttention: await this.measureFlashAttention(),
-      searchPerformance: await this.measureSearchSpeed(),
-      memoryUsage: await this.measureMemoryEfficiency(),
-      startupTime: await this.measureStartupLatency(),
-      sonaAdaptation: await this.measureSONASpeed(),
-      swarmCoordination: await this.measureSwarmEfficiency()
-    };
-  }
-
-  async generateReport(): Promise<PerformanceReport> {
-    const snapshot = await this.collectMetrics();
-
-    return {
-      summary: this.generateSummary(snapshot),
-      achievements: this.checkTargetAchievements(snapshot),
-      trends: this.analyzeTrends(),
-      recommendations: this.generateOptimizations(),
-      regressions: await this.detectRegressions()
-    };
-  }
-}
-```
-
-### Continuous Regression Detection
-```typescript
-class PerformanceRegression {
-  async detectRegressions(): Promise<RegressionReport> {
-    const current = await this.runFullBenchmark();
-    const baseline = await this.getBaseline();
-
-    const regressions = [];
-
-    for (const [metric, currentValue] of Object.entries(current)) {
-      const baselineValue = baseline[metric];
-      const change = (currentValue - baselineValue) / baselineValue;
-
-      if (change < -0.05) { // 5% regression threshold
-        regressions.push({
-          metric,
-          baseline: baselineValue,
-          current: currentValue,
-          regressionPercent: change * 100,
-          severity: this.classifyRegression(change)
-        });
-      }
-    }
-
-    return {
-      hasRegressions: regressions.length > 0,
-      regressions,
-      recommendations: this.generateRegressionFixes(regressions)
-    };
-  }
-}
-```
-
-## Optimization Strategies
-
-### Memory Optimization
-```typescript
-class MemoryOptimization {
-  async optimizeMemoryUsage(): Promise<OptimizationResult> {
-    // Implement memory pooling
-    await this.setupMemoryPools();
-
-    // Enable garbage collection tuning
-    await this.optimizeGarbageCollection();
-
-    // Implement object reuse patterns
-    await this.setupObjectPools();
-
-    // Enable memory compression
-    await this.enableMemoryCompression();
-
-    return this.validateMemoryReduction();
-  }
-}
-```
-
-### CPU Optimization
-```typescript
-class CPUOptimization {
-  async optimizeCPUUsage(): Promise<OptimizationResult> {
-    // Implement worker thread pools
-    await this.setupWorkerThreads();
-
-    // Enable CPU-specific optimizations
-    await this.enableSIMDInstructions();
-
-    // Implement task batching
-    await this.optimizeTaskBatching();
-
-    return this.validateCPUImprovement();
-  }
-}
-```
-
-## Target Validation Framework
-
-### Performance Gates
-```typescript
-class PerformanceGates {
-  async validateAllTargets(): Promise<ValidationReport> {
-    const results = await Promise.all([
-      this.validateFlashAttention(),     // 2.49x-7.47x
-      this.validateSearchPerformance(),  // 150x-12,500x
-      this.validateMemoryReduction(),    // 50-75%
-      this.validateStartupTime(),        // <500ms
-      this.validateSONAAdaptation()      // <0.05ms
-    ]);
-
-    return {
-      allTargetsAchieved: results.every(r => r.achieved),
-      results,
-      overallScore: this.calculateOverallScore(results),
-      recommendations: this.generateRecommendations(results)
-    };
-  }
-}
-```
-
-## Success Metrics
-
-### Primary Targets
-- [ ] **Flash Attention**: 2.49x-7.47x speedup validated
-- [ ] **Search Performance**: 150x-12,500x improvement confirmed
-- [ ] **Memory Reduction**: 50-75% usage optimization achieved
-- [ ] **Startup Time**: <500ms cold start consistently
-- [ ] **SONA Adaptation**: <0.05ms learning response time
-- [ ] **15-Agent Coordination**: Efficient parallel execution
-
-### Continuous Monitoring
-- [ ] **Performance Dashboard**: Real-time metrics collection
-- [ ] **Regression Testing**: Automated performance validation
-- [ ] **Trend Analysis**: Performance evolution tracking
-- [ ] **Alert System**: Immediate regression notification
-
-## Related V3 Skills
-
-- `v3-integration-deep` - Performance integration with agentic-flow
-- `v3-memory-unification` - Memory performance optimization
-- `v3-swarm-coordination` - Swarm performance coordination
-- `v3-security-overhaul` - Secure performance patterns
-
-## Usage Examples
-
-### Complete Performance Validation
-```bash
-# Full performance suite
-npm run benchmark:v3
-
-# Specific target validation
-npm run benchmark:flash-attention
-npm run benchmark:agentdb-search
-npm run benchmark:memory-optimization
-
-# Continuous monitoring
-npm run monitor:performance
+---
+name: "V3 Performance Optimization"
+description: "Achieve aggressive v3 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite."
+---
+
+# V3 Performance Optimization
+
+## What This Skill Does
+
+Validates and optimizes claude-flow v3 to achieve industry-leading performance through Flash Attention, AgentDB HNSW indexing, and comprehensive system optimization with continuous benchmarking.
+
+## Quick Start
+
+```bash
+# Initialize performance optimization
+Task("Performance baseline", "Establish v2 performance benchmarks", "v3-performance-engineer")
+
+# Target validation (parallel)
+Task("Flash Attention", "Validate 2.49x-7.47x speedup target", "v3-performance-engineer")
+Task("Search optimization", "Validate 150x-12,500x search improvement", "v3-performance-engineer")
+Task("Memory optimization", "Achieve 50-75% memory reduction", "v3-performance-engineer")
+```
+
+## Performance Target Matrix
+
+### Flash Attention Revolution
+```
+┌─────────────────────────────────────────┐
+│           FLASH ATTENTION               │
+├─────────────────────────────────────────┤
+│  Baseline: Standard attention           │
+│  Target:   2.49x - 7.47x speedup       │
+│  Memory:   50-75% reduction             │
+│  Latency:  Sub-millisecond processing   │
+└─────────────────────────────────────────┘
+```
+
+### Search Performance Revolution
+```
+┌─────────────────────────────────────────┐
+│            SEARCH OPTIMIZATION         │
+├─────────────────────────────────────────┤
+│  Current:  O(n) linear search           │
+│  Target:   150x - 12,500x improvement   │
+│  Method:   HNSW indexing                │
+│  Latency:  <100ms for 1M+ entries       │
+└─────────────────────────────────────────┘
+```
+
+## Comprehensive Benchmark Suite
+
+### Startup Performance
+```typescript
+class StartupBenchmarks {
+  async benchmarkColdStart(): Promise<BenchmarkResult> {
+    const startTime = performance.now();
+
+    await this.initializeCLI();
+    await this.initializeMCPServer();
+    await this.spawnTestAgent();
+
+    const totalTime = performance.now() - startTime;
+
+    return {
+      total: totalTime,
+      target: 500, // ms
+      achieved: totalTime < 500
+    };
+  }
+}
+```
+
+### Memory Operation Benchmarks
+```typescript
+class MemoryBenchmarks {
+  async benchmarkVectorSearch(): Promise<SearchBenchmark> {
+    const queries = this.generateTestQueries(10000);
+
+    // Baseline: Current linear search
+    const baselineTime = await this.timeOperation(() =>
+      this.currentMemory.searchAll(queries)
+    );
+
+    // Target: HNSW search
+    const hnswTime = await this.timeOperation(() =>
+      this.agentDBMemory.hnswSearchAll(queries)
+    );
+
+    const improvement = baselineTime / hnswTime;
+
+    return {
+      baseline: baselineTime,
+      hnsw: hnswTime,
+      improvement,
+      targetRange: [150, 12500],
+      achieved: improvement >= 150
+    };
+  }
+
+  async benchmarkMemoryUsage(): Promise<MemoryBenchmark> {
+    const baseline = process.memoryUsage().heapUsed;
+
+    await this.loadTestDataset();
+    const withData = process.memoryUsage().heapUsed;
+
+    await this.enableOptimization();
+    const optimized = process.memoryUsage().heapUsed;
+
+    const reduction = (withData - optimized) / withData;
+
+    return {
+      baseline,
+      withData,
+      optimized,
+      reductionPercent: reduction * 100,
+      targetReduction: [50, 75],
+      achieved: reduction >= 0.5
+    };
+  }
+}
+```
+
+### Swarm Coordination Benchmarks
+```typescript
+class SwarmBenchmarks {
+  async benchmark15AgentCoordination(): Promise<SwarmBenchmark> {
+    const agents = await this.spawn15Agents();
+
+    // Coordination latency
+    const coordinationTime = await this.timeOperation(() =>
+      this.coordinateSwarmTask(agents)
+    );
+
+    // Task decomposition
+    const decompositionTime = await this.timeOperation(() =>
+      this.decomposeComplexTask()
+    );
+
+    // Consensus achievement
+    const consensusTime = await this.timeOperation(() =>
+      this.achieveSwarmConsensus(agents)
+    );
+
+    return {
+      coordination: coordinationTime,
+      decomposition: decompositionTime,
+      consensus: consensusTime,
+      agentCount: 15,
+      efficiency: this.calculateEfficiency(agents)
+    };
+  }
+}
+```
+
+### Flash Attention Benchmarks
+```typescript
+class AttentionBenchmarks {
+  async benchmarkFlashAttention(): Promise<AttentionBenchmark> {
+    const sequences = this.generateSequences([512, 1024, 2048, 4096]);
+    const results = [];
+
+    for (const sequence of sequences) {
+      // Baseline attention
+      const baselineResult = await this.benchmarkStandardAttention(sequence);
+
+      // Flash attention
+      const flashResult = await this.benchmarkFlashAttention(sequence);
+
+      results.push({
+        sequenceLength: sequence.length,
+        speedup: baselineResult.time / flashResult.time,
+        memoryReduction: (baselineResult.memory - flashResult.memory) / baselineResult.memory,
+        targetSpeedup: [2.49, 7.47],
+        achieved: this.checkTarget(flashResult, [2.49, 7.47])
+      });
+    }
+
+    return {
+      results,
+      averageSpeedup: this.calculateAverage(results, 'speedup'),
+      averageMemoryReduction: this.calculateAverage(results, 'memoryReduction')
+    };
+  }
+}
+```
+
+### SONA Learning Benchmarks
+```typescript
+class SONABenchmarks {
+  async benchmarkAdaptationTime(): Promise<SONABenchmark> {
+    const scenarios = [
+      'pattern_recognition',
+      'task_optimization',
+      'error_correction',
+      'performance_tuning'
+    ];
+
+    const results = [];
+
+    for (const scenario of scenarios) {
+      const startTime = performance.hrtime.bigint();
+      await this.sona.adapt(scenario);
+      const endTime = performance.hrtime.bigint();
+
+      const adaptationTimeMs = Number(endTime - startTime) / 1000000;
+
+      results.push({
+        scenario,
+        adaptationTime: adaptationTimeMs,
+        target: 0.05, // ms
+        achieved: adaptationTimeMs <= 0.05
+      });
+    }
+
+    return {
+      scenarios: results,
+      averageTime: results.reduce((sum, r) => sum + r.adaptationTime, 0) / results.length,
+      successRate: results.filter(r => r.achieved).length / results.length
+    };
+  }
+}
+```
+
+## Performance Monitoring Dashboard
+
+### Real-time Metrics
+```typescript
+class PerformanceMonitor {
+  async collectMetrics(): Promise<PerformanceSnapshot> {
+    return {
+      timestamp: Date.now(),
+      flashAttention: await this.measureFlashAttention(),
+      searchPerformance: await this.measureSearchSpeed(),
+      memoryUsage: await this.measureMemoryEfficiency(),
+      startupTime: await this.measureStartupLatency(),
+      sonaAdaptation: await this.measureSONASpeed(),
+      swarmCoordination: await this.measureSwarmEfficiency()
+    };
+  }
+
+  async generateReport(): Promise<PerformanceReport> {
+    const snapshot = await this.collectMetrics();
+
+    return {
+      summary: this.generateSummary(snapshot),
+      achievements: this.checkTargetAchievements(snapshot),
+      trends: this.analyzeTrends(),
+      recommendations: this.generateOptimizations(),
+      regressions: await this.detectRegressions()
+    };
+  }
+}
+```
+
+### Continuous Regression Detection
+```typescript
+class PerformanceRegression {
+  async detectRegressions(): Promise<RegressionReport> {
+    const current = await this.runFullBenchmark();
+    const baseline = await this.getBaseline();
+
+    const regressions = [];
+
+    for (const [metric, currentValue] of Object.entries(current)) {
+      const baselineValue = baseline[metric];
+      const change = (currentValue - baselineValue) / baselineValue;
+
+      if (change < -0.05) { // 5% regression threshold
+        regressions.push({
+          metric,
+          baseline: baselineValue,
+          current: currentValue,
+          regressionPercent: change * 100,
+          severity: this.classifyRegression(change)
+        });
+      }
+    }
+
+    return {
+      hasRegressions: regressions.length > 0,
+      regressions,
+      recommendations: this.generateRegressionFixes(regressions)
+    };
+  }
+}
+```
+
+## Optimization Strategies
+
+### Memory Optimization
+```typescript
+class MemoryOptimization {
+  async optimizeMemoryUsage(): Promise<OptimizationResult> {
+    // Implement memory pooling
+    await this.setupMemoryPools();
+
+    // Enable garbage collection tuning
+    await this.optimizeGarbageCollection();
+
+    // Implement object reuse patterns
+    await this.setupObjectPools();
+
+    // Enable memory compression
+    await this.enableMemoryCompression();
+
+    return this.validateMemoryReduction();
+  }
+}
+```
+
+### CPU Optimization
+```typescript
+class CPUOptimization {
+  async optimizeCPUUsage(): Promise<OptimizationResult> {
+    // Implement worker thread pools
+    await this.setupWorkerThreads();
+
+    // Enable CPU-specific optimizations
+    await this.enableSIMDInstructions();
+
+    // Implement task batching
+    await this.optimizeTaskBatching();
+
+    return this.validateCPUImprovement();
+  }
+}
+```
+
+## Target Validation Framework
+
+### Performance Gates
+```typescript
+class PerformanceGates {
+  async validateAllTargets(): Promise<ValidationReport> {
+    const results = await Promise.all([
+      this.validateFlashAttention(),     // 2.49x-7.47x
+      this.validateSearchPerformance(),  // 150x-12,500x
+      this.validateMemoryReduction(),    // 50-75%
+      this.validateStartupTime(),        // <500ms
+      this.validateSONAAdaptation()      // <0.05ms
+    ]);
+
+    return {
+      allTargetsAchieved: results.every(r => r.achieved),
+      results,
+      overallScore: this.calculateOverallScore(results),
+      recommendations: this.generateRecommendations(results)
+    };
+  }
+}
+```
+
+## Success Metrics
+
+### Primary Targets
+- [ ] **Flash Attention**: 2.49x-7.47x speedup validated
+- [ ] **Search Performance**: 150x-12,500x improvement confirmed
+- [ ] **Memory Reduction**: 50-75% usage optimization achieved
+- [ ] **Startup Time**: <500ms cold start consistently
+- [ ] **SONA Adaptation**: <0.05ms learning response time
+- [ ] **15-Agent Coordination**: Efficient parallel execution
+
+### Continuous Monitoring
+- [ ] **Performance Dashboard**: Real-time metrics collection
+- [ ] **Regression Testing**: Automated performance validation
+- [ ] **Trend Analysis**: Performance evolution tracking
+- [ ] **Alert System**: Immediate regression notification
+
+## Related V3 Skills
+
+- `v3-integration-deep` - Performance integration with agentic-flow
+- `v3-memory-unification` - Memory performance optimization
+- `v3-swarm-coordination` - Swarm performance coordination
+- `v3-security-overhaul` - Secure performance patterns
+
+## Usage Examples
+
+### Complete Performance Validation
+```bash
+# Full performance suite
+npm run benchmark:v3
+
+# Specific target validation
+npm run benchmark:flash-attention
+npm run benchmark:agentdb-search
+npm run benchmark:memory-optimization
+
+# Continuous monitoring
+npm run monitor:performance
 ```