claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/fleet-manager/invoke-fleet-balance.sh

@@ -1,239 +0,0 @@
-#!/bin/bash
-#
-# Fleet Manager - Load Balancing CLI Wrapper
-#
-# Usage:
-#   ./invoke-fleet-balance.sh --agents <id1,id2,id3> [--strategy <round-robin|least-loaded|offload>] [--all]
-#
-# Examples:
-#   # Balance resources across multiple agents
-#   ./invoke-fleet-balance.sh --agents backend-dev-1,backend-dev-2,backend-dev-3
-#
-#   # Balance with specific strategy
-#   ./invoke-fleet-balance.sh --agents cfn-validator-1,cfn-validator-2 --strategy round-robin
-#
-#   # Balance entire fleet
-#   ./invoke-fleet-balance.sh --all
-
-set -euo pipefail
-
-# Parse arguments
-AGENTS=""
-STRATEGY="round-robin"
-ALL=false
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --agents)
-            AGENTS="$2"
-            shift 2
-            ;;
-        --strategy)
-            STRATEGY="$2"
-            shift 2
-            ;;
-        --all)
-            ALL=true
-            shift
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate strategy
-if [[ ! "$STRATEGY" =~ ^(round-robin|least-loaded|offload)$ ]]; then
-    echo "Error: Invalid strategy '$STRATEGY'"
-    echo "Valid strategies: round-robin, least-loaded, offload"
-    exit 1
-fi
-
-# Get agent list
-if [ "$ALL" = true ]; then
-    # Get all registered agents
-    POOL_KEY="fleet:pool:allocated"
-    AGENT_LIST=$(redis-cli HKEYS "$POOL_KEY" | grep ':cpu$' | sed 's/:cpu$//' | sort -u | tr '\n' ',')
-    AGENT_LIST=${AGENT_LIST%,}  # Remove trailing comma
-
-    if [ -z "$AGENT_LIST" ]; then
-        echo "No agents registered"
-        exit 0
-    fi
-elif [ -n "$AGENTS" ]; then
-    AGENT_LIST="$AGENTS"
-else
-    echo "Error: Must specify --agents or --all"
-    echo ""
-    echo "Usage: $0 --agents <id1,id2,id3> [--strategy <round-robin|least-loaded|offload>] [--all]"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --agents backend-dev-1,backend-dev-2,backend-dev-3"
-    echo "  $0 --agents cfn-validator-1,cfn-validator-2 --strategy round-robin"
-    echo "  $0 --all"
-    exit 1
-fi
-
-# Split agent IDs
-IFS=',' read -ra AGENT_ARRAY <<< "$AGENT_LIST"
-
-echo "[Fleet Manager] Starting load balancing..."
-echo "  Strategy: $STRATEGY"
-echo "  Agents: ${AGENT_ARRAY[@]}"
-echo ""
-
-# Generate balance ID
-BALANCE_ID="balance-$(date +%s)-$$"
-
-# Collect current load for each agent
-declare -A BEFORE_LOAD
-declare -A AFTER_LOAD
-
-TOTAL_LOAD=0
-AGENT_COUNT=${#AGENT_ARRAY[@]}
-
-for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-    METRICS_KEY="fleet:agent:${AGENT_ID}:metrics"
-    METRICS=$(redis-cli GET "$METRICS_KEY")
-
-    if [ -n "$METRICS" ] && [ "$METRICS" != "(nil)" ]; then
-        CPU_UTIL=$(echo "$METRICS" | jq -r '.metrics.cpuUtilization')
-        BEFORE_LOAD[$AGENT_ID]=$CPU_UTIL
-        TOTAL_LOAD=$(echo "$TOTAL_LOAD + $CPU_UTIL" | bc)
-    else
-        # Default to 0.5 if no metrics
-        BEFORE_LOAD[$AGENT_ID]="0.50"
-        TOTAL_LOAD=$(echo "$TOTAL_LOAD + 0.50" | bc)
-    fi
-done
-
-# Calculate target load based on strategy
-case "$STRATEGY" in
-    round-robin)
-        # Distribute evenly
-        TARGET_LOAD=$(echo "scale=2; $TOTAL_LOAD / $AGENT_COUNT" | bc)
-
-        for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-            AFTER_LOAD[$AGENT_ID]=$TARGET_LOAD
-        done
-        ;;
-
-    least-loaded)
-        # Move load from highest to lowest
-        # Sort agents by load
-        SORTED_AGENTS=$(for agent in "${!BEFORE_LOAD[@]}"; do
-            echo "${BEFORE_LOAD[$agent]} $agent"
-        done | sort -n)
-
-        # Simple redistribution: reduce highest, increase lowest
-        HIGHEST=$(echo "$SORTED_AGENTS" | tail -1 | awk '{print $2}')
-        LOWEST=$(echo "$SORTED_AGENTS" | head -1 | awk '{print $2}')
-
-        for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-            if [ "$AGENT_ID" = "$HIGHEST" ]; then
-                AFTER_LOAD[$AGENT_ID]=$(echo "${BEFORE_LOAD[$AGENT_ID]} - 0.15" | bc)
-            elif [ "$AGENT_ID" = "$LOWEST" ]; then
-                AFTER_LOAD[$AGENT_ID]=$(echo "${BEFORE_LOAD[$AGENT_ID]} + 0.15" | bc)
-            else
-                AFTER_LOAD[$AGENT_ID]=${BEFORE_LOAD[$AGENT_ID]}
-            fi
-        done
-        ;;
-
-    offload)
-        # Offload from first agent to others
-        FIRST_AGENT="${AGENT_ARRAY[0]}"
-        OFFLOAD_AMOUNT=$(echo "scale=2; ${BEFORE_LOAD[$FIRST_AGENT]} / $AGENT_COUNT" | bc)
-
-        for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-            if [ "$AGENT_ID" = "$FIRST_AGENT" ]; then
-                AFTER_LOAD[$AGENT_ID]=$(echo "${BEFORE_LOAD[$AGENT_ID]} - $OFFLOAD_AMOUNT" | bc)
-            else
-                INCREASE=$(echo "scale=2; $OFFLOAD_AMOUNT / ($AGENT_COUNT - 1)" | bc)
-                AFTER_LOAD[$AGENT_ID]=$(echo "${BEFORE_LOAD[$AGENT_ID]} + $INCREASE" | bc)
-            fi
-        done
-        ;;
-esac
-
-# Store balancing state in Redis
-BALANCE_KEY="fleet:balance:${BALANCE_ID}:state"
-TIMESTAMP=$(date +%s)
-
-BALANCE_STATE=$(jq -n \
-    --arg balance_id "$BALANCE_ID" \
-    --arg strategy "$STRATEGY" \
-    --arg agent_list "$AGENT_LIST" \
-    --arg ts "$TIMESTAMP" \
-    '{
-        balanceId: $balance_id,
-        strategy: $strategy,
-        agents: ($agent_list | split(",")),
-        status: "completed",
-        timestamp: ($ts | tonumber)
-    }')
-
-echo "$BALANCE_STATE" | redis-cli -x SET "$BALANCE_KEY" >/dev/null
-
-# Build result JSON
-AGENT_RESULTS="["
-FIRST=true
-
-for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-    if [ "$FIRST" = false ]; then
-        AGENT_RESULTS+=","
-    fi
-    FIRST=false
-
-    BEFORE=${BEFORE_LOAD[$AGENT_ID]}
-    AFTER=${AFTER_LOAD[$AGENT_ID]}
-
-    # Determine adjustment
-    DIFF=$(echo "$AFTER - $BEFORE" | bc)
-    if (( $(echo "$DIFF > 0.01" | bc -l) )); then
-        ADJUSTMENT="increased"
-    elif (( $(echo "$DIFF < -0.01" | bc -l) )); then
-        ADJUSTMENT="reduced"
-    else
-        ADJUSTMENT="unchanged"
-    fi
-
-    AGENT_RESULT=$(jq -n \
-        --arg agent_id "$AGENT_ID" \
-        --arg before "$BEFORE" \
-        --arg after "$AFTER" \
-        --arg adjustment "$ADJUSTMENT" \
-        '{
-            agentId: $agent_id,
-            beforeLoad: ($before | tonumber),
-            afterLoad: ($after | tonumber),
-            adjustment: $adjustment
-        }')
-
-    AGENT_RESULTS+="$AGENT_RESULT"
-done
-
-AGENT_RESULTS+="]"
-
-# Output summary
-echo "Load Balancing Results:"
-for AGENT_ID in "${AGENT_ARRAY[@]}"; do
-    echo "  [$AGENT_ID] ${BEFORE_LOAD[$AGENT_ID]} -> ${AFTER_LOAD[$AGENT_ID]}"
-done
-echo ""
-
-# Return JSON result
-RESULT=$(jq -n \
-    --arg status "balanced" \
-    --arg strategy "$STRATEGY" \
-    --argjson agents "$AGENT_RESULTS" \
-    --arg ts "$TIMESTAMP" \
-    '{
-        status: $status,
-        strategy: $strategy,
-        agents: $agents,
-        timestamp: ($ts | tonumber)
-    }')
-
-echo "$RESULT"

