claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/redis-coordination/test-utils.sh

@@ -1,97 +0,0 @@
-#!/bin/bash
-# Utility functions for quorum testing
-
-# Check absolute quorum
-check_quorum() {
-    local total_agents="$1"
-    local quorum="$2"
-    local completed_agents="$3"
-
-    if [ "$completed_agents" -ge "$quorum" ]; then
-        echo "SUCCESS"
-    else
-        echo "FAILURE"
-    fi
-}
-
-# Check percentage-based quorum
-check_percentage_quorum() {
-    local total_agents="$1"
-    local quorum_percentage="$2"
-    local completed_agents="$3"
-
-    # Calculate the minimum number of agents required (round up)
-    local required_agents=$(echo "scale=0; ceil($total_agents * $quorum_percentage)" | bc)
-
-    if [ "$completed_agents" -ge "$required_agents" ]; then
-        echo "SUCCESS"
-    else
-        echo "FAILURE"
-    fi
-}
-
-# Graceful degradation strategy
-simulate_graceful_degradation() {
-    local total_agents="$1"
-    local initial_quorum="$2"
-    local max_failures="$3"
-
-    # Dynamically adjust quorum based on failures
-    local current_quorum="$initial_quorum"
-    local adjusted_agents=$((total_agents - max_failures))
-    local adjusted_quorum_threshold=$(echo "scale=2; $current_quorum * 0.8" | bc)
-
-    if (( $(echo "$adjusted_quorum_threshold <= 0.65" | bc -l) )); then
-        echo "HALT"  # Prevent degradation below minimum viable quorum
-    else
-        echo "$(check_percentage_quorum "$adjusted_agents" "$adjusted_quorum_threshold" "$adjusted_agents")"
-    fi
-}
-
-# Assertion functions
-assert_equals() {
-    local actual="$1"
-    local expected="$2"
-    local message="${3:-Assertion failed}"
-
-    if [ "$actual" != "$expected" ]; then
-        echo "FAIL: $message (Expected: $expected, Got: $actual)"
-        exit 1
-    fi
-}
-
-assert_greater_than() {
-    local actual="$1"
-    local expected="$2"
-    local message="${3:-Assertion failed}"
-
-    if [ "$actual" -le "$expected" ]; then
-        echo "FAIL: $message (Expected > $expected, Got: $actual)"
-        exit 1
-    fi
-}
-
-assert_not_empty() {
-    local value="$1"
-    local message="${2:-Value is empty}"
-
-    if [ -z "$value" ]; then
-        echo "FAIL: $message"
-        exit 1
-    fi
-}
-
-# Error handling and logging
-log_error() {
-    local message="$1"
-    echo "[ERROR] $message" >&2
-}
-
-# Cleanup function
-cleanup() {
-    # Remove any temporary files or reset test environments
-    echo "Cleaning up test environment..."
-}
-
-# Trap to ensure cleanup happens even if script fails
-trap cleanup EXIT

package/.claude/skills/redis-coordination/test-waiting-mode.sh

