claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/skills/cfn-sprint-execution/lib/checkpoint/resume-wave.sh

@@ -1,325 +0,0 @@
-#!/bin/bash
-
-################################################################################
-# CFN Wave Checkpoint - Resume Execution from Checkpoint
-# Purpose: Detect and resume orphaned containers from failed orchestrator runs
-# Version: 1.0.0
-# Exit Codes: 0=success, 1=validation_error, 2=redis_error
-################################################################################
-
-set -euo pipefail
-
-# Script configuration
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../" && pwd)"
-
-# Redis configuration
-readonly REDIS_HOST="${REDIS_HOST:-localhost}"
-readonly REDIS_PORT="${REDIS_PORT:-6379}"
-readonly DEFAULT_REDIS_DB=0
-readonly DEFAULT_TIMEOUT=30
-readonly CHECKPOINT_TTL="${CHECKPOINT_TTL:-3600}"
-
-# Helper: Check Redis connection
-check_redis_connection() {
-    if ! command -v redis-cli &> /dev/null; then
-        return 1
-    fi
-
-    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping >/dev/null 2>&1
-    return $?
-}
-
-# Color codes
-readonly RED='\033[0;31m'
-readonly GREEN='\033[0;32m'
-readonly YELLOW='\033[1;33m'
-readonly BLUE='\033[0;34m'
-readonly CYAN='\033[0;36m'
-readonly NC='\033[0m'
-
-# Logging functions
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_warning() {
-    echo -e "${YELLOW}[WARN]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_debug() {
-    echo -e "${CYAN}[DEBUG]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-################################################################################
-# CHECKPOINT RECOVERY
-################################################################################
-
-resume_wave() {
-    local task_id="$1"
-    local wave_number="${2:-}"
-
-    if [[ -z "$task_id" ]]; then
-        log_error "Usage: resume_wave TASK_ID [WAVE_NUMBER]"
-        return 1
-    fi
-
-    # Verify Redis connectivity
-    if ! check_redis_connection >/dev/null 2>&1; then
-        log_error "Redis not available - cannot resume from checkpoint"
-        return 2
-    fi
-
-    log_info "Attempting to resume wave execution for task=$task_id"
-
-    if [[ -z "$wave_number" ]]; then
-        # Resume all waves with checkpoints
-        local checkpoints
-        checkpoints=$(redis-cli \
-            -h "${REDIS_HOST:-localhost}" \
-            -p "${REDIS_PORT:-6379}" \
-            SMEMBERS "cfn:wave:checkpoints:${task_id}" 2>/dev/null || echo "")
-
-        if [[ -z "$checkpoints" ]]; then
-            log_warning "No checkpoints found for task=$task_id"
-            return 1
-        fi
-
-        log_info "Found checkpoints for waves: $checkpoints"
-
-        local resume_count=0
-        while IFS= read -r wave_num; do
-            if [[ -n "$wave_num" ]]; then
-                if _resume_single_wave "$task_id" "$wave_num"; then
-                    ((resume_count++))
-                fi
-            fi
-        done <<< "$checkpoints"
-
-        if [[ $resume_count -gt 0 ]]; then
-            log_success "Resumed $resume_count wave(s)"
-            return 0
-        else
-            log_warning "Failed to resume any waves"
-            return 1
-        fi
-    else
-        # Resume specific wave
-        _resume_single_wave "$task_id" "$wave_number"
-    fi
-}
-
-################################################################################
-# SINGLE WAVE RESUME
-################################################################################
-
-_resume_single_wave() {
-    local task_id="$1"
-    local wave_number="$2"
-
-    log_info "Resuming wave $wave_number of task=$task_id"
-
-    # Get checkpoint data
-    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
-    local checkpoint_data
-    checkpoint_data=$(redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        GET "$checkpoint_key" 2>/dev/null || echo "{}")
-
-    if [[ -z "$checkpoint_data" ]] || [[ "$checkpoint_data" == "{}" ]]; then
-        log_error "No checkpoint data found for wave $wave_number"
-        return 1
-    fi
-
-    log_debug "Checkpoint data: $checkpoint_data"
-
-    # Extract container IDs
-    local container_ids
-    container_ids=$(echo "$checkpoint_data" | jq -r '.container_ids | join(",")')
-
-    local expected_count
-    expected_count=$(echo "$checkpoint_data" | jq -r '.expected_count')
-
-    log_info "Expected $expected_count containers, resuming with IDs: $container_ids"
-
-    # Verify containers still exist
-    local running_count=0
-    local failed_containers=""
-
-    while IFS=',' read -r container_id; do
-        if [[ -n "$container_id" ]]; then
-            if docker ps -a --filter "id=$container_id" --format "{{.ID}}" 2>/dev/null | grep -q "$container_id"; then
-                ((running_count++))
-                log_debug "Container $container_id exists"
-            else
-                log_warning "Container $container_id not found"
-                failed_containers="${failed_containers}${container_id},"
-            fi
-        fi
-    done <<< "$container_ids"
-
-    log_info "Found $running_count/$expected_count containers still running"
-
-    if [[ $running_count -eq 0 ]]; then
-        log_error "No containers found for recovery"
-        return 1
-    fi
-
-    # Update checkpoint status
-    echo "$checkpoint_data" | jq \
-        --arg status "resumed" \
-        --arg resumed_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-        --arg running_count "$running_count" \
-        '.status = $status | .resumed_at = $resumed_at | .running_count = ($running_count | tonumber)' \
-        > /tmp/checkpoint_update.json
-
-    redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        SET "$checkpoint_key" "$(cat /tmp/checkpoint_update.json)" \
-        EX "${CHECKPOINT_TTL:-3600}" 2>/dev/null || true
-
-    log_success "Resumed wave $wave_number with $running_count active containers"
-    return 0
-}
-
-################################################################################
-# GET RESUMABLE WAVES FOR TASK
-################################################################################
-
-get_resumable_waves() {
-    local task_id="$1"
-
-    if [[ -z "$task_id" ]]; then
-        log_error "Usage: get_resumable_waves TASK_ID"
-        return 1
-    fi
-
-    # Verify Redis connectivity
-    if ! check_redis_connection >/dev/null 2>&1; then
-        log_error "Redis not available"
-        return 2
-    fi
-
-    local checkpoints
-    checkpoints=$(redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        SMEMBERS "cfn:wave:checkpoints:${task_id}" 2>/dev/null || echo "")
-
-    if [[ -z "$checkpoints" ]]; then
-        return 1
-    fi
-
-    echo "$checkpoints"
-    return 0
-}
-
-################################################################################
-# VERIFY CONTAINER STATUS
-################################################################################
-
-verify_container_status() {
-    local task_id="$1"
-    local wave_number="$2"
-
-    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]]; then
-        log_error "Usage: verify_container_status TASK_ID WAVE_NUMBER"
-        return 1
-    fi
-
-    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
-
-    # Get checkpoint data
-    local checkpoint_data
-    checkpoint_data=$(redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        GET "$checkpoint_key" 2>/dev/null || echo "{}")
-
-    if [[ -z "$checkpoint_data" ]] || [[ "$checkpoint_data" == "{}" ]]; then
-        log_error "No checkpoint found"
-        return 1
-    fi
-
-    # Extract container IDs and verify
-    local container_ids
-    container_ids=$(echo "$checkpoint_data" | jq -r '.container_ids | join(" ")')
-
-    local status_json='{
-        "wave_number": '$wave_number',
-        "containers": []
-    }'
-
-    for container_id in $container_ids; do
-        if [[ -z "$container_id" ]]; then
-            continue
-        fi
-
-        # Check container state
-        local container_info
-        container_info=$(docker ps -a --filter "id=$container_id" --format "json" 2>/dev/null || echo "{}")
-
-        if [[ "$container_info" != "{}" ]]; then
-            local container_status=$(echo "$container_info" | jq -r '.State // "unknown"')
-            status_json=$(echo "$status_json" | jq \
-                --arg id "$container_id" \
-                --arg state "$container_status" \
-                '.containers += [{id: $id, state: $state}]')
-
-            log_debug "Container $container_id state: $container_status"
-        else
-            status_json=$(echo "$status_json" | jq \
-                --arg id "$container_id" \
-                '.containers += [{id: $id, state: "missing"}]')
-
-            log_warning "Container $container_id not found"
-        fi
-    done
-
-    echo "$status_json"
-    return 0
-}
-
-################################################################################
-# MAIN OPERATION DISPATCH
-################################################################################
-
-main() {
-    local operation="${1:-}"
-    shift || true
-
-    case "$operation" in
-        resume)
-            # resume TASK_ID [WAVE_NUMBER]
-            resume_wave "$@"
-            ;;
-        get-resumable)
-            # get-resumable TASK_ID
-            get_resumable_waves "$@"
-            ;;
-        verify)
-            # verify TASK_ID WAVE_NUMBER
-            verify_container_status "$@"
-            ;;
-        *)
-            log_error "Unknown operation: $operation"
-            echo "Available operations: resume, get-resumable, verify"
-            return 1
-            ;;
-    esac
-}
-
-# Execute if not sourced
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    main "$@"
-fi

