claude-flow-novice 2.14.2 → 2.14.4

package/.claude/skills/cfn-redis-coordination/invoke-redis-pattern.sh

@@ -1,220 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Version 1.3.0
-# Redis Coordination Pattern CLI
-
-# Load configuration
-CONFIG_PATH="$(dirname "$0")/config.json"
-REDIS_HOST=$(jq -r '.host' "$CONFIG_PATH")
-REDIS_PORT=$(jq -r '.port' "$CONFIG_PATH")
-REDIS_DB=$(jq -r '.db' "$CONFIG_PATH")
-
-# Utility functions
-log_error() {
-  echo "{\"status\": \"error\", \"message\": \"$1\"}" >&2
-  exit 1
-}
-
-invoke_redis_command() {
-  local command="$1"
-  shift
-  redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -n "$REDIS_DB" "$command" "$@"
-}
-
-# Waiting mode operations
-wait_mode() {
-  local task_id=""
-  local agent_id=""
-  local context=""
-
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --task-id)
-        task_id="$2"
-        shift 2
-        ;;
-      --agent-id)
-        agent_id="$2"
-        shift 2
-        ;;
-      --context)
-        context="$2"
-        shift 2
-        ;;
-      *)
-        log_error "Invalid argument for wait: $1"
-        ;;
-    esac
-  done
-
-  [[ -z "$task_id" ]] && log_error "task-id is required"
-  [[ -z "$agent_id" ]] && log_error "agent-id is required"
-
-  local wake_channel="task:$task_id:agent:$agent_id:wake"
-
-  # Blocking pop with timeout
-  result=$(invoke_redis_command BLPOP "$wake_channel" 300)
-
-  if [[ -z "$result" ]]; then
-    echo "{\"status\": \"timeout\", \"task_id\": \"$task_id\", \"agent_id\": \"$agent_id\", \"context\": \"$context\"}"
-  else
-    echo "{\"status\": \"woken\", \"task_id\": \"$task_id\", \"agent_id\": \"$agent_id\", \"payload\": $result, \"context\": \"$context\"}"
-  fi
-}
-
-wake_mode() {
-  local task_id=""
-  local agent_id=""
-  local payload=""
-
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --task-id)
-        task_id="$2"
-        shift 2
-        ;;
-      --agent-id)
-        agent_id="$2"
-        shift 2
-        ;;
-      --payload)
-        payload="$2"
-        shift 2
-        ;;
-      *)
-        log_error "Invalid argument for wake: $1"
-        ;;
-    esac
-  done
-
-  [[ -z "$task_id" ]] && log_error "task-id is required"
-  [[ -z "$agent_id" ]] && log_error "agent-id is required"
-  [[ -z "$payload" ]] && log_error "payload is required"
-
-  local wake_channel="task:$task_id:agent:$agent_id:wake"
-
-  invoke_redis_command LPUSH "$wake_channel" "$payload" > /dev/null
-
-  echo "{\"status\": \"success\", \"task_id\": \"$task_id\", \"agent_id\": \"$agent_id\"}"
-}
-
-report_mode() {
-  local task_id=""
-  local agent_id=""
-  local confidence=0.0
-  local result=""
-
-  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
-        ;;
-      *)
-        log_error "Invalid argument for report: $1"
-        ;;
-    esac
-  done
-
-  [[ -z "$task_id" ]] && log_error "task-id is required"
-  [[ -z "$agent_id" ]] && log_error "agent-id is required"
-
-  local result_key="task:$task_id:agent:$agent_id:result"
-  local result_json=$(jq -n \
-    --arg r "$result" \
-    --arg c "$confidence" \
-    '{result: $r, confidence: ($c | tonumber), timestamp: now}')
-
-  invoke_redis_command SET "$result_key" "$result_json" > /dev/null
-
-  echo "{\"status\": \"success\", \"task_id\": \"$task_id\", \"agent_id\": \"$agent_id\", \"confidence\": $confidence}"
-}
-
-collect_mode() {
-  local task_id=""
-  local agent_ids=()
-
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-      --task-id)
-        task_id="$2"
-        shift 2
-        ;;
-      --agent-ids)
-        IFS=',' read -r -a agent_ids <<< "$2"
-        shift 2
-        ;;
-      *)
-        log_error "Invalid argument for collect: $1"
-        ;;
-    esac
-  done
-
-  [[ -z "$task_id" ]] && log_error "task-id is required"
-  [[ ${#agent_ids[@]} -eq 0 ]] && log_error "agent-ids is required"
-
-  local results=()
-  local total_confidence=0.0
-  local valid_results=0
-
-  for agent_id in "${agent_ids[@]}"; do
-    local result_key="task:$task_id:agent:$agent_id:result"
-    result=$(invoke_redis_command GET "$result_key")
-
-    if [[ -n "$result" ]]; then
-      results+=("$result")
-      confidence=$(echo "$result" | jq '.confidence')
-      total_confidence=$(echo "$total_confidence + $confidence" | bc)
-      ((valid_results++))
-    fi
-  done
-
-  local avg_confidence=0.0
-  if [[ $valid_results -gt 0 ]]; then
-    avg_confidence=$(echo "scale=2; $total_confidence / $valid_results" | bc)
-  fi
-
-  local consensus_threshold="0.90"
-  local status="insufficient_consensus"
-  if (( $(echo "$avg_confidence >= $consensus_threshold" | bc -l) )); then
-    status="consensus"
-  fi
-
-  echo "{\"status\": \"$status\", \"task_id\": \"$task_id\", \"results\": $(printf '%s\n' "${results[@]}" | jq -s '.'), \"avgConfidence\": $avg_confidence, \"consensusThreshold\": $consensus_threshold}"
-}
-
-# Determine action
-case "${1:-}" in
-  wait)
-    shift
-    wait_mode "$@"
-    ;;
-  wake)
-    shift
-    wake_mode "$@"
-    ;;
-  report)
-    shift
-    report_mode "$@"
-    ;;
-  collect)
-    shift
-    collect_mode "$@"
-    ;;
-  *)
-    log_error "Usage: $0 {wait|wake|report|collect} [options]"
-    ;;
-esac