@@ -1,59 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Test script for Redis Coordination Waiting Mode (v1.3.0)
-
-# Utility functions
-log_success() {
-  echo -e "\033[32m[PASS]\033[0m $1"
-}
-
-log_failure() {
-  echo -e "\033[31m[FAIL]\033[0m $1"
-  exit 1
-}
-
-# Setup test variables
-TASK_ID="test-task-$(date +%s)"
-AGENT_IDS=("agent1" "agent2" "agent3")
-
-# Ensure clean test environment
-./invoke-redis-pattern.sh
-
-# Test 1: Enter Waiting Mode
-echo "### Test 1: Enter Waiting Mode ###"
-wait_result=$(./invoke-redis-pattern.sh wait --task-id "$TASK_ID" --agent-id "${AGENT_IDS[0]}" --context "test-context")
-echo "$wait_result" | jq -e '.status == "timeout"' > /dev/null || log_failure "Failed to enter waiting mode"
-log_success "Entered waiting mode successfully"
-
-# Test 2: Wake Agent
-echo -e "\n### Test 2: Wake Agent ###"
-payload='{"iteration": 2, "feedback": "Add error handling"}'
-wake_result=$(./invoke-redis-pattern.sh wake --task-id "$TASK_ID" --agent-id "${AGENT_IDS[0]}" --payload "$payload")
-echo "$wake_result" | jq -e '.status == "success"' > /dev/null || log_failure "Failed to wake agent"
-log_success "Woke agent successfully"
-
-# Test 3: Report Result
-echo -e "\n### Test 3: Report Result ###"
-report_result=$(./invoke-redis-pattern.sh report --task-id "$TASK_ID" --agent-id "${AGENT_IDS[0]}" --confidence 0.92 --result '{"key": "value"}')
-echo "$report_result" | jq -e '.status == "success" and .confidence == 0.92' > /dev/null || log_failure "Failed to report result"
-log_success "Reported result successfully"
-
-# Test 4: Collect Consensus
-echo -e "\n### Test 4: Collect Consensus ###"
-for agent in "${AGENT_IDS[@]}"; do
-  ./invoke-redis-pattern.sh report --task-id "$TASK_ID" --agent-id "$agent" --confidence 0.95 --result "{\"result\": \"test-$agent\"}"
-done
-
-collect_result=$(./invoke-redis-pattern.sh collect --task-id "$TASK_ID" --agent-ids "$(IFS=,; echo "${AGENT_IDS[*]}")")
-echo "$collect_result" | jq -e '.status == "consensus" and .avgConfidence >= 0.90' > /dev/null || log_failure "Failed to collect consensus"
-log_success "Collected consensus successfully"
-
-# Test 5: Timeout Handling
-echo -e "\n### Test 5: Timeout Handling ###"
-timeout_task_id="timeout-test-$(date +%s)"
-timeout_result=$(./invoke-redis-pattern.sh wait --task-id "$timeout_task_id" --agent-id "${AGENT_IDS[0]}" --context "timeout-test")
-echo "$timeout_result" | jq -e '.status == "timeout"' > /dev/null || log_failure "Failed to handle timeout"
-log_success "Timeout handled successfully"
-
-echo -e "\n\033[32m✅ ALL REDIS COORDINATION TESTS PASSED!\033[0m"

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

package/.claude/skills/redis-coordination/tests/edge-cases-test.sh

@@ -1,99 +0,0 @@
-#!/bin/bash
-# Edge Cases Test Suite
-# Validates complex and concurrent scenarios for error recovery
-
-set -euo pipefail
-
-# Source common test utilities
-source "$(dirname "$0")/test-utils.sh"
-
-# Redis connection failure simulation
-test_redis_connection_failure() {
-    local original_redis_host=$(redis-cli config get bind | tail -n 1)
-
-    # Simulate connection failure by setting invalid host
-    redis-cli config set bind "invalid-host"
-
-    set +e  # Disable immediate exit on error
-    ./.claude/skills/redis-coordination/retry-mechanism.sh \
-        --task-id "connection-failure-test" \
-        --max-retries 3 2>/dev/null
-    local exit_code=$?
-    set -e
-
-    # Restore original Redis host
-    redis-cli config set bind "$original_redis_host"
-
-    # Check that retry mechanism handles connection failure
-    assert "[ $exit_code -ne 0 ]" "Connection failure not handled correctly"
-}
-
-# Concurrent DLQ writes test
-test_concurrent_dlq_writes() {
-    local concurrent_tasks=10
-    local base_task_id="concurrent-dlq-$(date +%s)"
-
-    # Run concurrent DLQ writes
-    for ((i=1; i<=concurrent_tasks; i++)); do
-        (
-            ./.claude/skills/redis-coordination/write-to-dlq.sh \
-                --task-id "${base_task_id}-$i" \
-                --agent-id "concurrent-tester" \
-                --error '{"code": 500, "message": "Concurrent Test"}' &
-        )
-    done
-
-    # Wait for all background processes
-    wait
-
-    # Verify all entries were written
-    local query_result=$(./.claude/skills/redis-coordination/query-dlq.sh \
-        --agent-id "concurrent-tester")
-
-    assert "[ $(echo '$query_result' | grep -c "$base_task_id") -eq $concurrent_tasks ]" "Not all concurrent DLQ writes successful"
-}
-
-# Invalid agent ID handling
-test_invalid_agent_id() {
-    set +e  # Disable immediate exit on error
-    local result=$(./.claude/skills/redis-coordination/query-dlq.sh \
-        --agent-id "!@#$%^&*()-invalid-agent" 2>&1)
-    local exit_code=$?
-    set -e
-
-    assert "[ $exit_code -ne 0 ]" "Invalid agent ID not rejected"
-    assert_contains "$result" "Invalid agent ID" "Error message missing for invalid agent ID"
-}
-
-# TTL expiration edge cases
-test_ttl_expiration_edge_cases() {
-    local task_id="ttl-edge-$(date +%s)"
-    local short_ttl=60  # 1 minute
-
-    # Write with extremely short TTL
-    ./.claude/skills/redis-coordination/write-to-dlq.sh \
-        --task-id "$task_id" \
-        --agent-id "ttl-edge-tester" \
-        --error '{"code": 999, "message": "TTL Edge Case"}' \
-        --ttl "$short_ttl"
-
-    # Wait slightly beyond TTL
-    sleep $((short_ttl + 5))
-
-    # Verify entry is automatically removed
-    local query_result=$(./.claude/skills/redis-coordination/query-dlq.sh \
-        --task-id "$task_id")
-
-    assert_empty "$query_result" "DLQ entry not automatically expired"
-}
-
-# Run tests
-main() {
-    test_redis_connection_failure
-    test_concurrent_dlq_writes
-    test_invalid_agent_id
-    test_ttl_expiration_edge_cases
-    echo "Edge Cases Tests: PASSED"
-}
-
-main