package/claude-assets/skills/cfn-sprint-execution/lib/checkpoint/save-checkpoint.sh

@@ -1,284 +0,0 @@
-#!/bin/bash
-
-################################################################################
-# CFN Wave Checkpoint - Save Execution State
-# Purpose: Persist wave execution state to Redis for recovery
-# Version: 1.0.0
-# Exit Codes: 0=success, 1=validation_error, 2=redis_error
-################################################################################
-
-set -euo pipefail
-
-# Script configuration
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../" && pwd)"
-
-# Redis configuration
-readonly REDIS_HOST="${REDIS_HOST:-localhost}"
-readonly REDIS_PORT="${REDIS_PORT:-6379}"
-readonly DEFAULT_REDIS_DB=0
-readonly DEFAULT_TIMEOUT=30
-readonly CHECKPOINT_TTL="${CHECKPOINT_TTL:-3600}"
-
-# Helper: Check Redis connection
-check_redis_connection() {
-    if ! command -v redis-cli &> /dev/null; then
-        return 1
-    fi
-
-    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping >/dev/null 2>&1
-    return $?
-}
-
-# Color codes
-readonly RED='\033[0;31m'
-readonly GREEN='\033[0;32m'
-readonly YELLOW='\033[1;33m'
-readonly BLUE='\033[0;34m'
-readonly NC='\033[0m'
-
-# Logging functions
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-log_warning() {
-    echo -e "${YELLOW}[WARN]${NC} $(date '+%H:%M:%S') $*" >&2
-}
-
-################################################################################
-# CHECKPOINT SAVE FUNCTION
-################################################################################
-
-save_checkpoint() {
-    local task_id="$1"
-    local wave_number="$2"
-    local container_ids="$3"
-    local spawn_time="$4"
-    local expected_count="$5"
-
-    # Validation
-    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]] || [[ -z "$expected_count" ]]; then
-        log_error "Usage: save_checkpoint TASK_ID WAVE_NUMBER CONTAINER_IDS SPAWN_TIME EXPECTED_COUNT"
-        return 1
-    fi
-
-    # Verify Redis connectivity
-    if ! check_redis_connection >/dev/null 2>&1; then
-        log_error "Redis not available - checkpoint persistence disabled"
-        log_warning "Wave execution will proceed without recovery capability"
-        return 0  # Non-fatal: continue execution
-    fi
-
-    # Build checkpoint JSON
-    local checkpoint_json
-    checkpoint_json=$(jq -n \
-        --arg task_id "$task_id" \
-        --arg wave_number "$wave_number" \
-        --arg container_ids "$container_ids" \
-        --arg spawn_time "$spawn_time" \
-        --arg expected_count "$expected_count" \
-        --arg created_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-        '{
-            task_id: $task_id,
-            wave_number: ($wave_number | tonumber),
-            container_ids: ($container_ids | split(",")),
-            spawn_time: ($spawn_time | tonumber),
-            expected_count: ($expected_count | tonumber),
-            created_at: $created_at,
-            status: "in_progress"
-        }')
-
-    # Generate checkpoint key
-    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
-
-    # Store in Redis with TTL
-    log_info "Saving checkpoint: $checkpoint_key"
-
-    if redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        SET "$checkpoint_key" "$checkpoint_json" \
-        EX "${CHECKPOINT_TTL:-3600}" 2>/dev/null; then
-
-        log_success "Checkpoint saved for task=$task_id wave=$wave_number"
-
-        # Also track in a set for recovery scanning
-        redis-cli \
-            -h "${REDIS_HOST:-localhost}" \
-            -p "${REDIS_PORT:-6379}" \
-            SADD "cfn:wave:checkpoints:${task_id}" "$wave_number" 2>/dev/null || true
-
-        # Set expiry separately (SADD doesn't support EX)
-        redis-cli \
-            -h "${REDIS_HOST:-localhost}" \
-            -p "${REDIS_PORT:-6379}" \
-            EXPIRE "cfn:wave:checkpoints:${task_id}" "${CHECKPOINT_TTL:-3600}" 2>/dev/null || true
-
-        return 0
-    else
-        log_error "Failed to save checkpoint to Redis"
-        return 2
-    fi
-}
-
-################################################################################
-# CHECKPOINT EXISTS CHECK
-################################################################################
-
-checkpoint_exists() {
-    local task_id="$1"
-    local wave_number="${2:-}"
-
-    if [[ -z "$task_id" ]]; then
-        log_error "checkpoint_exists requires TASK_ID"
-        return 1
-    fi
-
-    # Verify Redis connectivity
-    if ! check_redis_connection >/dev/null 2>&1; then
-        log_warning "Redis not available - checkpoint check skipped"
-        return 1
-    fi
-
-    if [[ -z "$wave_number" ]]; then
-        # Check if any checkpoints exist for task
-        local checkpoint_count
-        checkpoint_count=$(redis-cli \
-            -h "${REDIS_HOST:-localhost}" \
-            -p "${REDIS_PORT:-6379}" \
-            SCARD "cfn:wave:checkpoints:${task_id}" 2>/dev/null || echo "0")
-
-        [[ "$checkpoint_count" -gt 0 ]]
-    else
-        # Check specific wave checkpoint
-        local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
-        redis-cli \
-            -h "${REDIS_HOST:-localhost}" \
-            -p "${REDIS_PORT:-6379}" \
-            EXISTS "$checkpoint_key" 2>/dev/null | grep -q "^1$"
-    fi
-}
-
-################################################################################
-# GET CHECKPOINT DATA
-################################################################################
-
-get_checkpoint() {
-    local task_id="$1"
-    local wave_number="$2"
-
-    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]]; then
-        log_error "Usage: get_checkpoint TASK_ID WAVE_NUMBER"
-        return 1
-    fi
-
-    # Verify Redis connectivity
-    if ! check_redis_connection >/dev/null 2>&1; then
-        log_error "Redis not available"
-        return 2
-    fi
-
-    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
-
-    redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        GET "$checkpoint_key" 2>/dev/null || {
-        log_error "Failed to retrieve checkpoint"
-        return 2
-    }
-}
-
-################################################################################
-# UPDATE CHECKPOINT STATUS
-################################################################################
-
-update_checkpoint_status() {
-    local task_id="$1"
-    local wave_number="$2"
-    local status="$3"
-
-    if [[ -z "$task_id" ]] || [[ -z "$wave_number" ]] || [[ -z "$status" ]]; then
-        log_error "Usage: update_checkpoint_status TASK_ID WAVE_NUMBER STATUS"
-        return 1
-    fi
-
-    # Verify Redis connectivity
-    if ! check_redis_connection >/dev/null 2>&1; then
-        log_warning "Redis not available - status update skipped"
-        return 0
-    fi
-
-    local checkpoint_key="cfn:wave:checkpoint:${task_id}:${wave_number}"
-
-    # Get existing checkpoint
-    local existing
-    existing=$(redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        GET "$checkpoint_key" 2>/dev/null || echo "{}")
-
-    # Update status
-    local updated
-    updated=$(echo "$existing" | jq --arg status "$status" '.status = $status')
-
-    # Save updated checkpoint
-    redis-cli \
-        -h "${REDIS_HOST:-localhost}" \
-        -p "${REDIS_PORT:-6379}" \
-        SET "$checkpoint_key" "$updated" \
-        EX "${CHECKPOINT_TTL:-3600}" 2>/dev/null || {
-        log_error "Failed to update checkpoint status"
-        return 2
-    }
-
-    log_success "Updated checkpoint status: $status"
-    return 0
-}
-
-################################################################################
-# MAIN OPERATION DISPATCH
-################################################################################
-
-main() {
-    local operation="${1:-}"
-    shift || true
-
-    case "$operation" in
-        save)
-            # save TASK_ID WAVE_NUMBER CONTAINER_IDS SPAWN_TIME EXPECTED_COUNT
-            save_checkpoint "$@"
-            ;;
-        exists)
-            # exists TASK_ID [WAVE_NUMBER]
-            checkpoint_exists "$@"
-            ;;
-        get)
-            # get TASK_ID WAVE_NUMBER
-            get_checkpoint "$@"
-            ;;
-        update-status)
-            # update-status TASK_ID WAVE_NUMBER STATUS
-            update_checkpoint_status "$@"
-            ;;
-        *)
-            log_error "Unknown operation: $operation"
-            echo "Available operations: save, exists, get, update-status"
-            return 1
-            ;;
-    esac
-}
-
-# Execute if not sourced
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    main "$@"
-fi

