claude-flow 3.0.0-alpha.8 → 3.0.0-alpha.9

package/.claude/skills/worker-benchmarks/skill.md

@@ -1,135 +0,0 @@
----
-name: worker-benchmarks
-description: Run comprehensive worker system benchmarks and performance analysis
-version: 1.0.0
-invocable: true
-author: agentic-flow
-capabilities:
-  - performance_testing
-  - metrics_collection
-  - optimization_recommendations
----
-
-# Worker Benchmarks Skill
-
-Run comprehensive performance benchmarks for the agentic-flow worker system.
-
-## Quick Start
-
-```bash
-# Run full benchmark suite
-npx agentic-flow workers benchmark
-
-# Run specific benchmark
-npx agentic-flow workers benchmark --type trigger-detection
-npx agentic-flow workers benchmark --type registry
-npx agentic-flow workers benchmark --type agent-selection
-npx agentic-flow workers benchmark --type concurrent
-```
-
-## Benchmark Types
-
-### 1. Trigger Detection (`trigger-detection`)
-Tests keyword detection speed across 12 worker triggers.
-- **Target**: p95 < 5ms
-- **Iterations**: 1000
-- **Metrics**: latency, throughput, histogram
-
-### 2. Worker Registry (`registry`)
-Tests CRUD operations on worker entries.
-- **Target**: p95 < 10ms
-- **Iterations**: 500 creates, gets, updates
-- **Metrics**: per-operation latency breakdown
-
-### 3. Agent Selection (`agent-selection`)
-Tests performance-based agent selection.
-- **Target**: p95 < 1ms
-- **Iterations**: 1000
-- **Metrics**: selection confidence, agent scores
-
-### 4. Model Cache (`cache`)
-Tests model caching performance.
-- **Target**: p95 < 0.5ms
-- **Metrics**: hit rate, cache size, eviction stats
-
-### 5. Concurrent Workers (`concurrent`)
-Tests parallel worker creation and updates.
-- **Target**: < 1000ms for 10 workers
-- **Metrics**: per-worker latency, memory usage
-
-### 6. Memory Key Generation (`memory-keys`)
-Tests memory pattern key generation.
-- **Target**: p95 < 0.1ms
-- **Iterations**: 5000
-- **Metrics**: unique patterns, throughput
-
-## Output Format
-
-```
-═══════════════════════════════════════════════════════════
-📈 BENCHMARK RESULTS
-═══════════════════════════════════════════════════════════
-
-✅ Trigger Detection
-   Operation: detect
-   Count: 1,000
-   Avg: 0.045ms | p95: 0.120ms (target: 5ms)
-   Throughput: 22,222 ops/s
-   Memory Δ: 0.12MB
-
-✅ Worker Registry
-   Operation: crud
-   Count: 1,500
-   Avg: 1.234ms | p95: 3.456ms (target: 10ms)
-   Throughput: 810 ops/s
-   Memory Δ: 2.34MB
-
-───────────────────────────────────────────────────────────
-📊 SUMMARY
-───────────────────────────────────────────────────────────
-Total Tests: 6
-Passed: 6 | Failed: 0
-Avg Latency: 0.567ms
-Total Duration: 2345ms
-Peak Memory: 8.90MB
-═══════════════════════════════════════════════════════════
-```
-
-## Integration with Settings
-
-Benchmark thresholds are configured in `.claude/settings.json`:
-
-```json
-{
-  "performance": {
-    "benchmarkThresholds": {
-      "triggerDetection": { "p95Ms": 5 },
-      "workerRegistry": { "p95Ms": 10 },
-      "agentSelection": { "p95Ms": 1 },
-      "memoryKeyGeneration": { "p95Ms": 0.1 },
-      "concurrentWorkers": { "totalMs": 1000 }
-    }
-  }
-}
-```
-
-## Programmatic Usage
-
-```typescript
-import { workerBenchmarks, runBenchmarks } from 'agentic-flow/workers/worker-benchmarks';
-
-// Run full suite
-const suite = await runBenchmarks();
-console.log(suite.summary);
-
-// Run individual benchmarks
-const triggerResult = await workerBenchmarks.benchmarkTriggerDetection(1000);
-const registryResult = await workerBenchmarks.benchmarkRegistryOperations(500);
-```
-
-## Performance Optimization Tips
-
-1. **Model Cache**: Enable with `CLAUDE_FLOW_MODEL_CACHE_MB=512`
-2. **Parallel Workers**: Enable with `CLAUDE_FLOW_WORKER_PARALLEL=true`
-3. **Warning Suppression**: Enable with `CLAUDE_FLOW_SUPPRESS_WARNINGS=true`
-4. **SQLite WAL Mode**: Automatic for better concurrent performance