package/.claude/skills/fleet-manager/invoke-fleet-metrics.sh

@@ -1,193 +0,0 @@
-#!/bin/bash
-#
-# Fleet Manager - Performance Metrics CLI Wrapper
-#
-# Usage:
-#   ./invoke-fleet-metrics.sh --agent-id <id> [--detailed] [--all]
-#
-# Examples:
-#   # Get metrics for specific agent
-#   ./invoke-fleet-metrics.sh --agent-id backend-dev-1
-#
-#   # Get detailed metrics
-#   ./invoke-fleet-metrics.sh --agent-id backend-dev-1 --detailed
-#
-#   # Get fleet-wide metrics
-#   ./invoke-fleet-metrics.sh --all
-
-set -euo pipefail
-
-# Parse arguments
-AGENT_ID=""
-DETAILED=false
-ALL=false
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --detailed)
-            DETAILED=true
-            shift
-            ;;
-        --all)
-            ALL=true
-            shift
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Function to generate mock metrics for an agent
-generate_metrics() {
-    local agent_id="$1"
-    local allocation_key="fleet:agent:${agent_id}:allocation"
-    local registration_key="fleet:agent:${agent_id}:registration"
-
-    # Get allocated resources
-    local allocation=$(redis-cli GET "$allocation_key")
-    local registration=$(redis-cli GET "$registration_key")
-
-    if [ -z "$allocation" ] || [ "$allocation" = "(nil)" ]; then
-        # Use registration resources if no allocation
-        if [ -z "$registration" ] || [ "$registration" = "(nil)" ]; then
-            echo "Error: Agent $agent_id not found"
-            return 1
-        fi
-        allocation="$registration"
-    fi
-
-    local cpu_allocated=$(echo "$allocation" | jq -r '.cpu')
-    local memory_allocated=$(echo "$allocation" | jq -r '.memory')
-
-    # Generate realistic metrics (mock data)
-    local cpu_usage=$(echo "$cpu_allocated * 0.8" | bc)
-    local cpu_utilization="0.80"
-    local memory_usage=$(echo "$memory_allocated * 0.88" | bc | cut -d'.' -f1)
-    local memory_utilization="0.88"
-    local task_completion_rate="0.95"
-    local avg_response_time="120"
-
-    # Determine health status based on utilization
-    local health="healthy"
-    if (( $(echo "$cpu_utilization > 0.90" | bc -l) )) || (( $(echo "$memory_utilization > 0.90" | bc -l) )); then
-        health="degraded"
-    fi
-
-    local timestamp=$(date +%s)
-
-    # Build metrics JSON
-    if [ "$DETAILED" = true ]; then
-        METRICS=$(jq -n \
-            --arg agent_id "$agent_id" \
-            --arg cpu_usage "$cpu_usage" \
-            --arg cpu_util "$cpu_utilization" \
-            --arg memory_usage "$memory_usage" \
-            --arg memory_util "$memory_utilization" \
-            --arg task_rate "$task_completion_rate" \
-            --arg response_time "$avg_response_time" \
-            --arg health "$health" \
-            --arg ts "$timestamp" \
-            '{
-                agentId: $agent_id,
-                metrics: {
-                    cpuUsage: ($cpu_usage | tonumber),
-                    cpuUtilization: ($cpu_util | tonumber),
-                    memoryUsage: ($memory_usage | tonumber),
-                    memoryUtilization: ($memory_util | tonumber),
-                    taskCompletionRate: ($task_rate | tonumber),
-                    averageResponseTime: ($response_time | tonumber),
-                    detailed: {
-                        threadsActive: 8,
-                        diskIOPS: 450,
-                        networkThroughput: 250
-                    }
-                },
-                health: $health,
-                timestamp: ($ts | tonumber)
-            }')
-    else
-        METRICS=$(jq -n \
-            --arg agent_id "$agent_id" \
-            --arg cpu_usage "$cpu_usage" \
-            --arg cpu_util "$cpu_utilization" \
-            --arg memory_usage "$memory_usage" \
-            --arg memory_util "$memory_utilization" \
-            --arg task_rate "$task_completion_rate" \
-            --arg response_time "$avg_response_time" \
-            --arg health "$health" \
-            --arg ts "$timestamp" \
-            '{
-                agentId: $agent_id,
-                metrics: {
-                    cpuUsage: ($cpu_usage | tonumber),
-                    cpuUtilization: ($cpu_util | tonumber),
-                    memoryUsage: ($memory_usage | tonumber),
-                    memoryUtilization: ($memory_util | tonumber),
-                    taskCompletionRate: ($task_rate | tonumber),
-                    averageResponseTime: ($response_time | tonumber)
-                },
-                health: $health,
-                timestamp: ($ts | tonumber)
-            }')
-    fi
-
-    # Store metrics in Redis
-    local metrics_key="fleet:agent:${agent_id}:metrics"
-    echo "$METRICS" | redis-cli -x SET "$metrics_key" >/dev/null
-
-    echo "$METRICS"
-}
-
-# Main logic
-if [ "$ALL" = true ]; then
-    # Get all registered agents
-    POOL_KEY="fleet:pool:allocated"
-    AGENT_IDS=$(redis-cli HKEYS "$POOL_KEY" | grep ':cpu$' | sed 's/:cpu$//' | sort -u)
-
-    if [ -z "$AGENT_IDS" ]; then
-        echo "No agents registered"
-        exit 0
-    fi
-
-    echo "{"
-    echo "  \"fleetMetrics\": ["
-
-    FIRST=true
-    for aid in $AGENT_IDS; do
-        if [ "$FIRST" = false ]; then
-            echo ","
-        fi
-        FIRST=false
-
-        AGENT_METRICS=$(generate_metrics "$aid" 2>/dev/null || echo "{}")
-        echo "$AGENT_METRICS" | jq -c '.'
-    done
-
-    echo "  ],"
-    echo "  \"summary\": {"
-    echo "    \"totalAgents\": $(echo "$AGENT_IDS" | wc -l),"
-    echo "    \"timestamp\": $(date +%s)"
-    echo "  }"
-    echo "}"
-
-elif [ -n "$AGENT_ID" ]; then
-    # Get metrics for specific agent
-    generate_metrics "$AGENT_ID"
-
-else
-    echo "Error: Must specify --agent-id or --all"
-    echo ""
-    echo "Usage: $0 --agent-id <id> [--detailed] [--all]"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --agent-id backend-dev-1"
-    echo "  $0 --agent-id backend-dev-1 --detailed"
-    echo "  $0 --all"
-    exit 1
-fi