package/.claude/skills/redis-coordination/tests/integration-test.sh

@@ -1,170 +0,0 @@
-#!/bin/bash
-# Integration Test Suite
-# Validates full CFN Loop retry and DLQ mechanisms
-
-set -euo pipefail
-
-# Source test utilities
-source "$(dirname "$0")/test-utils.sh"
-
-# Simulate a CFN Loop with potential failures
-test_cfn_loop_retry_integration() {
-    local task_id="integration-test-$(date +%s)"
-    local agent_ids=("researcher" "backend-dev" "devops")
-    local failed_stages=()
-
-    # Mock agent with potential failure
-    mock_agent_with_retry() {
-        local agent_id="$1"
-        local stage="$2"
-
-        # Simulate potential failures
-        local failure_probability=0.3  # 30% chance of failure
-        local random_value=$(shuf -i 1-10 -n 1)
-
-        if [ $random_value -le 3 ]; then
-            echo "Agent $agent_id failed at stage $stage"
-            failed_stages+=("$stage")
-            return 1
-        fi
-        return 0
-    }
-
-    # Run mock CFN Loop
-    local max_iterations=5
-    for ((iteration=1; iteration<=max_iterations; iteration++)); do
-        echo "CFN Loop Iteration $iteration"
-
-        for agent_id in "${agent_ids[@]}"; do
-            if ! mock_agent_with_retry "$agent_id" "iteration-$iteration"; then
-                # Retry mechanism
-                ./.claude/skills/redis-coordination/retry-mechanism.sh \
-                    --task-id "$task_id" \
-                    --agent-id "$agent_id" \
-                    --max-retries 3
-            fi
-
-            # Signal agent completion
-            redis-cli lpush "swarm:$task_id:$agent_id:done" "complete"
-        done
-
-        # Check consensus
-        local consensus_result=$(./.claude/skills/redis-coordination/check-consensus.sh \
-            --task-id "$task_id" \
-            --min-confidence 0.85)
-
-        if [ "$consensus_result" == "success" ]; then
-            break
-        fi
-    done
-
-    # Validate test results
-    assert_not_empty "$consensus_result" "No consensus reached"
-
-    # Check if any agents had to be retried
-    if [ ${#failed_stages[@]} -gt 0 ]; then
-        echo "Stages with failures: ${failed_stages[@]}"
-    fi
-}
-
-# Test DLQ capture during orchestration
-test_dlq_capture_during_orchestration() {
-    local task_id="dlq-capture-$(date +%s)"
-    local agent_id="critical-agent"
-    local error_scenarios=(
-        "connection_timeout"
-        "invalid_configuration"
-        "resource_exhaustion"
-    )
-
-    for scenario in "${error_scenarios[@]}"; do
-        # Simulate orchestration failure
-        local result=$(
-            ./.claude/skills/redis-coordination/orchestrate-cfn-loop.sh \
-                --task-id "$task_id" \
-                --agent-id "$agent_id" \
-                --error-scenario "$scenario" 2>&1
-        )
-
-        # Check if DLQ write occurred
-        local dlq_entry=$(./.claude/skills/redis-coordination/query-dlq.sh \
-            --task-id "$task_id")
-
-        assert_not_empty "$dlq_entry" "DLQ not captured for $scenario"
-        assert_contains "$dlq_entry" "$scenario" "Scenario details missing in DLQ"
-    done
-}
-
-# Config loading test
-test_config_loading() {
-    local config_variations=(
-        "/tmp/full-config.json"
-        "/tmp/minimal-config.json"
-        "/tmp/override-config.json"
-    )
-
-    for config_path in "${config_variations[@]}"; do
-        # Generate test configurations
-        case "$config_path" in
-            "/tmp/full-config.json")
-                cat > "$config_path" << EOF
-{
-    "retry_max_attempts": 5,
-    "backoff_base": 2,
-    "dlq_ttl_days": 7,
-    "log_level": "debug"
-}
-EOF
-                ;;
-            "/tmp/minimal-config.json")
-                cat > "$config_path" << EOF
-{
-    "retry_max_attempts": 3
-}
-EOF
-                ;;
-            "/tmp/override-config.json")
-                cat > "$config_path" << EOF
-{
-    "retry_max_attempts": 10,
-    "feature_flags": {
-        "advanced_retry": true,
-        "dlq_monitoring": true
-    }
-}
-EOF
-                ;;
-        esac
-
-        # Test config loading
-        local result=$(./.claude/skills/redis-coordination/load-config.sh \
-            --config "$config_path")
-
-        assert_not_empty "$result" "Config loading failed for $config_path"
-    done
-}
-
-# Run integration tests
-main() {
-    local passed=0
-    local total_tests=3
-    local tests=(
-        "test_cfn_loop_retry_integration"
-        "test_dlq_capture_during_orchestration"
-        "test_config_loading"
-    )
-
-    for test in "${tests[@]}"; do
-        if $test; then
-            ((passed++))
-        fi
-    done
-
-    # Compute and report confidence
-    report_test_results "redis-phase1-1760875302" "tester-1" "$passed" "$total_tests"
-
-    # Return pass/fail
-    [ $passed -eq $total_tests ]
-}
-
-main