package/.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh

@@ -1,283 +0,0 @@
-#!/bin/bash
-#
-# Redis Waiting Mode CLI Wrapper for Agents
-#
-# Usage:
-#   ./invoke-waiting-mode.sh report --task-id <task> --agent-id <agent> --confidence <score> [--iteration <n>]
-#   ./invoke-waiting-mode.sh collect --task-id <task> --agent-ids <id1,id2,id3>
-#   ./invoke-waiting-mode.sh shutdown --task-id <task> [--reason <reason>]
-#
-# DEPRECATION NOTICE:
-# - 'enter' and 'wake' subcommands are DEPRECATED
-# - This script now only supports 'report', 'collect', and 'shutdown' subcommands
-# - Agents are expected to exit cleanly without waiting mode
-#
-# Priority Levels (0-100, higher = more urgent, default = 50):
-#   90-100: Critical (security patches, system failures)
-#   70-89:  High (urgent features, blocking bugs)
-#   40-60:  Medium (normal tasks, default)
-#   20-39:  Low (optimizations, refactoring)
-#   0-19:   Minimal (documentation, cleanup)
-
-set -euo pipefail
-
-# Debug mode (set DEBUG=true for verbose output)
-DEBUG="${DEBUG:-false}"
-
-# Parse command
-COMMAND="${1:-}"
-shift || true
-
-# Parse arguments
-TASK_ID=""
-AGENT_ID=""
-AGENT_IDS=""
-REASON=""
-ITERATION=""
-CONFIDENCE=""
-FEEDBACK=""
-PRIORITY=50  # Default medium priority (0-100, higher = more urgent)
-MIN_QUORUM=""  # Minimum quorum for consensus validation
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --agent-ids)
-            AGENT_IDS="$2"
-            shift 2
-            ;;
-        --reason)
-            REASON="$2"
-            shift 2
-            ;;
-        --iteration)
-            ITERATION="$2"
-            shift 2
-            ;;
-        --confidence)
-            CONFIDENCE="$2"
-            shift 2
-            ;;
-        --feedback)
-            FEEDBACK="$2"
-            shift 2
-            ;;
-        --priority)
-            PRIORITY="$2"
-            shift 2
-            ;;
-        --min-quorum)
-            MIN_QUORUM="$2"
-            shift 2
-            ;;
-        *)
-            echo "Unknown argument: $1"
-            exit 1
-            ;;
-    esac
-done
-
-case "$COMMAND" in
-    enter)
-        echo "[DEPRECATED] 'enter' subcommand is no longer supported."
-        echo "Agents should no longer use waiting mode. Exit cleanly."
-        exit 1
-        ;;
-
-    wake)
-        echo "[DEPRECATED] 'wake' subcommand is no longer supported."
-        echo "Coordinator should spawn agents directly without waiting mode."
-        exit 1
-        ;;
-
-    report)
-        if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONFIDENCE" ]; then
-            echo "Error: report requires --task-id, --agent-id, and --confidence"
-            exit 1
-        fi
-
-        RESULT_KEY="swarm:${TASK_ID}:${AGENT_ID}:result"
-
-        # Build result message with optional feedback
-        RESULT_MSG=$(jq -n \
-            --arg confidence "$CONFIDENCE" \
-            --arg iteration "${ITERATION:-0}" \
-            --arg feedback "${FEEDBACK:-}" \
-            --arg ts "$(date +%s)" \
-            '{
-                confidence: ($confidence | tonumber),
-                iteration: ($iteration | tonumber),
-                feedback: ($feedback | split(",") | map(select(length > 0))),
-                timestamp: ($ts | tonumber)
-            }')
-
-        echo "$RESULT_MSG" | redis-cli -x LPUSH "$RESULT_KEY" >/dev/null
-
-        echo "[$AGENT_ID] ✅ Result reported"
-        echo "  Confidence: $CONFIDENCE"
-        [ -n "$ITERATION" ] && echo "  Iteration: $ITERATION"
-        if [ -n "$FEEDBACK" ]; then
-            echo "  Feedback items: $(echo "$FEEDBACK" | tr ',' '\n' | wc -l)"
-        fi
-        ;;
-
-    collect)
-        if [ -z "$TASK_ID" ] || [ -z "$AGENT_IDS" ]; then
-            echo "Error: collect requires --task-id and --agent-ids" >&2
-            exit 1
-        fi
-
-        # Output verbose messages to stderr
-        echo "[Coordinator] Collecting results from agents..." >&2
-        echo "" >&2
-
-        # Split agent IDs
-        IFS=',' read -ra AGENTS <<< "$AGENT_IDS"
-
-        RESULTS=()
-        CONFIDENCES=()
-        ALL_FEEDBACK=()
-
-        for AGENT in "${AGENTS[@]}"; do
-            RESULT_KEY="swarm:${TASK_ID}:${AGENT}:result"
-
-            # Get latest result (non-blocking, non-destructive)
-            # Use LINDEX instead of LPOP to preserve results for multiple reads
-            RESULT=$(redis-cli LINDEX "$RESULT_KEY" 0)
-
-            if [ -n "$RESULT" ] && [ "$RESULT" != "(nil)" ]; then
-                # Handle both simple numeric format and JSON format
-                # Try to parse as JSON first, fall back to simple number
-                if CONF=$(echo "$RESULT" | jq -r '.confidence' 2>/dev/null) && [ "$CONF" != "null" ]; then
-                    # JSON format: {"confidence":0.85,"iteration":1,...}
-                    echo "  [$AGENT] Confidence: $CONF" >&2
-                    RESULTS+=("$RESULT")
-                    CONFIDENCES+=("$CONF")
-
-                    # Check if result includes feedback array
-                    FEEDBACK=$(echo "$RESULT" | jq -r '.feedback // empty | .[]?' 2>/dev/null)
-                    if [ -n "$FEEDBACK" ]; then
-                        echo "  [$AGENT] Feedback provided:" >&2
-                        echo "$RESULT" | jq -r '.feedback[]' | sed 's/^/    - /' >&2
-
-                        # Collect all feedback items
-                        while IFS= read -r ITEM; do
-                            ALL_FEEDBACK+=("$ITEM")
-                        done < <(echo "$RESULT" | jq -r '.feedback[]')
-                    fi
-                elif [[ "$RESULT" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-                    # Simple numeric format: "0.85"
-                    CONF="$RESULT"
-                    echo "  [$AGENT] Confidence: $CONF" >&2
-                    CONFIDENCES+=("$CONF")
-                else
-                    echo "  [$AGENT] ⚠️  Invalid result format: $RESULT" >&2
-                fi
-            else
-                echo "  [$AGENT] ⚠️  No result found" >&2
-            fi
-        done
-
-        # Validate quorum if specified
-        TOTAL_AGENTS=${#AGENTS[@]}
-        RESPONDING_AGENTS=${#CONFIDENCES[@]}
-
-        if [ -n "$MIN_QUORUM" ]; then
-            # Parse min-quorum (supports: absolute number, percentage, or decimal)
-            if [[ "$MIN_QUORUM" =~ ^[0-9]+%$ ]]; then
-                # Percentage format: "66%"
-                PCT=${MIN_QUORUM%\%}
-                REQUIRED=$(echo "scale=0; ($TOTAL_AGENTS * $PCT) / 100" | bc)
-            elif [[ "$MIN_QUORUM" =~ ^0\.[0-9]+$ ]]; then
-                # Decimal format: "0.66"
-                REQUIRED=$(echo "scale=0; ($TOTAL_AGENTS * $MIN_QUORUM) / 1" | bc)
-            else
-                # Absolute number format: "2"
-                REQUIRED=$MIN_QUORUM
-            fi
-
-            if [ "$RESPONDING_AGENTS" -lt "$REQUIRED" ]; then
-                echo "" >&2
-                echo "[Coordinator] ❌ Quorum not met" >&2
-                echo "  Required: $REQUIRED agents" >&2
-                echo "  Responding: $RESPONDING_AGENTS agents" >&2
-                exit 1
-            fi
-        fi
-
-        # Calculate consensus
-        if [ ${#CONFIDENCES[@]} -gt 0 ]; then
-            SUM=0
-            for CONF in "${CONFIDENCES[@]}"; do
-                SUM=$(echo "$SUM + $CONF" | bc)
-            done
-            COUNT=${#CONFIDENCES[@]}
-            CONSENSUS=$(echo "scale=2; $SUM / $COUNT" | bc)
-
-            # Ensure leading zero for bc output (handles .87 -> 0.87)
-            if [[ "$CONSENSUS" =~ ^\. ]]; then
-                CONSENSUS="0$CONSENSUS"
-            fi
-
-            echo "" >&2
-            echo "[Coordinator] Consensus: $CONSENSUS" >&2
-
-            # Print aggregated feedback if available
-            if [ ${#ALL_FEEDBACK[@]} -gt 0 ]; then
-                echo "[Coordinator] Aggregated Feedback (${#ALL_FEEDBACK[@]} items):" >&2
-                printf '%s\n' "${ALL_FEEDBACK[@]}" | sort -u | sed 's/^/  - /' >&2
-            fi
-
-            # Output only consensus value to stdout for callers
-            echo "$CONSENSUS"
-        else
-            echo "" >&2
-            echo "[Coordinator] No results to calculate consensus" >&2
-            echo "0.0"
-        fi
-        ;;
-
-    shutdown)
-        if [ -z "$TASK_ID" ]; then
-            echo "Error: shutdown requires --task-id"
-            exit 1
-        fi
-
-        SHUTDOWN_KEY="swarm:${TASK_ID}:shutdown"
-
-        # Build shutdown message
-        SHUTDOWN_MSG=$(jq -n \
-            --arg reason "${REASON:-task_complete}" \
-            --arg ts "$(date +%s)" \
-            '{
-                reason: $reason,
-                timestamp: ($ts | tonumber)
-            }')
-
-        # Broadcast shutdown signal
-        echo "$SHUTDOWN_MSG" | redis-cli -x LPUSH "$SHUTDOWN_KEY" >/dev/null
-
-        echo "[Coordinator] 🛑 Shutdown signal broadcasted"
-        echo "  Task ID: $TASK_ID"
-        echo "  Reason: ${REASON:-task_complete}"
-        ;;
-
-    *)
-        echo "Usage: $0 <command> [options]"
-        echo ""
-        echo "Commands:"
-        echo "  report   - Agent reports result"
-        echo "  collect  - Coordinator collects results"
-        echo "  shutdown - Coordinator broadcasts shutdown signal"
-        echo ""
-        echo "Note: 'enter' and 'wake' subcommands are DEPRECATED"
-        exit 1
-        ;;
-esac

package/.claude/skills/cfn-redis-coordination/list-active-swarms.sh

@@ -1,147 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# List Active Swarms - Redis Coordination
-#
-# Queries Redis for all active swarm metadata to help track multiple
-# concurrent CFN Loop sessions.
-#
-# Usage:
-#   ./list-active-swarms.sh [--task-id <id>] [--mode <mode>] [--json]
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-TASK_ID_FILTER=""
-MODE_FILTER=""
-JSON_OUTPUT=false
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID_FILTER="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE_FILTER="$2"
-      shift 2
-      ;;
-    --json)
-      JSON_OUTPUT=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      echo "Usage: $0 [--task-id <id>] [--mode <mode>] [--json]"
-      exit 1
-      ;;
-  esac
-done
-
-# Get all swarm metadata keys
-SWARM_KEYS=$(redis-cli --scan --pattern "swarm:*:metadata" 2>/dev/null || echo "")
-
-if [ -z "$SWARM_KEYS" ]; then
-  if [ "$JSON_OUTPUT" = true ]; then
-    echo '{"swarms": [], "count": 0}'
-  else
-    echo "No active swarms found"
-  fi
-  exit 0
-fi
-
-# Initialize JSON array
-if [ "$JSON_OUTPUT" = true ]; then
-  echo '{"swarms": ['
-  FIRST=true
-fi
-
-# Process each swarm
-while IFS= read -r KEY; do
-  if [ -z "$KEY" ]; then
-    continue
-  fi
-
-  # Extract swarm ID from key (swarm:swarm-<task-id>:metadata)
-  SWARM_ID=$(echo "$KEY" | sed 's/swarm:\(.*\):metadata/\1/')
-
-  # Get metadata
-  TASK_ID=$(redis-cli hget "$KEY" task_id 2>/dev/null || echo "")
-  MODE=$(redis-cli hget "$KEY" mode 2>/dev/null || echo "")
-  MAX_AGENTS=$(redis-cli hget "$KEY" max_agents 2>/dev/null || echo "")
-  LOOP3_AGENTS=$(redis-cli hget "$KEY" loop3_agents 2>/dev/null || echo "")
-  LOOP2_AGENTS=$(redis-cli hget "$KEY" loop2_agents 2>/dev/null || echo "")
-  PRODUCT_OWNER=$(redis-cli hget "$KEY" product_owner 2>/dev/null || echo "")
-  CREATED_AT=$(redis-cli hget "$KEY" created_at 2>/dev/null || echo "")
-  STATUS=$(redis-cli hget "$KEY" status 2>/dev/null || echo "in_progress")
-  FINAL_CONSENSUS=$(redis-cli hget "$KEY" final_consensus 2>/dev/null || echo "")
-  TOTAL_ITERATIONS=$(redis-cli hget "$KEY" total_iterations 2>/dev/null || echo "")
-  COMPLETED_AT=$(redis-cli hget "$KEY" completed_at 2>/dev/null || echo "")
-
-  # Apply filters
-  if [ -n "$TASK_ID_FILTER" ] && [ "$TASK_ID" != "$TASK_ID_FILTER" ]; then
-    continue
-  fi
-
-  if [ -n "$MODE_FILTER" ] && [ "$MODE" != "$MODE_FILTER" ]; then
-    continue
-  fi
-
-  # Output
-  if [ "$JSON_OUTPUT" = true ]; then
-    if [ "$FIRST" = false ]; then
-      echo ","
-    fi
-    FIRST=false
-
-    cat <<EOF
-  {
-    "swarm_id": "$SWARM_ID",
-    "task_id": "$TASK_ID",
-    "mode": "$MODE",
-    "status": "$STATUS",
-    "max_agents": $MAX_AGENTS,
-    "loop3_agents": "$LOOP3_AGENTS",
-    "loop2_agents": "$LOOP2_AGENTS",
-    "product_owner": "$PRODUCT_OWNER",
-    "created_at": "$CREATED_AT",
-    "final_consensus": "$FINAL_CONSENSUS",
-    "total_iterations": "$TOTAL_ITERATIONS",
-    "completed_at": "$COMPLETED_AT"
-  }
-EOF
-  else
-    echo "========================================="
-    echo "Swarm ID: $SWARM_ID"
-    echo "Task ID: $TASK_ID"
-    echo "Mode: $MODE"
-    echo "Status: $STATUS"
-    echo "Agents: $MAX_AGENTS total"
-    echo "  Loop 3: $LOOP3_AGENTS"
-    echo "  Loop 2: $LOOP2_AGENTS"
-    echo "  Product Owner: $PRODUCT_OWNER"
-    echo "Created: $CREATED_AT"
-
-    if [ -n "$COMPLETED_AT" ]; then
-      echo "Completed: $COMPLETED_AT"
-      echo "Final Consensus: $FINAL_CONSENSUS"
-      echo "Total Iterations: $TOTAL_ITERATIONS"
-    fi
-
-    echo ""
-  fi
-
-done <<< "$SWARM_KEYS"
-
-# Close JSON array
-if [ "$JSON_OUTPUT" = true ]; then
-  echo ""
-  echo "],"
-
-  # Count swarms
-  COUNT=$(echo "$SWARM_KEYS" | wc -l)
-  echo "\"count\": $COUNT"
-  echo "}"
-fi