claude-flow-novice 2.14.13 → 2.14.15

package/claude-assets/skills/cfn-multi-coordinator-planning/plan-coordinator-resources.sh

@@ -0,0 +1,258 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../cfn-redis-coordination/redis-utils.sh"
+
+# Configuration
+DEFAULT_MEMORY_PER_COORDINATOR=2048  # MB
+DEFAULT_CPU_PER_COORDINATOR=2
+DEFAULT_REDIS_DB_START=1
+DEFAULT_REDIS_DB_END=15
+CLEANUP_OVERHEAD=0.15  # 15%
+MONITORING_OVERHEAD=0.05  # 5%
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log() {
+    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"
+}
+
+warn() {
+    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
+    exit 1
+}
+
+info() {
+    echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] INFO: $1${NC}"
+}
+
+get_system_resources() {
+    local memory_kb cpu_cores
+    memory_kb=$(grep MemTotal /proc/meminfo | awk '{print $2}')
+    cpu_cores=$(nproc)
+
+    local memory_mb=$((memory_kb / 1024))
+
+    echo "{\"memory_mb\": $memory_mb, \"cpu_cores\": $cpu_cores}"
+}
+
+calculate_max_coordinators() {
+    local system_resources="$1"
+    local memory_mb cpu_cores
+
+    memory_mb=$(echo "$system_resources" | jq -r '.memory_mb')
+    cpu_cores=$(echo "$system_resources" | jq -r '.cpu_cores')
+
+    # Calculate with overhead
+    local effective_memory=$((memory_mb - (memory_mb * CLEANUP_OVERHEAD + memory_mb * MONITORING_OVERHEAD)))
+    local effective_cpu=$((cpu_cores - (cpu_cores * CLEANUP_OVERHEAD + cpu_cores * MONITORING_OVERHEAD)))
+
+    local max_by_memory=$((effective_memory / DEFAULT_MEMORY_PER_COORDINATOR))
+    local max_by_cpu=$((effective_cpu / DEFAULT_CPU_PER_COORDINATOR))
+
+    # Return the smaller of the two limits
+    if [[ $max_by_memory -lt $max_by_cpu ]]; then
+        echo $max_by_memory
+    else
+        echo $max_by_cpu
+    fi
+}
+
+reserve_redis_namespace() {
+    local zone_name="$1"
+    local task_id="$2"
+    local redis_db="$3"
+
+    local namespace_pattern="swarm:zone-${zone_name}:${task_id}"
+
+    # Test Redis connectivity
+    if ! redis-cli ping >/dev/null 2>&1; then
+        error "Redis connection failed"
+    fi
+
+    # Reserve namespace with SETNX and TTL
+    local reservation_key="${namespace_pattern}:reservation"
+    local reservation_result
+    reservation_result=$(redis-cli setnx "$reservation_key" "$(date '+%s')" 2>/dev/null || echo "0")
+
+    if [[ "$reservation_result" != "1" ]]; then
+        error "Namespace already reserved: $namespace_pattern"
+    fi
+
+    # Set TTL for reservation (1 hour)
+    redis-cli expire "$reservation_key" 3600 >/dev/null
+
+    log "✓ Redis namespace reserved: $namespace_pattern (DB: $redis_db)"
+    echo "$namespace_pattern"
+}
+
+allocate_redis_databases() {
+    local zone_count="$1"
+    local start_db="$2"
+    local end_db="$3"
+
+    local available_dbs=$((end_db - start_db + 1))
+
+    if [[ $zone_count -gt $available_dbs ]]; then
+        error "Too many zones: $zone_count (available DBs: $available_dbs)"
+    fi
+
+    local db_allocation=()
+    for ((i=0; i<zone_count; i++)); do
+        db_allocation+=($((start_db + i)))
+    done
+
+    printf '%s\n' "${db_allocation[@]}"
+}
+
+generate_task_id() {
+    local zone_name="$1"
+    local timestamp
+    timestamp=$(date '+%s')
+
+    echo "zone-${zone_name}-${timestamp}"
+}
+
+plan_zone_resources() {
+    local zone_name="$1"
+    local redis_db="$2"
+    local task_data="$3"
+
+    local task_id
+    task_id=$(generate_task_id "$zone_name")
+
+    # Reserve Redis namespace
+    local namespace_pattern
+    namespace_pattern=$(reserve_redis_namespace "$zone_name" "$task_id" "$redis_db")
+
+    # Generate resource plan
+    local resource_plan="{
+        \"zone_name\": \"$zone_name\",
+        \"task_id\": \"$task_id\",
+        \"namespace_pattern\": \"$namespace_pattern\",
+        \"redis_db\": $redis_db,
+        \"memory_mb\": $DEFAULT_MEMORY_PER_COORDINATOR,
+        \"cpu_cores\": $DEFAULT_CPU_PER_COORDINATOR,
+        \"working_directory\": \"/tmp/zone-${zone_name}-${task_id}\",
+        \"monitoring_port\": $((8080 + redis_db)),
+        \"timestamp\": $(date '+%s')
+    }"
+
+    log "✓ Resource plan generated for zone: $zone_name"
+    echo "$resource_plan"
+}
+
+validate_resource_availability() {
+    local zone_count="$1"
+    local system_resources="$2"
+
+    local max_coordinators
+    max_coordinators=$(calculate_max_coordinators "$system_resources")
+
+    if [[ $zone_count -gt $max_coordinators ]]; then
+        error "Insufficient resources for $zone_count coordinators (maximum: $max_coordinators)"
+    fi
+
+    log "✓ Resource availability validated: $zone_count zones (capacity: $max_coordinators)"
+}
+
+main() {
+    local config_file="$1"
+
+    if [[ -z "$config_file" ]]; then
+        error "Usage: $0 <zone-config-file>"
+    fi
+
+    if [[ ! -f "$config_file" ]]; then
+        error "Configuration file not found: $config_file"
+    fi
+
+    log "Starting coordinator resource planning for: $config_file"
+
+    # Read configuration
+    local zone_config
+    if ! zone_config=$(jq . "$config_file" 2>/dev/null); then
+        error "Invalid JSON in configuration file: $config_file"
+    fi
+
+    local zone_count
+    zone_count=$(echo "$zone_config" | jq '.zones | length')
+
+    if [[ $zone_count -eq 0 ]]; then
+        error "No zones found in configuration"
+    fi
+
+    info "Planning resources for $zone_count zones"
+
+    # Get system resources
+    local system_resources
+    system_resources=$(get_system_resources)
+
+    # Validate resource availability
+    validate_resource_availability "$zone_count" "$system_resources"
+
+    # Allocate Redis databases
+    local redis_dbs
+    mapfile -t redis_dbs < <(allocate_redis_databases "$zone_count" "$DEFAULT_REDIS_DB_START" "$DEFAULT_REDIS_DB_END")
+
+    # Generate resource plan for each zone
+    local resource_plans="[]"
+    local i=0
+
+    while IFS= read -r zone_name; do
+        local zone_data
+        zone_data=$(echo "$zone_config" | jq -r ".zones[$i]")
+
+        local resource_plan
+        resource_plan=$(plan_zone_resources "$zone_name" "${redis_dbs[$i]}" "$zone_data")
+
+        resource_plans=$(echo "$resource_plans" | jq ". + [$resource_plan]")
+
+        ((i++))
+    done < <(echo "$zone_config" | jq -r '.zones[].name')
+
+    # Generate complete resource allocation plan
+    local allocation_plan="{
+        \"timestamp\": $(date '+%s'),
+        \"zone_count\": $zone_count,
+        \"system_resources\": $system_resources,
+        \"max_coordinators\": $(calculate_max_coordinators "$system_resources"),
+        \"resource_plans\": $resource_plans,
+        \"redis_allocation\": {
+            \"databases_used\": $(printf '%s,' "${redis_dbs[@]}" | sed 's/,$//'),
+            \"total_allocated\": $zone_count
+        }
+    }"
+
+    # Save allocation plan
+    local output_file="/tmp/coordinator-resource-plan-$(date '+%s').json"
+    echo "$allocation_plan" > "$output_file"
+
+    log "✅ Coordinator resource planning completed"
+    log "Resource allocation plan saved to: $output_file"
+
+    # Display summary
+    echo
+    info "=== Resource Allocation Summary ==="
+    echo "Zones to execute: $zone_count"
+    echo "System memory: $(echo "$system_resources" | jq -r '.memory_mb') MB"
+    echo "System CPUs: $(echo "$system_resources" | jq -r '.cpu_cores')"
+    echo "Memory per coordinator: ${DEFAULT_MEMORY_PER_COORDINATOR} MB"
+    echo "CPUs per coordinator: ${DEFAULT_CPU_PER_COORDINATOR}"
+    echo "Redis databases allocated: ${redis_dbs[*]}"
+    echo
+}
+
+# Execute main function with all arguments
+main "$@"