package/.claude/skills/fleet-manager/invoke-fleet-register.sh

@@ -1,124 +0,0 @@
-#!/bin/bash
-#
-# Fleet Manager - Agent Registration CLI Wrapper
-#
-# Usage:
-#   ./invoke-fleet-register.sh --agent-id <id> --tier <shared|dedicated|premium>
-#
-# Examples:
-#   # Register agent with shared tier
-#   ./invoke-fleet-register.sh --agent-id researcher-1 --tier shared
-#
-#   # Register agent with dedicated tier
-#   ./invoke-fleet-register.sh --agent-id backend-dev-1 --tier dedicated
-#
-#   # Register agent with premium tier
-#   ./invoke-fleet-register.sh --agent-id cfn-validator-1 --tier premium
-
-set -euo pipefail
-
-# Parse arguments
-AGENT_ID=""
-TIER="shared"  # Default tier
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --tier)
-            TIER="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required arguments
-if [ -z "$AGENT_ID" ]; then
-    echo "Error: --agent-id is required"
-    echo ""
-    echo "Usage: $0 --agent-id <id> --tier <shared|dedicated|premium>"
-    echo ""
-    echo "Examples:"
-    echo "  $0 --agent-id researcher-1 --tier shared"
-    echo "  $0 --agent-id backend-dev-1 --tier dedicated"
-    echo "  $0 --agent-id cfn-validator-1 --tier premium"
-    exit 1
-fi
-
-# Validate tier
-if [[ ! "$TIER" =~ ^(shared|dedicated|premium)$ ]]; then
-    echo "Error: Invalid tier '$TIER'"
-    echo "Valid tiers: shared, dedicated, premium"
-    exit 1
-fi
-
-# Define tier resources
-case "$TIER" in
-    shared)
-        CPU=0.5
-        MEMORY=512
-        ;;
-    dedicated)
-        CPU=2.0
-        MEMORY=2048
-        ;;
-    premium)
-        CPU=4.0
-        MEMORY=4096
-        ;;
-esac
-
-# Create registration record in Redis
-REGISTRATION_KEY="fleet:agent:${AGENT_ID}:registration"
-TIMESTAMP=$(date +%s)
-
-REGISTRATION_DATA=$(jq -n \
-    --arg tier "$TIER" \
-    --arg cpu "$CPU" \
-    --arg memory "$MEMORY" \
-    --arg ts "$TIMESTAMP" \
-    '{
-        tier: $tier,
-        cpu: ($cpu | tonumber),
-        memory: ($memory | tonumber),
-        timestamp: ($ts | tonumber)
-    }')
-
-echo "$REGISTRATION_DATA" | redis-cli -x SET "$REGISTRATION_KEY" >/dev/null
-
-# Update resource pool allocation
-POOL_KEY="fleet:pool:allocated"
-redis-cli HSET "$POOL_KEY" "${AGENT_ID}:cpu" "$CPU" >/dev/null
-redis-cli HSET "$POOL_KEY" "${AGENT_ID}:memory" "$MEMORY" >/dev/null
-
-# Output success message
-echo "[$AGENT_ID] Registered with $TIER tier"
-echo "  CPU: $CPU cores"
-echo "  Memory: $MEMORY MB"
-
-# Return JSON result
-RESULT=$(jq -n \
-    --arg status "registered" \
-    --arg agent_id "$AGENT_ID" \
-    --arg tier "$TIER" \
-    --arg cpu "$CPU" \
-    --arg memory "$MEMORY" \
-    --arg ts "$TIMESTAMP" \
-    '{
-        status: $status,
-        agentId: $agent_id,
-        tier: $tier,
-        resources: {
-            cpu: ($cpu | tonumber),
-            memory: ($memory | tonumber)
-        },
-        timestamp: ($ts | tonumber)
-    }')
-
-echo "$RESULT"