claude-flow-novice 2.8.1 → 2.9.0

package/.claude/skills/redis-coordination/test-timeout-enforcement.sh

@@ -1,513 +0,0 @@
-#!/bin/bash
-
-# CFN Loop Timeout Enforcement Testing Skill
-# Validates timeout mechanisms at agent, orchestrator, and system levels
-
-set -euo pipefail
-
-# Skill configuration
-SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$(dirname "$SKILL_DIR")")"
-TASK_ID="${TASK_ID:-test-timeout-enforcement-$(date +%s)}"
-AGENT_ID="${AGENT_ID:-timeout-tester}"
-
-# Configuration defaults
-DEFAULT_TIMEOUT=30
-TEST_TIMEOUT=5
-CLEANUP_DELAY=2
-
-# Colors and logging
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-log() {
-    echo "$(date '+%Y-%m-%d %H:%M:%S') [$$] $*"
-}
-
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $*"
-}
-
-log_success() {
-    echo -e "${GREEN}[PASS]${NC} $*"
-}
-
-log_error() {
-    echo -e "${RED}[FAIL]${NC} $*"
-}
-
-log_warning() {
-    echo -e "${YELLOW}[WARN]${NC} $*"
-}
-
-# Redis connection check
-check_redis() {
-    if ! redis-cli ping >/dev/null 2>&1; then
-        log_warning "Redis not available - some tests will be skipped"
-        return 1
-    fi
-    return 0
-}
-
-# Cleanup Redis test data
-cleanup_redis_data() {
-    if check_redis; then
-        redis-cli --scan --pattern "swarm:${TASK_ID}:*" | xargs -r redis-cli del >/dev/null 2>&1 || true
-        redis-cli --scan --pattern "timeout-test:*" | xargs -r redis-cli del >/dev/null 2>&1 || true
-    fi
-}
-
-# Test 1: Agent process timeout enforcement
-test_agent_process_timeout() {
-    log_info "Testing agent process timeout enforcement..."
-    
-    local test_agent_id="timeout-agent-$(date +%s)"
-    local timeout_duration=$TEST_TIMEOUT
-    local test_file="/tmp/agent-timeout-test-${test_agent_id}.tmp"
-    
-    # Create a test agent that runs longer than timeout
-    (
-        echo "Agent $test_agent_id started" > "$test_file"
-        for i in {1..10}; do
-            echo "Agent $test_agent_id working... step $i" >> "$test_file"
-            sleep 1
-        done
-        echo "Agent $test_agent_id completed" >> "$test_file"
-    ) &
-    
-    local agent_pid=$!
-    local timeout_occurred=false
-    
-    # Monitor agent with timeout
-    local elapsed=0
-    while kill -0 "$agent_pid" 2>/dev/null && [[ $elapsed -lt $timeout_duration ]]; do
-        sleep 1
-        ((elapsed++))
-    done
-    
-    # Check if agent should be terminated
-    if kill -0 "$agent_pid" 2>/dev/null; then
-        timeout_occurred=true
-        log_info "Agent timeout reached, terminating process..."
-        
-        # Graceful termination
-        kill -TERM "$agent_pid" 2>/dev/null || true
-        sleep 1
-        
-        # Force termination if still running
-        if kill -0 "$agent_pid" 2>/dev/null; then
-            kill -KILL "$agent_pid" 2>/dev/null || true
-            log_info "Force terminated agent process"
-        fi
-    fi
-    
-    # Verify results
-    if $timeout_occurred; then
-        # Check that agent was interrupted
-        local final_line
-        final_line=$(tail -1 "$test_file" 2>/dev/null || echo "")
-        
-        if [[ "$final_line" != *"completed"* ]]; then
-            log_success "Agent timeout enforcement working correctly"
-            rm -f "$test_file"
-            return 0
-        else
-            log_error "Agent completed despite timeout"
-            rm -f "$test_file"
-            return 1
-        fi
-    else
-        log_error "Agent completed before timeout (test configuration issue)"
-        rm -f "$test_file"
-        return 1
-    fi
-}
-
-# Test 2: Orchestrator timeout coordination
-test_orchestrator_timeout_coordination() {
-    log_info "Testing orchestrator timeout coordination..."
-    
-    if ! check_redis; then
-        log_warning "Skipping orchestrator timeout test - Redis not available"
-        return 0
-    fi
-    
-    local test_task_id="orchestrator-timeout-$(date +%s)"
-    local test_agent_id="test-agent-${test_task_id}"
-    local timeout_duration=$TEST_TIMEOUT
-    
-    # Simulate orchestrator spawning an agent
-    (
-        # Simulate agent work that times out
-        echo "Agent $test_agent_id starting work"
-        redis-cli set "swarm:${test_task_id}:${test_agent_id}:status" "working" >/dev/null
-        
-        for i in {1..10}; do
-            redis-cli set "swarm:${test_task_id}:${test_agent_id}:progress" "$i/10" >/dev/null
-            sleep 1
-        done
-        
-        redis-cli set "swarm:${test_task_id}:${test_agent_id}:status" "completed" >/dev/null
-    ) &
-    
-    local orchestrator_pid=$!
-    local timeout_occurred=false
-    
-    # Simulate orchestrator timeout monitoring
-    local elapsed=0
-    while kill -0 "$orchestrator_pid" 2>/dev/null && [[ $elapsed -lt $timeout_duration ]]; do
-        sleep 1
-        ((elapsed++))
-        
-        # Check agent status
-        local agent_status
-        agent_status=$(redis-cli get "swarm:${test_task_id}:${test_agent_id}:status" 2>/dev/null || echo "")
-        
-        if [[ -n "$agent_status" ]]; then
-            log_info "Agent status: $agent_status"
-        fi
-    done
-    
-    # Timeout handling
-    if kill -0 "$orchestrator_pid" 2>/dev/null; then
-        timeout_occurred=true
-        log_info "Orchestrator timeout reached, terminating..."
-        
-        kill -TERM "$orchestrator_pid" 2>/dev/null || true
-        sleep 1
-        kill -KILL "$orchestrator_pid" 2>/dev/null || true
-    fi
-    
-    # Cleanup Redis
-    redis-cli del "swarm:${test_task_id}:${test_agent_id}:status" >/dev/null 2>&1 || true
-    redis-cli del "swarm:${test_task_id}:${test_agent_id}:progress" >/dev/null 2>&1 || true
-    
-    if $timeout_occurred; then
-        log_success "Orchestrator timeout coordination working correctly"
-        return 0
-    else
-        log_error "Orchestrator timeout coordination failed"
-        return 1
-    fi
-}
-
-# Test 3: Multiple agent timeout handling
-test_multiple_agent_timeout() {
-    log_info "Testing multiple agent timeout handling..."
-    
-    local agent_count=3
-    local timeout_duration=$TEST_TIMEOUT
-    local agent_pids=()
-    
-    # Spawn multiple agents
-    for i in $(seq 1 $agent_count); do
-        (
-            echo "Agent $i starting work"
-            for j in {1..10}; do
-                echo "Agent $i: step $j"
-                sleep 1
-            done
-            echo "Agent $i completed"
-        ) &
-        agent_pids+=($!)
-    done
-    
-    # Monitor all agents with timeout
-    local elapsed=0
-    local running_agents=true
-    
-    while $running_agents && [[ $elapsed -lt $timeout_duration ]]; do
-        running_agents=false
-        for pid in "${agent_pids[@]}"; do
-            if kill -0 "$pid" 2>/dev/null; then
-                running_agents=true
-                break
-            fi
-        done
-        sleep 1
-        ((elapsed++))
-    done
-    
-    # Terminate remaining agents
-    local terminated_count=0
-    for pid in "${agent_pids[@]}"; do
-        if kill -0 "$pid" 2>/dev/null; then
-            kill -TERM "$pid" 2>/dev/null || true
-            sleep 1
-            if kill -0 "$pid" 2>/dev/null; then
-                kill -KILL "$pid" 2>/dev/null || true
-            fi
-            ((terminated_count++))
-        fi
-    done
-    
-    if [[ $terminated_count -gt 0 ]]; then
-        log_success "Multiple agent timeout handling: $terminated_count/$agent_count agents timed out"
-        return 0
-    else
-        log_error "No agents required timeout (test configuration issue)"
-        return 1
-    fi
-}
-
-# Test 4: Redis cleanup after timeout
-test_redis_cleanup_after_timeout() {
-    log_info "Testing Redis cleanup after timeout..."
-    
-    if ! check_redis; then
-        log_warning "Skipping Redis cleanup test - Redis not available"
-        return 0
-    fi
-    
-    local test_task_id="cleanup-test-$(date +%s)"
-    local test_agent_id="cleanup-agent"
-    
-    # Create test Redis data
-    redis-cli set "swarm:${test_task_id}:${test_agent_id}:status" "working" >/dev/null
-    redis-cli set "swarm:${test_task_id}:${test_agent_id}:confidence" "0.85" >/dev/null
-    redis-cli set "swarm:${test_task_id}:gate-passed" "true" >/dev/null
-    redis-cli set "swarm:${test_task_id}:iteration" "1" >/dev/null
-    
-    # Verify data was created
-    local key_count
-    key_count=$(redis-cli --scan --pattern "swarm:${test_task_id}:*" | wc -l)
-    
-    if [[ $key_count -eq 0 ]]; then
-        log_error "Failed to create test Redis data"
-        return 1
-    fi
-    
-    # Simulate timeout scenario
-    (
-        # Simulate agent that times out
-        echo "Agent starting work"
-        sleep 10  # Will be killed by timeout
-        echo "Agent completed"
-    ) &
-    
-    local agent_pid=$!
-    
-    # Simulate timeout
-    sleep 2
-    kill -TERM "$agent_pid" 2>/dev/null || true
-    
-    # Perform cleanup (simulating orchestrator behavior)
-    redis-cli --scan --pattern "swarm:${test_task_id}:*" | xargs -r redis-cli del >/dev/null
-    
-    # Verify cleanup
-    local remaining_keys
-    remaining_keys=$(redis-cli --scan --pattern "swarm:${test_task_id}:*" | wc -l)
-    
-    if [[ $remaining_keys -eq 0 ]]; then
-        log_success "Redis cleanup after timeout working correctly"
-        return 0
-    else
-        log_error "Redis cleanup failed: $remaining_keys keys remaining"
-        return 1
-    fi
-}
-
-# Test 5: Timeout escalation (SIGTERM → SIGKILL)
-test_timeout_escalation() {
-    log_info "Testing timeout escalation (SIGTERM → SIGKILL)..."
-    
-    local test_pid
-    local timeout_grace=2
-    local timeout_force=5
-    
-    # Create a process that ignores SIGTERM
-    (
-        # Ignore SIGTERM
-        trap '' TERM
-        echo "Ignoring SIGTERM, will only respond to SIGKILL"
-        while true; do
-            echo "Still running..."
-            sleep 1
-        done
-    ) &
-    
-    test_pid=$!
-    
-    # First, try SIGTERM
-    kill -TERM "$test_pid" 2>/dev/null || true
-    sleep $timeout_grace
-    
-    # Check if still running
-    if kill -0 "$test_pid" 2>/dev/null; then
-        log_info "SIGTERM ignored, escalating to SIGKILL"
-        kill -KILL "$test_pid" 2>/dev/null || true
-        sleep 1
-        
-        if ! kill -0 "$test_pid" 2>/dev/null; then
-            log_success "Timeout escalation (SIGTERM → SIGKILL) working correctly"
-            return 0
-        else
-            log_error "SIGKILL failed to terminate process"
-            return 1
-        fi
-    else
-        log_error "Process responded to SIGTERM (test configuration issue)"
-        return 1
-    fi
-}
-
-# Test 6: Timeout in different execution contexts
-test_timeout_contexts() {
-    log_info "Testing timeout in different execution contexts..."
-    
-    local test_results=()
-    
-    # Test 1: Background process timeout
-    (
-        sleep 10
-    ) &
-    local bg_pid=$!
-    
-    if timeout 2 wait "$bg_pid"; then
-        test_results+=("FAIL: Background process should have timed out")
-    else
-        test_results+=("PASS: Background process timed out correctly")
-    fi
-    
-    # Test 2: Subshell timeout
-    if timeout 2 bash -c 'sleep 5; echo "completed"'; then
-        test_results+=("FAIL: Subshell should have timed out")
-    else
-        test_results+=("PASS: Subshell timed out correctly")
-    fi
-    
-    # Test 3: Command timeout
-    if timeout 2 sleep 5; then
-        test_results+=("FAIL: Command should have timed out")
-    else
-        test_results+=("PASS: Command timed out correctly")
-    fi
-    
-    # Test 4: Pipeline timeout
-    if timeout 2 bash -c 'sleep 5 | cat'; then
-        test_results+=("FAIL: Pipeline should have timed out")
-    else
-        test_results+=("PASS: Pipeline timed out correctly")
-    fi
-    
-    # Count results
-    local pass_count=0
-    local total_count=${#test_results[@]}
-    
-    for result in "${test_results[@]}"; do
-        if [[ "$result" == PASS* ]]; then
-            ((pass_count++))
-            log_success "$result"
-        else
-            log_error "$result"
-        fi
-    done
-    
-    if [[ $pass_count -eq $total_count ]]; then
-        log_success "All timeout contexts working correctly ($pass_count/$total_count)"
-        return 0
-    else
-        log_error "Some timeout contexts failed ($pass_count/$total_count)"
-        return 1
-    fi
-}
-
-# Main test execution
-main() {
-    log_info "Starting CFN Loop Timeout Enforcement Testing"
-    log_info "Task ID: $TASK_ID"
-    log_info "Agent ID: $AGENT_ID"
-    
-    local tests_passed=0
-    local tests_total=6
-    
-    # Run all timeout enforcement tests
-    if test_agent_process_timeout; then ((tests_passed++)); fi
-    if test_orchestrator_timeout_coordination; then ((tests_passed++)); fi
-    if test_multiple_agent_timeout; then ((tests_passed++)); fi
-    if test_redis_cleanup_after_timeout; then ((tests_passed++)); fi
-    if test_timeout_escalation; then ((tests_passed++)); fi
-    if test_timeout_contexts; then ((tests_passed++)); fi
-    
-    # Cleanup
-    cleanup_redis_data
-    
-    # Print summary
-    echo ""
-    log_info "Timeout Enforcement Test Summary:"
-    log_info "Tests passed: $tests_passed/$tests_total"
-    
-    if [[ $tests_passed -eq $tests_total ]]; then
-        log_success "🎉 All timeout enforcement tests passed!"
-        return 0
-    else
-        log_error "❌ Some timeout enforcement tests failed!"
-        return 1
-    fi
-}
-
-# Help function
-show_help() {
-    cat << EOF
-CFN Loop Timeout Enforcement Testing Skill
-
-Tests timeout mechanisms at multiple levels:
-- Agent process timeout enforcement
-- Orchestrator timeout coordination  
-- Multiple agent timeout handling
-- Redis cleanup after timeout
-- Timeout escalation (SIGTERM → SIGKILL)
-- Timeout in different execution contexts
-
-Usage: $0 [OPTIONS]
-
-Options:
-    --task-id ID      Custom task ID (default: auto-generated)
-    --agent-id ID     Custom agent ID (default: timeout-tester)
-    --timeout SECONDS Test timeout duration (default: 5)
-    --help            Show this help message
-
-Environment Variables:
-    TASK_ID          Override task ID
-    AGENT_ID         Override agent ID
-
-Examples:
-    $0
-    $0 --task-id custom-task-123 --timeout 10
-    TASK_ID=custom-task $0 --agent-id custom-agent
-
-EOF
-}
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --timeout)
-            TEST_TIMEOUT="$2"
-            shift 2
-            ;;
-        --help)
-            show_help
-            exit 0
-            ;;
-        *)
-            log_error "Unknown option: $1"
-            show_help
-            exit 1
-            ;;
-    esac
-done
-
-# Run main function
-main "$@"