package/.claude/skills/worker-integration/skill.md

@@ -1,154 +0,0 @@
----
-name: worker-integration
-description: Worker-Agent integration for intelligent task dispatch and performance tracking
-version: 1.0.0
-invocable: true
-author: agentic-flow
-capabilities:
-  - agent_selection
-  - performance_tracking
-  - memory_coordination
-  - self_learning
----
-
-# Worker-Agent Integration Skill
-
-Intelligent coordination between background workers and specialized agents.
-
-## Quick Start
-
-```bash
-# View agent recommendations for a trigger
-npx agentic-flow workers agents ultralearn
-npx agentic-flow workers agents optimize
-
-# View performance metrics
-npx agentic-flow workers metrics
-
-# View integration stats
-npx agentic-flow workers stats --integration
-```
-
-## Agent Mappings
-
-Workers automatically dispatch to optimal agents based on trigger type:
-
-| Trigger | Primary Agents | Fallback | Pipeline Phases |
-|---------|---------------|----------|-----------------|
-| `ultralearn` | researcher, coder | planner | discovery → patterns → vectorization → summary |
-| `optimize` | performance-analyzer, coder | researcher | static-analysis → performance → patterns |
-| `audit` | security-analyst, tester | reviewer | security → secrets → vulnerability-scan |
-| `benchmark` | performance-analyzer | coder, tester | performance → metrics → report |
-| `testgaps` | tester | coder | discovery → coverage → gaps |
-| `document` | documenter, researcher | coder | api-discovery → patterns → indexing |
-| `deepdive` | researcher, security-analyst | coder | call-graph → deps → trace |
-| `refactor` | coder, reviewer | researcher | complexity → smells → patterns |
-
-## Performance-Based Selection
-
-The system learns from execution history to improve agent selection:
-
-```typescript
-// Agent selection considers:
-// 1. Quality score (0-1)
-// 2. Success rate
-// 3. Average latency
-// 4. Execution count
-
-const { agent, confidence, reasoning } = selectBestAgent('optimize');
-// agent: "performance-analyzer"
-// confidence: 0.87
-// reasoning: "Selected based on 45 executions with 94.2% success"
-```
-
-## Memory Key Patterns
-
-Workers store results using consistent patterns:
-
-```
-{trigger}/{topic}/{phase}
-
-Examples:
-- ultralearn/auth-module/analysis
-- optimize/database/performance
-- audit/payment/vulnerabilities
-- benchmark/api/metrics
-```
-
-## Benchmark Thresholds
-
-Agents are monitored against performance thresholds:
-
-```json
-{
-  "researcher": {
-    "p95_latency": "<500ms",
-    "memory_mb": "<256MB"
-  },
-  "coder": {
-    "p95_latency": "<300ms",
-    "quality_score": ">0.85"
-  },
-  "security-analyst": {
-    "scan_coverage": ">95%",
-    "p95_latency": "<1000ms"
-  }
-}
-```
-
-## Feedback Loop
-
-Workers provide feedback for continuous improvement:
-
-```typescript
-import { workerAgentIntegration } from 'agentic-flow/workers/worker-agent-integration';
-
-// Record execution feedback
-workerAgentIntegration.recordFeedback(
-  'optimize',           // trigger
-  'coder',              // agent
-  true,                 // success
-  245,                  // latency ms
-  0.92                  // quality score
-);
-
-// Check compliance
-const { compliant, violations } = workerAgentIntegration.checkBenchmarkCompliance('coder');
-```
-
-## Integration Statistics
-
-```bash
-$ npx agentic-flow workers stats --integration
-
-Worker-Agent Integration Stats
-══════════════════════════════
-Total Agents:       6
-Tracked Agents:     4
-Total Feedback:     156
-Avg Quality Score:  0.89
-
-Model Cache Stats
-─────────────────
-Hits:     1,234
-Misses:   45
-Hit Rate: 96.5%
-```
-
-## Configuration
-
-Enable integration features in `.claude/settings.json`:
-
-```json
-{
-  "workers": {
-    "enabled": true,
-    "parallel": true,
-    "memoryDepositEnabled": true,
-    "agentMappings": {
-      "ultralearn": ["researcher", "coder"],
-      "optimize": ["performance-analyzer", "coder"]
-    }
-  }
-}
-```

