claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/redis/invoke-waiting-mode.sh.backup

@@ -1,225 +0,0 @@
-#!/bin/bash
-#
-# Invoke Waiting Mode - Agent Coordination for CFN Loop
-# Purpose: Handle coordination between agents using waiting mode and collection
-# Usage: invoke-waiting-mode.sh <collect|wait|signal> [task-id] [agent-id] [timeout]
-#
-
-set -euo pipefail
-
-# Source centralized Redis functions (provides graceful fallback for Task mode)
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/redis-functions.sh"
-
-REDIS_COORD_SKILL="$SCRIPT_DIR"
-
-# Parse arguments
-COMMAND=${1:-"collect"}
-TASK_ID=${2:-""}
-AGENT_ID=${3:-""}
-TIMEOUT=${4:-120}
-
-# Redis configuration
-# Support both REDIS_HOST and CFN_REDIS_HOST (TypeScript uses CFN_REDIS_HOST)
-REDIS_HOST=${CFN_REDIS_HOST:-${REDIS_HOST:-"localhost"}}
-REDIS_PORT=${CFN_REDIS_PORT:-${REDIS_PORT:-6379}}
-REDIS_DB=${REDIS_DB:-0}
-
-# Debug output
-DEBUG=${DEBUG:-false}
-if [[ "$DEBUG" == "true" ]]; then
-    echo "DEBUG: invoke-waiting-mode called with: $*" >&2
-    echo "DEBUG: REDIS_HOST=$REDIS_HOST, REDIS_PORT=$REDIS_PORT, REDIS_DB=$REDIS_DB" >&2
-fi
-
-# Function to connect to Redis with error handling
-redis_cmd() {
-    local cmd="$1"
-    shift
-
-    if command -v redis-cli >/dev/null 2>&1; then
-        redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -n "$REDIS_DB" "$cmd" "$@" 2>/dev/null
-    else
-        echo "Warning: redis-cli not available, using mock mode" >&2
-        return 0
-    fi
-}
-
-# Function to collect agent signals
-collect_signals() {
-    local task_id="$1"
-    local agent_type="$2"
-    local timeout="${3:-120}"
-
-    echo "📡 Collecting ${agent_type} signals for task: $task_id (timeout: ${timeout}s)" >&2
-
-    local signals_key="swarm:${task_id}:signals:${agent_type}"
-    local start_time=$(date +%s)
-    local signals_collected=()
-
-    while true; do
-        # Get all available signals
-        local signals=($(redis_cmd SMEMBERS "$signals_key" 2>/dev/null || echo ""))
-
-        if [[ ${#signals[@]} -gt 0 ]]; then
-            for signal in "${signals[@]}"; do
-                if [[ ! " ${signals_collected[@]} " =~ " ${signal} " ]]; then
-                    signals_collected+=("$signal")
-                    echo "  ✓ Signal collected: $signal" >&2
-
-                    # Get detailed signal data
-                    local signal_key="swarm:${task_id}:agent:${signal}:data"
-                    local signal_data=$(redis_cmd HGETALL "$signal_key" 2>/dev/null || echo "")
-
-                    if [[ -n "$signal_data" ]]; then
-                        echo "    Data: $signal_data" >&2
-                    fi
-                fi
-            done
-        fi
-
-        # Check if we have all expected signals (this would be based on agent count)
-        local expected_signals=${EXPECTED_AGENTS:-1}
-        if [[ ${#signals_collected[@]} -ge $expected_signals ]]; then
-            echo "✅ All signals collected" >&2
-            break
-        fi
-
-        # Check timeout
-        local current_time=$(date +%s)
-        if [[ $((current_time - start_time)) -ge $timeout ]]; then
-            echo "⚠️ Timeout reached, proceeding with collected signals" >&2
-            break
-        fi
-
-        sleep 2
-    done
-
-    # Return collected signals as JSON
-    local json_output="{"
-    json_output+="\"task_id\":\"$task_id\","
-    json_output+="\"agent_type\":\"$agent_type\","
-    json_output+="\"signals\":["
-
-    for i in "${!signals_collected[@]}"; do
-        if [[ $i -gt 0 ]]; then
-            json_output+=","
-        fi
-        json_output+='"'"${signals_collected[$i]}"'"'
-    done
-
-    json_output+="],"
-    json_output+="\"count\":${#signals_collected[@]},"
-    json_output+="\"timeout\":$timeout"
-    json_output+="}"
-
-    echo "$json_output"
-}
-
-# Function to wait for specific condition
-wait_for_signal() {
-    local task_id="$1"
-    local condition="$2"
-    local timeout="${3:-120}"
-
-    echo "⏳ Waiting for signal: $condition (timeout: ${timeout}s)" >&2
-
-    local start_time=$(date +%s)
-    local condition_key="swarm:${task_id}:condition:${condition}"
-
-    while true; do
-        local condition_met=$(redis_cmd GET "$condition_key" 2>/dev/null || echo "")
-
-        if [[ "$condition_met" == "true" ]]; then
-            echo "✅ Condition met: $condition" >&2
-            redis_cmd DEL "$condition_key" 2>/dev/null
-            echo "true"
-            return 0
-        fi
-
-        # Check timeout
-        local current_time=$(date +%s)
-        if [[ $((current_time - start_time)) -ge $timeout ]]; then
-            echo "⚠️ Timeout waiting for: $condition" >&2
-            echo "false"
-            return 1
-        fi
-
-        sleep 2
-    done
-}
-
-# Function to signal completion
-signal_completion() {
-    local task_id="$1"
-    local agent_id="$2"
-    local status="${3:-complete}"
-
-    echo "📤 Signaling completion: $agent_id -> $status" >&2
-
-    # Add to completed set
-    redis_cmd SADD "swarm:${task_id}:completed" "$agent_id" 2>/dev/null || true
-
-    # Set completion status
-    redis_cmd HSET "swarm:${task_id}:agent:${agent_id}:status" "status" "$status" 2>/dev/null || true
-    redis_cmd HSET "swarm:${task_id}:agent:${agent_id}:status" "completed_at" "$(date +%s)" 2>/dev/null || true
-
-    # Broadcast completion signal
-    redis_cmd PUBLISH "swarm:${task_id}:signals" "agent:$agent_id:status:$status" 2>/dev/null || true
-
-    echo "✅ Signal sent: $agent_id completed"
-}
-
-# Main command routing
-case "$COMMAND" in
-    "collect")
-        if [[ -z "$TASK_ID" ]]; then
-            echo "Error: collect command requires task-id" >&2
-            echo "Usage: $0 collect <task-id> <agent-type> [timeout]" >&2
-            exit 1
-        fi
-        collect_signals "$TASK_ID" "${AGENT_ID:-"loop3"}" "$TIMEOUT"
-        ;;
-    "wait")
-        if [[ -z "$TASK_ID" ]] || [[ -z "$AGENT_ID" ]]; then
-            echo "Error: wait command requires task-id and condition" >&2
-            echo "Usage: $0 wait <task-id> <condition> [timeout]" >&2
-            exit 1
-        fi
-        wait_for_signal "$TASK_ID" "$AGENT_ID" "$TIMEOUT"
-        ;;
-    "signal")
-        if [[ -z "$TASK_ID" ]] || [[ -z "$AGENT_ID" ]]; then
-            echo "Error: signal command requires task-id and agent-id" >&2
-            echo "Usage: $0 signal <task-id> <agent-id> [status]" >&2
-            exit 1
-        fi
-        signal_completion "$TASK_ID" "$AGENT_ID" "$TIMEOUT"
-        ;;
-    "help"|"-h"|"--help")
-        cat <<EOF
-Usage: $0 <command> [arguments]
-
-Commands:
-  collect <task-id> <agent-type> [timeout]   Collect signals from agents
-  wait <task-id> <condition> [timeout]       Wait for condition to be met
-  signal <task-id> <agent-id> [status]       Signal agent completion
-
-Examples:
-  $0 collect cfn-cli-12345 loop3 300
-  $0 wait cfn-cli-12345 gate-passed 60
-  $0 signal cfn-cli-12345 backend-developer-1 complete
-
-Environment Variables:
-  REDIS_HOST    Redis host (default: localhost)
-  REDIS_PORT    Redis port (default: 6379)
-  REDIS_DB      Redis database (default: 0)
-  DEBUG         Enable debug output (true/false)
-EOF
-        ;;
-    *)
-        echo "Error: Unknown command '$COMMAND'" >&2
-        echo "Use '$0 help' for usage information" >&2
-        exit 1
-        ;;
-esac

package/claude-assets/skills/cfn-memory-persistence/lib/redis/redis-cli-wrapper.sh.backup

@@ -1,43 +0,0 @@
-#!/bin/bash
-# Wrapper for redis-cli with graceful fallback for Task mode
-# Enforces environment variable usage and handles Redis unavailability
-#
-# ANTI-023 Memory Leak Protection:
-# - Task mode: Redis unavailable → soft fail (exit 0)
-# - CLI/Docker mode: Redis available → normal execution
-set -euo pipefail
-
-REDIS_HOST="${REDIS_HOST:-localhost}"
-REDIS_PORT="${REDIS_PORT:-6379}"
-REDIS_PASSWORD="${REDIS_PASSWORD:-${CFN_REDIS_PASSWORD:-}}"  # Support both env vars
-
-# Smart AUTH detection - test Redis connectivity and auth requirements
-AUTH_ARGS=()
-
-# First, test if Redis is reachable at all (no auth)
-if timeout 1 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping &>/dev/null; then
-    # Redis accepts no-auth connections - use it directly
-    AUTH_ARGS=()
-elif [ -n "$REDIS_PASSWORD" ]; then
-    # Redis rejected no-auth, try with password
-    AUTH_ARGS=("-a" "$REDIS_PASSWORD")
-    if ! timeout 1 redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" "${AUTH_ARGS[@]}" ping &>/dev/null; then
-        # Password provided but AUTH failed - likely wrong password or Redis down
-        # Treat as unavailable (soft fail for Task mode compatibility)
-        echo "⚠️ Redis unavailable - command skipped (soft fail)" >&2
-        echo "💡 This is expected in Task mode (Main Chat coordination)" >&2
-        echo "🔧 Agents should output JSON directly instead of Redis coordination" >&2
-        exit 0  # Soft fail - don't break agent execution
-    fi
-    # Auth successful with password
-else
-    # Redis requires auth but no password provided, OR Redis is completely down
-    # Treat as unavailable (soft fail for Task mode compatibility)
-    echo "⚠️ Redis unavailable - command skipped (soft fail)" >&2
-    echo "💡 This is expected in Task mode (Main Chat coordination)" >&2
-    echo "🔧 Agents should output JSON directly instead of Redis coordination" >&2
-    exit 0  # Soft fail - don't break agent execution
-fi
-
-# Redis available and auth validated (if needed) - execute command normally
-exec redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" "${AUTH_ARGS[@]}" "$@"

package/claude-assets/skills/cfn-memory-persistence/lib/redis/redis-functions.sh.backup

@@ -1,34 +0,0 @@
-#!/bin/bash
-# Centralized Redis functions for CFN Loop coordination
-# Source this file in coordination scripts to get graceful Redis fallback
-#
-# Usage:
-#   source ./.claude/skills/cfn-redis-coordination/redis-functions.sh
-#   redis-cli LPUSH "key" "value"  # Automatically uses wrapper with fallback
-#
-# ANTI-023 Memory Leak Protection:
-# All redis-cli calls automatically fail gracefully in Task mode
-
-# Get the directory where this script is located
-REDIS_FUNCTIONS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Override redis-cli to always use the wrapper
-redis-cli() {
-    "${REDIS_FUNCTIONS_DIR}/redis-cli-wrapper.sh" "$@"
-}
-
-# Export the function so it's available in subshells
-export -f redis-cli
-
-# Optional: Set Redis connection defaults
-# Support both REDIS_HOST and CFN_REDIS_HOST (TypeScript uses CFN_REDIS_HOST)
-export REDIS_HOST="${CFN_REDIS_HOST:-${REDIS_HOST:-localhost}}"
-export REDIS_PORT="${CFN_REDIS_PORT:-${REDIS_PORT:-6379}}"
-
-# Helper: Check if Redis is available (useful for conditional logic)
-is_redis_available() {
-    timeout 1 "${REDIS_FUNCTIONS_DIR}/redis-cli-wrapper.sh" ping &>/dev/null
-    return $?
-}
-
-export -f is_redis_available

package/claude-assets/skills/cfn-memory-persistence/lib/redis/report-completion.sh.backup

@@ -1,134 +0,0 @@
-#!/bin/bash
-# Report agent completion and confidence to Redis
-# Replaces deprecated invoke-waiting-mode.sh for CFN Loop coordination
-#
-# Usage:
-#   report-completion.sh --task-id <id> --agent-id <id> --confidence <0.0-1.0>
-#                        [--iteration <n>] [--namespace <ns>] [--result <json>]
-#                        [--test-pass-rate <pct>] [--tests-run <n>] [--tests-passed <n>]
-
-set -euo pipefail
-
-# Source centralized Redis functions (provides graceful fallback for Task mode)
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/redis-functions.sh"
-
-# Parse arguments
-TASK_ID=""
-AGENT_ID=""
-CONFIDENCE=""
-RESULT=""
-ITERATION="1"
-NAMESPACE="swarm"
-TEST_PASS_RATE=""
-TESTS_RUN=""
-TESTS_PASSED=""
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --confidence)
-            CONFIDENCE="$2"
-            shift 2
-            ;;
-        --result)
-            RESULT="$2"
-            shift 2
-            ;;
-        --iteration)
-            ITERATION="$2"
-            shift 2
-            ;;
-        --namespace)
-            NAMESPACE="$2"
-            shift 2
-            ;;
-        --test-pass-rate)
-            TEST_PASS_RATE="$2"
-            shift 2
-            ;;
-        --tests-run)
-            TESTS_RUN="$2"
-            shift 2
-            ;;
-        --tests-passed)
-            TESTS_PASSED="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown option: $1" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# Validate required parameters
-# Note: redis-cli calls use wrapper from redis-functions.sh (sourced above)
-# Wrapper provides graceful Task mode fallback when Redis unavailable
-if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONFIDENCE" ]; then
-    echo "Error: Missing required parameters" >&2
-    echo "Usage: $0 --task-id <id> --agent-id <id> --confidence <0.0-1.0>" >&2
-    echo "       [--iteration <n>] [--namespace <ns>] [--result <json>]" >&2
-    echo "       [--test-pass-rate <pct>] [--tests-run <n>] [--tests-passed <n>]" >&2
-    exit 1
-fi
-
-# Validate confidence range
-if ! awk -v conf="$CONFIDENCE" 'BEGIN { if (conf < 0 || conf > 1) exit 1 }'; then
-    echo "Error: Confidence must be between 0.0 and 1.0" >&2
-    exit 1
-fi
-
-# OPTIMIZATION: Batch all Redis operations into single pipeline
-# Use MULTI/EXEC for atomic transaction with reduced network round-trips (3-4 calls → 1)
-# Measured improvement: ~62% coordination overhead reduction in standard mode
-{
-    echo "MULTI"
-    echo "LPUSH ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:done complete"
-    echo "SET ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:confidence $CONFIDENCE EX 3600"
-
-    # Build result hash with test metrics if provided
-    RESULT_HASH_ARGS="confidence $CONFIDENCE iteration $ITERATION"
-
-    if [ -n "$RESULT" ]; then
-        RESULT_HASH_ARGS="$RESULT_HASH_ARGS result $RESULT"
-    fi
-
-    if [ -n "$TEST_PASS_RATE" ]; then
-        RESULT_HASH_ARGS="$RESULT_HASH_ARGS test_pass_rate $TEST_PASS_RATE"
-    fi
-
-    if [ -n "$TESTS_RUN" ]; then
-        RESULT_HASH_ARGS="$RESULT_HASH_ARGS tests_run $TESTS_RUN"
-    fi
-
-    if [ -n "$TESTS_PASSED" ]; then
-        RESULT_HASH_ARGS="$RESULT_HASH_ARGS tests_passed $TESTS_PASSED"
-    fi
-
-    RESULT_HASH_ARGS="$RESULT_HASH_ARGS timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
-
-    echo "HSET ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:result $RESULT_HASH_ARGS"
-
-    echo "EXEC"
-} | redis-cli > /dev/null
-
-# Step 4: Add to agent completion list (for orchestrator tracking)
-redis-cli LPUSH "${NAMESPACE}:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
-
-# Step 5: Set TTL on keys (auto-cleanup)
-redis-cli EXPIRE "${NAMESPACE}:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
-redis-cli EXPIRE "${NAMESPACE}:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
-
-echo "✅ Reported completion for agent: $AGENT_ID (confidence: $CONFIDENCE)"
-if [ -n "$TEST_PASS_RATE" ]; then
-    echo "   Test pass rate: $TEST_PASS_RATE%"
-fi
-exit 0