package/.claude/skills/redis-coordination/tests/retry-mechanism-test.sh

@@ -1,82 +0,0 @@
-#!/bin/bash
-# Retry Mechanism Test Suite
-# Validates retry logic, backoff, and timeout behavior
-
-set -euo pipefail
-
-# Source common test utilities
-source "$(dirname "$0")/test-utils.sh"
-
-# Test retry mechanism with different retry counts
-test_retry_mechanism() {
-    local retry_counts=(0 1 3 5)
-    local base_backoff=2  # Base backoff in seconds
-
-    for retries in "${retry_counts[@]}"; do
-        echo "Testing retry mechanism with $retries retries"
-
-        # Simulated failure function
-        mock_failed_operation() {
-            local attempt=1
-            local max_attempts=$((retries + 1))
-
-            while [ $attempt -le $max_attempts ]; do
-                if [ $attempt -eq $max_attempts ]; then
-                    echo "Final attempt failed"
-                    return 1
-                fi
-
-                # Simulate failure
-                echo "Attempt $attempt failed, will retry"
-                sleep $((base_backoff ** attempt))
-                ((attempt++))
-            done
-        }
-
-        # Capture timing and retry logs
-        local start_time=$(date +%s)
-        local log_file="/tmp/retry-test-$retries.log"
-
-        if ! mock_failed_operation 2>"$log_file"; then
-            local end_time=$(date +%s)
-            local total_time=$((end_time - start_time))
-
-            # Validate retry count and timing
-            local actual_retries=$(($(grep -c "Attempt" "$log_file") - 1))
-            assert_equal "$actual_retries" "$retries" "Retry count mismatch for $retries retries"
-
-            # Validate exponential backoff (roughly)
-            local expected_max_wait=$((base_backoff ** (retries + 1)))
-            assert "[ $total_time -le $((expected_max_wait + 5)) ]" "Backoff timing incorrect"
-        else
-            fail "Operation should have failed after $retries retries"
-        fi
-
-        # Clean up log
-        rm "$log_file"
-    done
-}
-
-# Test timeout behavior
-test_timeout_behavior() {
-    local timeout_duration=10  # 10 seconds
-    local long_running_operation() {
-        sleep 15  # Longer than timeout
-    }
-
-    local start_time=$(date +%s)
-    timeout $timeout_duration long_running_operation || true
-    local end_time=$(date +%s)
-
-    local total_time=$((end_time - start_time))
-    assert "[ $total_time -ge $timeout_duration ] && [ $total_time -le $((timeout_duration + 2)) ]" "Timeout not enforced correctly"
-}
-
-# Run tests
-main() {
-    test_retry_mechanism
-    test_timeout_behavior
-    echo "Retry Mechanism Tests: PASSED"
-}
-
-main