package/claude-assets/skills/cfn-sprint-execution/lib/execution/SKILL.md

@@ -1,27 +0,0 @@
-# Sprint Execution Skill
-
-## Purpose
-Provide a focused wrapper for executing individual sprints within a multi-sprint epic.
-
-## Key Capabilities
-- Inject sprint-specific context
-- Manage CFN Loop execution
-- Enforce scope boundaries
-- Validate sprint deliverables
-- Report sprint results
-
-## Input Requirements
-- Sprint configuration JSON
-- Execution mode (standard/safety)
-
-## Output Specification
-Produces result:
-- PROCEED
-- ITERATE
-- ABORT
-
-## Execution Principles
-- Strict scope management
-- Minimal context injection
-- Deliverable-focused validation
-- Adaptive iteration support

package/claude-assets/skills/cfn-sprint-execution/lib/execution/execute-sprint-task.sh

@@ -1,59 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-# Sprint Task Execution Script
-
-# Validate required arguments
-[[ $# -lt 4 ]] && { 
-    echo "Usage: $0 [SPRINT_CONFIG] [TASK_ID] [AGENT_ID] [SPRINT_ID]"
-    exit 1
-}
-
-SPRINT_CONFIG="$1"
-TASK_ID="$2"
-AGENT_ID="$3"
-SPRINT_ID="$4"
-
-# Validate file inputs
-[[ ! -f "$SPRINT_CONFIG" ]] && {
-    echo "Error: Sprint configuration file not found"
-    exit 1
-}
-
-# Read sprint configuration
-CONFIG=$(cat "$SPRINT_CONFIG")
-
-# Extract sprint details
-CONTEXT=$(echo "$CONFIG" | jq -r '.context_injection')
-DELIVERABLES=$(echo "$CONFIG" | jq -r '.deliverables[]')
-IN_SCOPE=$(echo "$CONFIG" | jq -r '.in_scope[]')
-OUT_OF_SCOPE=$(echo "$CONFIG" | jq -r '.out_of_scope[]')
-
-# Validate deliverables directory
-for deliverable in $DELIVERABLES; do
-    mkdir -p "$(dirname "$deliverable")"
-done
-
-# Redis coordination - signal sprint start
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:sprint_started" "$SPRINT_ID"
-
-# Context injection template
-cat << EOF > /tmp/sprint_context_${SPRINT_ID}.txt
-SPRINT ${SPRINT_ID} CONTEXT:
-
-${CONTEXT}
-
-DELIVERABLES:
-$(echo "$DELIVERABLES" | while read -r file; do echo "- ${file}"; done)
-
-IN SCOPE:
-$(echo "$IN_SCOPE" | while read -r item; do echo "- ${item}"; done)
-
-OUT OF SCOPE:
-$(echo "$OUT_OF_SCOPE" | while read -r item; do echo "- ${item}"; done)
-
-CRITICAL RULES:
-1. Only create files in DELIVERABLES list
-2. Do not implement anything OUT OF SCOPE
-3. Focus strictly on IN SCOPE tasks