package/.claude/skills/redis-coordination/tests/convert-line-endings.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-# Convert files to Unix line endings
-convert_file() {
-    local file="$1"
-    # Remove carriage returns and write back to the same file
-    tr -d '\r' < "$file" > "$file.tmp"
-    mv "$file.tmp" "$file"
-    chmod +x "$file"
-}
-
-# Convert files in the current directory
-for file in run-tests.sh test-primitives.sh test-utils.sh; do
-    convert_file "$file"
-done

package/.claude/skills/redis-coordination/tests/dlq-functionality-test.sh

@@ -1,102 +0,0 @@
-#!/bin/bash
-# DLQ Functionality Test Suite
-# Validates Dead Letter Queue write, expiration, and query mechanisms
-
-set -euo pipefail
-
-# Source common test utilities
-source "$(dirname "$0")/test-utils.sh"
-
-# Generate test configuration
-generate_test_config() {
-    local config_file="/tmp/dlq-test-config.json"
-    cat > "$config_file" << EOF
-{
-    "dlq_max_retries": 3,
-    "dlq_ttl_days": 7,
-    "dlq_write_mode": "strict",
-    "redis_connection": {
-        "host": "localhost",
-        "port": 6379
-    }
-}
-EOF
-    echo "$config_file"
-}
-
-# Test DLQ write after max retries
-test_dlq_write() {
-    local config_file=$(generate_test_config)
-    local task_id="test-task-$(date +%s)"
-    local agent_id="tester-dlq"
-    local error_details='{"code": 500, "message": "Test Error"}'
-
-    # Simulate max retry failure
-    local result=$(./.claude/skills/redis-coordination/write-to-dlq.sh \
-        --task-id "$task_id" \
-        --agent-id "$agent_id" \
-        --error "$error_details" \
-        --config "$config_file")
-
-    assert_not_empty "$result" "DLQ write failed"
-
-    # Validate DLQ entry structure
-    local dlq_entry=$(redis-cli get "dlq:$task_id:$agent_id")
-    assert_json_valid "$dlq_entry" "Invalid DLQ JSON structure"
-
-    # Check specific fields
-    local extracted_agent_id=$(echo "$dlq_entry" | jq -r '.agent_id')
-    assert_equal "$extracted_agent_id" "$agent_id" "Agent ID not preserved in DLQ"
-}
-
-# Test TTL expiration
-test_dlq_ttl() {
-    local config_file=$(generate_test_config)
-    local task_id="ttl-test-$(date +%s)"
-    local agent_id="tester-ttl"
-    local error_details='{"code": 404, "message": "Resource Not Found"}'
-
-    # Write to DLQ
-    ./.claude/skills/redis-coordination/write-to-dlq.sh \
-        --task-id "$task_id" \
-        --agent-id "$agent_id" \
-        --error "$error_details" \
-        --config "$config_file"
-
-    # Check TTL (should be close to 7 days)
-    local ttl=$(redis-cli ttl "dlq:$task_id:$agent_id")
-    assert "[ $ttl -ge 604600 ] && [ $ttl -le 604800 ]" "TTL not set correctly"
-}
-
-# Test query-dlq script
-test_dlq_query() {
-    # Populate test DLQ entries
-    local task_ids=("query-test-1" "query-test-2")
-    for task_id in "${task_ids[@]}"; do
-        ./.claude/skills/redis-coordination/write-to-dlq.sh \
-            --task-id "$task_id" \
-            --agent-id "tester-query" \
-            --error '{"code": 503, "message": "Test Query Error"}'
-    done
-
-    # Query DLQ
-    local query_result=$(./.claude/skills/redis-coordination/query-dlq.sh \
-        --agent-id "tester-query")
-
-    assert_not_empty "$query_result" "DLQ query returned no results"
-
-    # Validate query results contain expected task IDs
-    for task_id in "${task_ids[@]}"; do
-        assert "echo '$query_result' | grep -q '$task_id'" "Task ID $task_id not found in query results"
-    done
-}
-
-# Run tests
-main() {
-    test_dlq_write
-    test_dlq_ttl
-    test_dlq_query
-    echo "DLQ Functionality Tests: PASSED"
-}
-
-main