package/claude-assets/skills/cfn-multi-coordinator-planning/plan-multi-coordinator-work.sh

@@ -0,0 +1,267 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log() {
+    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"
+}
+
+warn() {
+    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
+}
+
+error() {
+    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
+    exit 1
+}
+
+info() {
+    echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] INFO: $1${NC}"
+}
+
+display_usage() {
+    echo "Multi-Coordinator Planning Tool"
+    echo
+    echo "Usage: $0 <zone-config-file> [options]"
+    echo
+    echo "Options:"
+    echo "  --max-zones-per-phase N    Maximum zones per rollout phase (default: 2)"
+    echo "  --skip-validation          Skip task validation (not recommended)"
+    echo "  --dry-run                  Generate plan without execution"
+    echo "  --output-dir DIR           Output directory for plans (default: /tmp)"
+    echo "  --help                     Display this help message"
+    echo
+    echo "Example:"
+    echo "  $0 zone-config.json --max-zones-per-phase 3"
+    echo
+}
+
+validate_prerequisites() {
+    # Check for required tools
+    local required_tools=("jq" "redis-cli" "bc")
+
+    for tool in "${required_tools[@]}"; do
+        if ! command -v "$tool" >/dev/null 2>&1; then
+            error "Required tool not found: $tool"
+        fi
+    done
+
+    # Check Redis connectivity
+    if ! redis-cli ping >/dev/null 2>&1; then
+        error "Redis connection failed - required for namespace planning"
+    fi
+
+    log "✓ Prerequisites validation passed"
+}
+
+execute_planning_phase() {
+    local phase_name="$1"
+    local config_file="$2"
+    local output_dir="$3"
+    shift 3
+    local additional_args=("$@")
+
+    log "Executing planning phase: $phase_name"
+
+    case "$phase_name" in
+        "validation")
+            if [[ "${additional_args[*]}" != *"--skip-validation"* ]]; then
+                "$SCRIPT_DIR/validate-task-planning.sh" "$config_file"
+            fi
+            ;;
+        "resources")
+            "$SCRIPT_DIR/plan-coordinator-resources.sh" "$config_file"
+            ;;
+        "dependencies")
+            "$SCRIPT_DIR/map-dependencies-conflicts.sh" "$config_file"
+            ;;
+        "rollout")
+            "$SCRIPT_DIR/plan-risk-rollout.sh" "$config_file" "${additional_args[@]}"
+            ;;
+        *)
+            error "Unknown planning phase: $phase_name"
+            ;;
+    esac
+}
+
+generate_execution_summary() {
+    local validation_file="$1"
+    local resource_file="$2"
+    local dependency_file="$3"
+    local rollout_file="$4"
+    local summary_file="$5"
+
+    local summary="{
+        \"timestamp\": $(date '+%s'),
+        \"planning_status\": \"completed\",
+        \"phases_executed\": [
+            \"task_validation\",
+            \"resource_allocation\",
+            \"dependency_analysis\",
+            \"rollout_planning\"
+        ],
+        \"output_files\": {
+            \"validation\": \"$validation_file\",
+            \"resources\": \"$resource_file\",
+            \"dependencies\": \"$dependency_file\",
+            \"rollout\": \"$rollout_file\"
+        },
+        \"ready_for_execution\": true,
+        \"next_steps\": [
+            \"Review generated plans\",
+            \"Execute rollout in phases\",
+            \"Monitor coordinator health\",
+            \"Apply rollback triggers if needed\"
+        ]
+    }"
+
+    echo "$summary" > "$summary_file"
+}
+
+display_final_summary() {
+    local summary_file="$1"
+    local summary_data
+    summary_data=$(jq . "$summary_file")
+
+    echo
+    info "=== Multi-Coordinator Planning Summary ==="
+    echo "Planning completed at: $(date -d @$(echo "$summary_data" | jq -r '.timestamp') '+%Y-%m-%d %H:%M:%S')"
+    echo "Status: $(echo "$summary_data" | jq -r '.planning_status')"
+    echo "Ready for execution: $(echo "$summary_data" | jq -r '.ready_for_execution')"
+    echo
+
+    echo "Generated Plans:"
+    echo "$summary_data" | jq -r '.output_files | to_entries[] | "  - \(.key): \(.value)"'
+    echo
+
+    echo "Next Steps:"
+    echo "$summary_data" | jq -r '.next_steps[] | "  - \(.)"'
+    echo
+
+    echo "Execution Command:"
+    local rollout_file
+    rollout_file=$(echo "$summary_data" | jq -r '.output_files.rollout')
+    echo "  ./execute-coordinator-rollout.sh $rollout_file"
+    echo
+}
+
+main() {
+    # Parse command line arguments
+    local config_file=""
+    local max_zones_per_phase=2
+    local skip_validation=false
+    local dry_run=false
+    local output_dir="/tmp"
+
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --max-zones-per-phase)
+                max_zones_per_phase="$2"
+                shift 2
+                ;;
+            --skip-validation)
+                skip_validation=true
+                shift
+                ;;
+            --dry-run)
+                dry_run=true
+                shift
+                ;;
+            --output-dir)
+                output_dir="$2"
+                shift 2
+                ;;
+            --help)
+                display_usage
+                exit 0
+                ;;
+            -*)
+                error "Unknown option: $1"
+                ;;
+            *)
+                if [[ -z "$config_file" ]]; then
+                    config_file="$1"
+                else
+                    error "Multiple configuration files specified"
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    # Validate arguments
+    if [[ -z "$config_file" ]]; then
+        error "Configuration file required"
+    fi
+
+    if [[ ! -f "$config_file" ]]; then
+        error "Configuration file not found: $config_file"
+    fi
+
+    # Create output directory
+    mkdir -p "$output_dir"
+
+    log "Starting multi-coordinator planning for: $config_file"
+
+    # Validate prerequisites
+    validate_prerequisites
+
+    # Prepare additional arguments
+    local additional_args=()
+    if [[ "$skip_validation" == true ]]; then
+        additional_args+=("--skip-validation")
+    fi
+
+    # Execute planning phases
+    local timestamp
+    timestamp=$(date '+%s')
+
+    local validation_output="/tmp/validated-task-$(basename "$config_file")"
+    local resource_output="/tmp/coordinator-resource-plan-$timestamp.json"
+    local dependency_output="/tmp/dependency-conflict-analysis-$timestamp.json"
+    local rollout_output="/tmp/rollout-plan-$timestamp.json"
+
+    # Phase 1: Task Validation
+    execute_planning_phase "validation" "$config_file" "$output_dir" "${additional_args[@]}"
+
+    # Phase 2: Resource Allocation
+    execute_planning_phase "resources" "$config_file" "$output_dir"
+
+    # Phase 3: Dependency Analysis
+    execute_planning_phase "dependencies" "$config_file" "$output_dir"
+
+    # Phase 4: Rollout Planning
+    execute_planning_phase "rollout" "$config_file" "$output_dir" "--max-zones-per-phase" "$max_zones_per_phase"
+
+    # Move files to output directory if specified
+    if [[ "$output_dir" != "/tmp" ]]; then
+        mv "$resource_output" "$output_dir/"
+        mv "$dependency_output" "$output_dir/"
+        mv "$rollout_output" "$output_dir/"
+        resource_output="$output_dir/$(basename "$resource_output")"
+        dependency_output="$output_dir/$(basename "$dependency_output")"
+        rollout_output="$output_dir/$(basename "$rollout_output")"
+    fi
+
+    # Generate execution summary
+    local summary_file="$output_dir/multi-coordinator-planning-summary-$timestamp.json"
+    generate_execution_summary "$validation_output" "$resource_output" "$dependency_output" "$rollout_output" "$summary_file"
+
+    log "✅ Multi-coordinator planning completed successfully"
+
+    if [[ "$dry_run" == false ]]; then
+        display_final_summary "$summary_file"
+    fi
+}
+
+# Execute main function with all arguments
+main "$@"