package/.claude/statusline-command.sh

@@ -1,176 +0,0 @@
-
-#!/bin/bash
-
-# Read JSON input from stdin
-INPUT=$(cat)
-MODEL=$(echo "$INPUT" | jq -r '.model.display_name // "Claude"')
-CWD=$(echo "$INPUT" | jq -r '.workspace.current_dir // .cwd')
-DIR=$(basename "$CWD")
-
-# Replace claude-code-flow with branded name
-if [ "$DIR" = "claude-code-flow" ]; then
-  DIR="🌊 Claude Flow"
-fi
-
-# Get git branch
-BRANCH=$(cd "$CWD" 2>/dev/null && git branch --show-current 2>/dev/null)
-
-# Start building statusline
-printf "\033[1m$MODEL\033[0m in \033[36m$DIR\033[0m"
-[ -n "$BRANCH" ] && printf " on \033[33m⎇ $BRANCH\033[0m"
-
-# Claude-Flow integration
-FLOW_DIR="$CWD/.claude-flow"
-
-if [ -d "$FLOW_DIR" ]; then
-  printf " │"
-
-  # 1. Swarm Configuration & Topology
-  if [ -f "$FLOW_DIR/swarm-config.json" ]; then
-    STRATEGY=$(jq -r '.defaultStrategy // empty' "$FLOW_DIR/swarm-config.json" 2>/dev/null)
-    if [ -n "$STRATEGY" ]; then
-      # Map strategy to topology icon
-      case "$STRATEGY" in
-        "balanced") TOPO_ICON="⚡mesh" ;;
-        "conservative") TOPO_ICON="⚡hier" ;;
-        "aggressive") TOPO_ICON="⚡ring" ;;
-        *) TOPO_ICON="⚡$STRATEGY" ;;
-      esac
-      printf " \033[35m$TOPO_ICON\033[0m"
-
-      # Count agent profiles as "configured agents"
-      AGENT_COUNT=$(jq -r '.agentProfiles | length' "$FLOW_DIR/swarm-config.json" 2>/dev/null)
-      if [ -n "$AGENT_COUNT" ] && [ "$AGENT_COUNT" != "null" ] && [ "$AGENT_COUNT" -gt 0 ]; then
-        printf "  \033[35m🤖 $AGENT_COUNT\033[0m"
-      fi
-    fi
-  fi
-
-  # 2. Real-time System Metrics
-  if [ -f "$FLOW_DIR/metrics/system-metrics.json" ]; then
-    # Get latest metrics (last entry in array)
-    LATEST=$(jq -r '.[-1]' "$FLOW_DIR/metrics/system-metrics.json" 2>/dev/null)
-
-    if [ -n "$LATEST" ] && [ "$LATEST" != "null" ]; then
-      # Memory usage
-      MEM_PERCENT=$(echo "$LATEST" | jq -r '.memoryUsagePercent // 0' | awk '{printf "%.0f", $1}')
-      if [ -n "$MEM_PERCENT" ] && [ "$MEM_PERCENT" != "null" ]; then
-        # Color-coded memory (green <60%, yellow 60-80%, red >80%)
-        if [ "$MEM_PERCENT" -lt 60 ]; then
-          MEM_COLOR="\033[32m"  # Green
-        elif [ "$MEM_PERCENT" -lt 80 ]; then
-          MEM_COLOR="\033[33m"  # Yellow
-        else
-          MEM_COLOR="\033[31m"  # Red
-        fi
-        printf "  ${MEM_COLOR}💾 ${MEM_PERCENT}%\033[0m"
-      fi
-
-      # CPU load
-      CPU_LOAD=$(echo "$LATEST" | jq -r '.cpuLoad // 0' | awk '{printf "%.0f", $1 * 100}')
-      if [ -n "$CPU_LOAD" ] && [ "$CPU_LOAD" != "null" ]; then
-        # Color-coded CPU (green <50%, yellow 50-75%, red >75%)
-        if [ "$CPU_LOAD" -lt 50 ]; then
-          CPU_COLOR="\033[32m"  # Green
-        elif [ "$CPU_LOAD" -lt 75 ]; then
-          CPU_COLOR="\033[33m"  # Yellow
-        else
-          CPU_COLOR="\033[31m"  # Red
-        fi
-        printf "  ${CPU_COLOR}⚙ ${CPU_LOAD}%\033[0m"
-      fi
-    fi
-  fi
-
-  # 3. Session State
-  if [ -f "$FLOW_DIR/session-state.json" ]; then
-    SESSION_ID=$(jq -r '.sessionId // empty' "$FLOW_DIR/session-state.json" 2>/dev/null)
-    ACTIVE=$(jq -r '.active // false' "$FLOW_DIR/session-state.json" 2>/dev/null)
-
-    if [ "$ACTIVE" = "true" ] && [ -n "$SESSION_ID" ]; then
-      # Show abbreviated session ID
-      SHORT_ID=$(echo "$SESSION_ID" | cut -d'-' -f1)
-      printf "  \033[34m🔄 $SHORT_ID\033[0m"
-    fi
-  fi
-
-  # 4. Performance Metrics from task-metrics.json
-  if [ -f "$FLOW_DIR/metrics/task-metrics.json" ]; then
-    # Parse task metrics for success rate, avg time, and streak
-    METRICS=$(jq -r '
-      # Calculate metrics
-      (map(select(.success == true)) | length) as $successful |
-      (length) as $total |
-      (if $total > 0 then ($successful / $total * 100) else 0 end) as $success_rate |
-      (map(.duration // 0) | add / length) as $avg_duration |
-      # Calculate streak (consecutive successes from end)
-      (reverse |
-        reduce .[] as $task (0;
-          if $task.success == true then . + 1 else 0 end
-        )
-      ) as $streak |
-      {
-        success_rate: $success_rate,
-        avg_duration: $avg_duration,
-        streak: $streak,
-        total: $total
-      } | @json
-    ' "$FLOW_DIR/metrics/task-metrics.json" 2>/dev/null)
-
-    if [ -n "$METRICS" ] && [ "$METRICS" != "null" ]; then
-      # Success Rate
-      SUCCESS_RATE=$(echo "$METRICS" | jq -r '.success_rate // 0' | awk '{printf "%.0f", $1}')
-      TOTAL_TASKS=$(echo "$METRICS" | jq -r '.total // 0')
-
-      if [ -n "$SUCCESS_RATE" ] && [ "$TOTAL_TASKS" -gt 0 ]; then
-        # Color-code: Green (>80%), Yellow (60-80%), Red (<60%)
-        if [ "$SUCCESS_RATE" -gt 80 ]; then
-          SUCCESS_COLOR="\033[32m"  # Green
-        elif [ "$SUCCESS_RATE" -ge 60 ]; then
-          SUCCESS_COLOR="\033[33m"  # Yellow
-        else
-          SUCCESS_COLOR="\033[31m"  # Red
-        fi
-        printf "  ${SUCCESS_COLOR}🎯 ${SUCCESS_RATE}%\033[0m"
-      fi
-
-      # Average Time
-      AVG_TIME=$(echo "$METRICS" | jq -r '.avg_duration // 0')
-      if [ -n "$AVG_TIME" ] && [ "$TOTAL_TASKS" -gt 0 ]; then
-        # Format smartly: seconds, minutes, or hours
-        if [ $(echo "$AVG_TIME < 60" | bc -l 2>/dev/null || echo 0) -eq 1 ]; then
-          TIME_STR=$(echo "$AVG_TIME" | awk '{printf "%.1fs", $1}')
-        elif [ $(echo "$AVG_TIME < 3600" | bc -l 2>/dev/null || echo 0) -eq 1 ]; then
-          TIME_STR=$(echo "$AVG_TIME" | awk '{printf "%.1fm", $1/60}')
-        else
-          TIME_STR=$(echo "$AVG_TIME" | awk '{printf "%.1fh", $1/3600}')
-        fi
-        printf "  \033[36m⏱️  $TIME_STR\033[0m"
-      fi
-
-      # Streak (only show if > 0)
-      STREAK=$(echo "$METRICS" | jq -r '.streak // 0')
-      if [ -n "$STREAK" ] && [ "$STREAK" -gt 0 ]; then
-        printf "  \033[91m🔥 $STREAK\033[0m"
-      fi
-    fi
-  fi
-
-  # 5. Active Tasks (check for task files)
-  if [ -d "$FLOW_DIR/tasks" ]; then
-    TASK_COUNT=$(find "$FLOW_DIR/tasks" -name "*.json" -type f 2>/dev/null | wc -l)
-    if [ "$TASK_COUNT" -gt 0 ]; then
-      printf "  \033[36m📋 $TASK_COUNT\033[0m"
-    fi
-  fi
-
-  # 6. Check for hooks activity
-  if [ -f "$FLOW_DIR/hooks-state.json" ]; then
-    HOOKS_ACTIVE=$(jq -r '.enabled // false' "$FLOW_DIR/hooks-state.json" 2>/dev/null)
-    if [ "$HOOKS_ACTIVE" = "true" ]; then
-      printf " \033[35m🔗\033[0m"
-    fi
-  fi
-fi
-
-echo

package/.claude/statusline.mjs

@@ -1,109 +0,0 @@
-/**
- * Agentic Flow Statusline for Claude Code
- * Shows model, tokens, cost, swarm status, and memory usage
- */
-
-import { execSync } from 'child_process';
-
-// Cache for expensive operations
-let lastSwarmCheck = 0;
-let cachedSwarmStatus = null;
-const CACHE_TTL = 5000; // 5 seconds
-
-/**
- * Get swarm status (cached)
- */
-function getSwarmStatus() {
-  const now = Date.now();
-  if (cachedSwarmStatus && (now - lastSwarmCheck) < CACHE_TTL) {
-    return cachedSwarmStatus;
-  }
-
-  try {
-    const result = execSync('npx agentic-flow@alpha mcp status 2>/dev/null || echo "idle"', {
-      encoding: 'utf-8',
-      timeout: 2000
-    }).trim();
-
-    cachedSwarmStatus = result.includes('running') ? '🐝' : '⚡';
-    lastSwarmCheck = now;
-    return cachedSwarmStatus;
-  } catch {
-    cachedSwarmStatus = '⚡';
-    lastSwarmCheck = now;
-    return cachedSwarmStatus;
-  }
-}
-
-/**
- * Format token count
- */
-function formatTokens(tokens) {
-  if (tokens >= 1000000) {
-    return `${(tokens / 1000000).toFixed(1)}M`;
-  }
-  if (tokens >= 1000) {
-    return `${(tokens / 1000).toFixed(1)}K`;
-  }
-  return String(tokens);
-}
-
-/**
- * Format cost
- */
-function formatCost(cost) {
-  if (cost >= 1) {
-    return `$${cost.toFixed(2)}`;
-  }
-  return `$${cost.toFixed(4)}`;
-}
-
-/**
- * Main statusline export
- */
-export default function statusline(context) {
-  const parts = [];
-
-  // Agentic Flow indicator
-  parts.push('🤖');
-
-  // Model name (shortened)
-  if (context.model) {
-    const model = context.model
-      .replace('claude-', '')
-      .replace('-20250514', '')
-      .replace('sonnet-4', 'S4')
-      .replace('opus-4', 'O4')
-      .replace('haiku-3.5', 'H3.5');
-    parts.push(model);
-  }
-
-  // Token usage
-  if (context.inputTokens !== undefined || context.outputTokens !== undefined) {
-    const input = formatTokens(context.inputTokens || 0);
-    const output = formatTokens(context.outputTokens || 0);
-    parts.push(`↑${input} ↓${output}`);
-  }
-
-  // Cost
-  if (context.totalCost !== undefined && context.totalCost > 0) {
-    parts.push(formatCost(context.totalCost));
-  }
-
-  // Swarm/MCP status indicator
-  parts.push(getSwarmStatus());
-
-  // Session time
-  if (context.sessionStartTime) {
-    const elapsed = Math.floor((Date.now() - context.sessionStartTime) / 1000);
-    const mins = Math.floor(elapsed / 60);
-    const secs = elapsed % 60;
-    if (mins > 0) {
-      parts.push(`${mins}m${secs}s`);
-    } else {
-      parts.push(`${secs}s`);
-    }
-  }
-
-  return parts.join(' │ ');
-}