package/.claude/skills/redis-coordination/tests/run-test-suite.sh

@@ -1,92 +0,0 @@
-#!/bin/bash
-# Master Test Runner for Redis Phase 1 Error Recovery & Resilience
-
-set -euo pipefail
-
-# Source test utilities
-source "$(dirname "$0")/test-utils.sh"
-
-# Test suites to run
-test_suites=(
-    "./retry-mechanism-test.sh"
-    "./dlq-functionality-test.sh"
-    "./edge-cases-test.sh"
-    "./integration-test.sh"
-)
-
-# Global tracking
-total_tests=0
-passed_tests=0
-failed_test_suites=()
-
-# Run individual test suite
-run_test_suite() {
-    local suite_path="$1"
-    local suite_name=$(basename "$suite_path")
-
-    echo "Running test suite: $suite_name"
-
-    set +e  # Disable immediate exit on error
-    "$suite_path"
-    local exit_code=$?
-    set -e
-
-    if [ $exit_code -eq 0 ]; then
-        ((passed_tests++))
-        echo "✅ $suite_name: PASSED"
-    else
-        failed_test_suites+=("$suite_name")
-        echo "❌ $suite_name: FAILED"
-    fi
-
-    ((total_tests++))
-}
-
-# Main execution
-main() {
-    echo "Starting Redis Phase 1 Error Recovery & Resilience Test Suite"
-
-    # Run all test suites
-    for suite in "${test_suites[@]}"; do
-        chmod +x "$suite"
-        run_test_suite "$suite"
-    done
-
-    # Calculate confidence
-    local confidence=$(compute_confidence_score "$passed_tests" "$total_tests")
-
-    # Report results
-    echo -e "\n--- Test Suite Summary ---"
-    echo "Total Test Suites: $total_tests"
-    echo "Passed: $passed_tests"
-    echo "Failed: $((total_tests - passed_tests))"
-    echo "Confidence Score: $confidence"
-
-    if [ ${#failed_test_suites[@]} -gt 0 ]; then
-        echo -e "\nFailed Test Suites:"
-        for failed_suite in "${failed_test_suites[@]}"; do
-            echo "  - $failed_suite"
-        done
-    fi
-
-    # CFN Loop reporting
-    ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-        --task-id "redis-phase1-1760875302" \
-        --agent-id "tester-1" \
-        --confidence "$confidence" \
-        --iteration 1
-
-    # Signal test completion
-    redis-cli lpush "swarm:redis-phase1-1760875302:tester-1:done" "complete"
-
-    # Enter waiting mode
-    ./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-        --task-id "redis-phase1-1760875302" \
-        --agent-id "tester-1" \
-        --context "phase1-testing-complete"
-
-    # Ensure exit code reflects overall test success
-    [ $passed_tests -eq $total_tests ]
-}
-
-main