package/claude-assets/skills/cfn-memory-persistence/lib/redis/store-context.sh.backup

@@ -1,123 +0,0 @@
-#!/bin/bash
-# Store CFN Loop task context in Redis
-# Used by orchestrator to pass structured context to CLI-spawned agents
-#
-# Usage:
-#   store-context.sh --task-id <id> --key <key> --value <value> [--namespace <ns>]
-#   store-context.sh --task-id <id> --epic <epic> --mode <mode> [--namespace <ns>]
-#   store-context.sh <task_id> <context_json> (legacy mode)
-
-set -euo pipefail
-
-# Source centralized Redis functions (provides graceful fallback for Task mode)
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/redis-functions.sh"
-
-# Initialize variables
-TASK_ID=""
-KEY=""
-VALUE=""
-NAMESPACE="swarm"
-CONTEXT=""
-EPIC=""
-MODE=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --key)
-      KEY="$2"
-      shift 2
-      ;;
-    --value)
-      VALUE="$2"
-      shift 2
-      ;;
-    --namespace)
-      NAMESPACE="$2"
-      shift 2
-      ;;
-    --epic)
-      EPIC="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      shift 2
-      ;;
-    *)
-      # Legacy mode: positional arguments
-      if [ -z "$TASK_ID" ]; then
-        TASK_ID="$1"
-      elif [ -z "$CONTEXT" ]; then
-        CONTEXT="$1"
-      fi
-      shift
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [ -z "$TASK_ID" ]; then
-    echo "Error: --task-id or TASK_ID required" >&2
-    echo "Usage: $0 --task-id <id> --key <key> --value <value> [--namespace <ns>]" >&2
-    echo "   or: $0 --task-id <id> --epic <epic> --mode <mode> [--namespace <ns>]" >&2
-    echo "   or: $0 <task_id> <context_json> (legacy)" >&2
-    exit 1
-fi
-
-# Handle epic+mode mode (new)
-if [ -n "$EPIC" ] && [ -n "$MODE" ]; then
-  # Store epic and mode with task context
-  REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
-
-  redis-cli HSET "$REDIS_KEY" \
-      "epic" "$EPIC" \
-      "mode" "$MODE" \
-      "updated_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-      > /dev/null
-
-  # Set TTL (24 hours)
-  redis-cli EXPIRE "$REDIS_KEY" 86400 > /dev/null
-
-  echo "✅ Context stored: epic=$EPIC, mode=$MODE for task: $TASK_ID"
-  exit 0
-fi
-
-# Handle structured mode (new)
-if [ -n "$KEY" ] && [ -n "$VALUE" ]; then
-  # Store structured context with specific key
-  REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
-
-  redis-cli HSET "$REDIS_KEY" \
-      "$KEY" "$VALUE" \
-      "updated_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-      > /dev/null
-
-  # Set TTL (24 hours)
-  redis-cli EXPIRE "$REDIS_KEY" 86400 > /dev/null
-
-  echo "✅ Context stored: $KEY for task: $TASK_ID"
-  exit 0
-fi
-
-# Handle legacy mode
-if [ -n "$CONTEXT" ]; then
-  redis-cli HSET "swarm:${TASK_ID}:context" \
-      "task_description" "$CONTEXT" \
-      "stored_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-      > /dev/null
-
-  # Set TTL (24 hours)
-  redis-cli EXPIRE "swarm:${TASK_ID}:context" 86400 > /dev/null
-
-  echo "✅ Context stored for task: $TASK_ID"
-  exit 0
-fi
-
-echo "Error: Either --epic/--mode, --key/--value, or <context_json> required" >&2
-exit 1