claude-flow-novice 2.18.6 → 2.18.8

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

@@ -1,267 +0,0 @@
-#!/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 "$@"

package/claude-assets/skills/cfn-planning/lib/coordinator/plan-risk-rollout.sh

@@ -1,350 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Configuration
-DEFAULT_PHASE_TIMEOUT=1800  # 30 minutes per phase
-DEFAULT_ROLLBACK_TIMEOUT=600  # 10 minutes for rollback
-SUCCESS_THRESHOLD=0.85
-
-# 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}"
-}
-
-calculate_zone_complexity() {
-    local zone_data="$1"
-    local complexity_score=0
-
-    # Base complexity from agent count
-    local agent_count
-    agent_count=$(echo "$zone_data" | jq -r '.agent_types | length // 0')
-    complexity_score=$((complexity_score + agent_count * 10))
-
-    # Complexity from deliverable count
-    local deliverable_count
-    deliverable_count=$(echo "$zone_data" | jq -r '.deliverables | length // 0')
-    complexity_score=$((complexity_score + deliverable_count * 5))
-
-    # Complexity from task description length (longer = more complex)
-    local task_description
-    task_description=$(echo "$zone_data" | jq -r '.task_description // ""')
-    local description_length=${#task_description}
-    if [[ $description_length -gt 100 ]]; then
-        complexity_score=$((complexity_score + 15))
-    elif [[ $description_length -gt 50 ]]; then
-        complexity_score=$((complexity_score + 10))
-    fi
-
-    # Complexity from acceptance criteria
-    local acceptance_count
-    acceptance_count=$(echo "$zone_data" | jq -r '.acceptance_criteria | length // 0')
-    complexity_score=$((complexity_score + acceptance_count * 8))
-
-    # Risk factors
-    if echo "$zone_data" | jq -e '.risk_factors' >/dev/null 2>&1; then
-        local risk_factors
-        risk_factors=$(echo "$zone_data" | jq -r '.risk_factors | length // 0')
-        complexity_score=$((complexity_score + risk_factors * 20))
-    fi
-
-    echo "$complexity_score"
-}
-
-rank_zones_by_complexity() {
-    local zone_config="$1"
-    local zones_with_complexity="[]"
-
-    local i=0
-    while IFS= read -r zone_name; do
-        local zone_data
-        zone_data=$(echo "$zone_config" | jq -r ".zones[$i]")
-
-        local complexity
-        complexity=$(calculate_zone_complexity "$zone_data")
-
-        local zone_entry="{
-            \"name\": \"$zone_name\",
-            \"complexity_score\": $complexity,
-            \"data\": $zone_data
-        }"
-
-        zones_with_complexity=$(echo "$zones_with_complexity" | jq ". + [$zone_entry]")
-        ((i++))
-    done < <(echo "$zone_config" | jq -r '.zones[].name')
-
-    # Sort by complexity score (ascending)
-    echo "$zones_with_complexity" | jq 'sort_by(.complexity_score)'
-}
-
-create_rollout_phases() {
-    local ranked_zones="$1"
-    local max_zones_per_phase="${2:-2}"
-
-    local rollout_phases="[]"
-    local phase_number=1
-    local i=0
-
-    while true; do
-        local phase_zones="[]"
-        local zones_in_phase=0
-
-        while [[ $zones_in_phase -lt $max_zones_per_phase ]]; do
-            local zone_data
-            zone_data=$(echo "$ranked_zones" | jq ".[$i] // empty")
-
-            if [[ "$zone_data" == "null" || "$zone_data" == "" ]]; then
-                break 2
-            fi
-
-            phase_zones=$(echo "$phase_zones" | jq ". + [$zone_data]")
-            ((i++))
-            ((zones_in_phase++))
-        done
-
-        if [[ $zones_in_phase -eq 0 ]]; then
-            break
-        fi
-
-        local phase_entry="{
-            \"phase\": $phase_number,
-            \"zones\": $phase_zones,
-            \"max_execution_time\": $DEFAULT_PHASE_TIMEOUT,
-            \"success_threshold\": $SUCCESS_THRESHOLD,
-            \"rollback_timeout\": $DEFAULT_ROLLBACK_TIMEOUT
-        }"
-
-        rollout_phases=$(echo "$rollout_phases" | jq ". + [$phase_entry]")
-        ((phase_number++))
-    done
-
-    echo "$rollout_phases"
-}
-
-create_success_criteria() {
-    local rollout_phases="$1"
-
-    local success_criteria="[]"
-
-    local phase_count
-    phase_count=$(echo "$rollout_phases" | jq 'length')
-
-    for ((i=0; i<phase_count; i++)); do
-        local phase_data
-        phase_data=$(echo "$rollout_phases" | jq ".[$i]")
-
-        local zone_names
-        zone_names=$(echo "$phase_data" | jq -r '.zones[].name')
-
-        local phase_criteria="{
-            \"phase\": $((i + 1)),
-            \"required_success_zones\": [],
-            \"minimum_confidence_threshold\": $SUCCESS_THRESHOLD,
-            \"all_zones_must_complete\": true,
-            \"validation_checks\": [
-                \"redis_namespace_isolation\",
-                \"agent_completion_signaling\",
-                \"coordinator_lifecycle_management\",
-                \"deliverable_verification\"
-            ]
-        }"
-
-        # Add required zone names
-        local zones_array="[]"
-        while IFS= read -r zone_name; do
-            zones_array=$(echo "$zones_array" | jq ". + [\"$zone_name\"]")
-        done <<< "$zone_names"
-
-        phase_criteria=$(echo "$phase_criteria" | jq ".required_success_zones = $zones_array")
-        success_criteria=$(echo "$success_criteria" | jq ". + [$phase_criteria]")
-    done
-
-    echo "$success_criteria"
-}
-
-create_rollback_triggers() {
-    local rollout_phases="$1"
-
-    local rollback_triggers="[]"
-
-    local phase_count
-    phase_count=$(echo "$rollout_phases" | jq 'length')
-
-    # Global rollback triggers
-    local global_triggers="[
-        {
-            \"trigger\": \"any_zone_critical_failure\",
-            \"action\": \"immediate_rollback_all\",
-            \"description\": \"Critical system failure in any zone\"
-        },
-        {
-            \"trigger\": \"redis_namespace_corruption\",
-            \"action\": \"emergency_stop_and_cleanup\",
-            \"description\": \"Redis namespace isolation breach\"
-        },
-        {
-            \"trigger\": \"resource_exhaustion\",
-            \"action\": \"scale_back_and_retry\",
-            \"description\": \"System resources exhausted\"
-        }
-    ]"
-
-    # Phase-specific rollback triggers
-    local i=0
-    for ((i=0; i<phase_count; i++)); do
-        local phase_zones
-        phase_zones=$(echo "$rollout_phases" | jq -r ".[$i].zones[].name")
-
-        while IFS= read -r zone_name; do
-            local trigger="{
-                \"trigger\": \"zone_${zone_name}_completion_failure\",
-                \"phase\": $((i + 1)),
-                \"action\": \"rollback_current_phase\",
-                \"description\": \"Zone $zone_name failed to complete in phase $((i + 1))\"
-            }"
-
-            rollback_triggers=$(echo "$rollback_triggers" | jq ". + [$trigger]")
-        done <<< "$phase_zones"
-    done
-
-    # Combine global and specific triggers
-    echo "$global_triggers" | jq ". + $rollback_triggers"
-}
-
-generate_rollout_plan() {
-    local zone_config="$1"
-    local max_zones_per_phase="${2:-2}"
-
-    info "Analyzing zone complexity for rollout planning"
-
-    # Rank zones by complexity
-    local ranked_zones
-    ranked_zones=$(rank_zones_by_complexity "$zone_config")
-
-    # Create rollout phases
-    local rollout_phases
-    rollout_phases=$(create_rollout_phases "$ranked_zones" "$max_zones_per_phase")
-
-    # Create success criteria
-    local success_criteria
-    success_criteria=$(create_success_criteria "$rollout_phases")
-
-    # Create rollback triggers
-    local rollback_triggers
-    rollback_triggers=$(create_rollback_triggers "$rollout_phases")
-
-    # Generate complete rollout plan
-    local rollout_plan="{
-        \"timestamp\": $(date '+%s'),
-        \"total_zones\": $(echo "$zone_config" | jq '.zones | length'),
-        \"max_zones_per_phase\": $max_zones_per_phase,
-        \"phases\": $rollout_phases,
-        \"success_criteria\": $success_criteria,
-        \"rollback_triggers\": $rollback_triggers,
-        \"execution_strategy\": {
-            \"type\": \"graduated_rollout\",
-            \"monitoring_level\": \"enhanced\",
-            \"auto_rollback_enabled\": true,
-            \"manual_approval_required\": false
-        }
-    }"
-
-    echo "$rollout_plan"
-}
-
-display_rollout_summary() {
-    local rollout_plan="$1"
-
-    echo
-    info "=== Risk-Based Rollout Plan ==="
-    echo "Total zones: $(echo "$rollout_plan" | jq -r '.total_zones')"
-    echo "Maximum zones per phase: $(echo "$rollout_plan" | jq -r '.max_zones_per_phase')"
-    echo
-
-    local phase_count
-    phase_count=$(echo "$rollout_plan" | jq '.phases | length')
-
-    echo "Rollout Phases:"
-    for ((i=0; i<phase_count; i++)); do
-        local phase_data
-        phase_data=$(echo "$rollout_plan" | jq ".phases[$i]")
-        local phase_number=$((i + 1))
-        local zone_count
-        zone_count=$(echo "$phase_data" | jq '.zones | length')
-        local zone_names
-        zone_names=$(echo "$phase_data" | jq -r '.zones[].name' | tr '\n' ', ' | sed 's/,$//')
-
-        echo "  Phase $phase_number: $zone_names ($zone_count zones)"
-    done
-    echo
-
-    echo "Success Criteria:"
-    echo "  - Minimum confidence threshold: $(echo "$rollout_plan" | jq -r '.success_criteria[0].minimum_confidence_threshold')"
-    echo "  - All zones must complete: $(echo "$rollout_plan" | jq -r '.success_criteria[0].all_zones_must_complete')"
-    echo "  - Validation checks: $(echo "$rollout_plan" | jq -r '.success_criteria[0].validation_checks | length') checks"
-    echo
-
-    echo "Rollback Triggers:"
-    echo "  - Global triggers: 3"
-    echo "  - Phase-specific triggers: $(echo "$rollout_plan" | jq '.rollback_triggers | length - 3')"
-    echo
-}
-
-main() {
-    local config_file="$1"
-    local max_zones_per_phase="${2:-2}"
-
-    if [[ -z "$config_file" ]]; then
-        error "Usage: $0 <zone-config-file> [max-zones-per-phase]"
-    fi
-
-    if [[ ! -f "$config_file" ]]; then
-        error "Configuration file not found: $config_file"
-    fi
-
-    log "Starting risk-based rollout 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
-
-    # Generate rollout plan
-    local rollout_plan
-    rollout_plan=$(generate_rollout_plan "$zone_config" "$max_zones_per_phase")
-
-    # Save rollout plan
-    local output_file="/tmp/rollout-plan-$(date '+%s').json"
-    echo "$rollout_plan" > "$output_file"
-
-    log "✅ Risk-based rollout planning completed"
-    log "Rollout plan saved to: $output_file"
-
-    # Display summary
-    display_rollout_summary "$rollout_plan"
-}
-
-# Execute main function with all arguments
-main "$@"