claude-flow-novice 2.9.0 → 2.10.0

package/.claude/skills/cfn-redis-coordination/heartbeat.sh

@@ -0,0 +1,126 @@
+#!/bin/bash
+
+# Heartbeat Monitoring Script for Agent Coordination
+# Implements 60s TTL, 30s check interval, and quorum fallback detection
+
+# Dependencies
+REDIS_CLI=$(which redis-cli)
+if [ -z "$REDIS_CLI" ]; then
+    echo "Error: redis-cli not found. Please install Redis client."
+    exit 1
+fi
+
+# Logging configuration
+LOG_FILE="/tmp/heartbeat-debug.log"
+touch "$LOG_FILE"
+
+log_debug() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
+}
+
+# Configuration
+HEARTBEAT_TTL=60  # 60 seconds TTL
+CHECK_INTERVAL=30  # 30 seconds between checks
+MISSED_THRESHOLD=2  # Number of missed heartbeats before considering agent hung
+BUFFER_TIME=3      # Additional buffer time for timing flexibility
+
+send_heartbeat() {
+    local task_id="$1"
+    local agent_id="$2"
+
+    if [ -z "$task_id" ] || [ -z "$agent_id" ]; then
+        echo "Usage: $0 send --task-id TASK_ID --agent-id AGENT_ID"
+        exit 1
+    fi
+
+    log_debug "Sending heartbeat for task=$task_id, agent=$agent_id"
+
+    # Use SETEX to create a key with expiration
+    $REDIS_CLI SETEX "swarm:agent_status:${task_id}:${agent_id}" "$HEARTBEAT_TTL" "alive"
+    echo "Heartbeat sent for agent ${agent_id} in task ${task_id}"
+}
+
+check_heartbeat() {
+    local task_id="$1"
+    local agent_id="$2"
+
+    if [ -z "$task_id" ] || [ -z "$agent_id" ]; then
+        echo "Usage: $0 check --task-id TASK_ID --agent-id AGENT_ID"
+        exit 1
+    fi
+
+    local key="swarm:agent_status:${task_id}:${agent_id}"
+    local status
+    local ttl
+
+    # Retrieve status and TTL
+    status=$($REDIS_CLI GET "$key")
+    ttl=$($REDIS_CLI TTL "$key")
+
+    log_debug "Checking heartbeat for task=$task_id, agent=$agent_id: status=$status, ttl=$ttl"
+
+    # Check for key existence and status
+    if [ -z "$status" ] || [ "$ttl" -le 0 ]; then
+        log_debug "Heartbeat DEAD: status missing or expired"
+        echo "dead"
+        increment_missed_counter "$task_id" "$agent_id"
+        return 1
+    else
+        log_debug "Heartbeat ALIVE: status=$status, ttl=$ttl"
+        echo "alive"
+        return 0
+    fi
+}
+
+increment_missed_counter() {
+    local task_id="$1"
+    local agent_id="$2"
+    local missed_key="swarm:missed_heartbeats:${task_id}:${agent_id}"
+
+    # Increment missed heartbeat counter
+    local missed_count=$($REDIS_CLI INCR "$missed_key")
+
+    # Set expiry for missed counter to match heartbeat TTL
+    $REDIS_CLI EXPIRE "$missed_key" $HEARTBEAT_TTL
+
+    log_debug "Missed heartbeat counter for task=$task_id, agent=$agent_id: count=$missed_count"
+
+    if [ "$missed_count" -ge "$MISSED_THRESHOLD" ]; then
+        # Trigger quorum fallback mechanism
+        $REDIS_CLI LPUSH "swarm:${task_id}:quorum_fallback" "$agent_id"
+        log_debug "QUORUM FALLBACK: Agent $agent_id missed $missed_count heartbeats"
+        echo "WARN: Agent $agent_id missed $missed_count heartbeats. Quorum fallback triggered."
+    fi
+}
+
+# Parse arguments
+case "$1" in
+    send)
+        shift
+        while [[ "$#" -gt 0 ]]; do
+            case $1 in
+                --task-id) task_id="$2"; shift ;;
+                --agent-id) agent_id="$2"; shift ;;
+                *) echo "Unknown parameter passed: $1"; exit 1 ;;
+            esac
+            shift
+        done
+        send_heartbeat "$task_id" "$agent_id"
+        ;;
+    check)
+        shift
+        while [[ "$#" -gt 0 ]]; do
+            case $1 in
+                --task-id) task_id="$2"; shift ;;
+                --agent-id) agent_id="$2"; shift ;;
+                *) echo "Unknown parameter passed: $1"; exit 1 ;;
+            esac
+            shift
+        done
+        check_heartbeat "$task_id" "$agent_id"
+        ;;
+    *)
+        echo "Usage: $0 {send|check} --task-id TASK_ID --agent-id AGENT_ID"
+        exit 1
+        ;;
+esac

package/.claude/skills/cfn-redis-coordination/init-swarm.sh

@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Initialize Swarm - Redis Coordination Primitive
+#
+# Creates swarm metadata in Redis for coordination tracking across any
+# multi-agent workflow (CFN Loop, independent swarms, custom orchestration).
+#
+# Usage:
+#   ./init-swarm.sh --swarm-id <id> \
+#                   --agents <agent1,agent2,...> \
+#                   [--task-id <id>] \
+#                   [--topology <mesh|hierarchical|chain>] \
+#                   [--ttl <seconds>] \
+#                   [--metadata <json-string>]
+#
+# Per-Agent Timeout Configuration:
+#   Agents can have custom timeout values set via Redis:
+#
+#   redis-cli SETEX "swarm:<task-id>:<agent-id>:timeout" 86400 <timeout-seconds>
+#
+#   If no custom timeout is set, the orchestrator will use role-based defaults:
+#   - researcher: 7200s (2 hours)
+#   - backend-dev, coder, frontend-dev: 3600s (1 hour)
+#   - reviewer, tester, security: 1800s (30 minutes)
+#   - coordinator, orchestrator, product-owner: 900s (15 minutes)
+#   - default: 3600s (1 hour)
+#
+# Benefits:
+#   - Namespace isolation for concurrent swarms
+#   - Agent inventory and resource tracking
+#   - Status monitoring (in_progress/completed)
+#   - Automatic cleanup via TTL
+#   - Per-agent timeout configuration via get-agent-timeout.sh
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+SWARM_ID=""
+AGENTS=""
+TASK_ID=""
+TOPOLOGY="mesh"
+TTL=604800  # 7 days default
+MAX_AGENTS=""
+METADATA_EXTRA=""
+AGENT_TIMEOUTS=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --swarm-id)
+      SWARM_ID="$2"
+      shift 2
+      ;;
+    --agents)
+      AGENTS="$2"
+      shift 2
+      ;;
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --topology)
+      TOPOLOGY="$2"
+      shift 2
+      ;;
+    --ttl)
+      TTL="$2"
+      shift 2
+      ;;
+    --max-agents)
+      MAX_AGENTS="$2"
+      shift 2
+      ;;
+    --metadata)
+      METADATA_EXTRA="$2"
+      shift 2
+      ;;
+    --agent-timeouts)
+      AGENT_TIMEOUTS="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      echo "Usage: $0 --swarm-id <id> --agents <agent1,agent2,...> [options]"
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [ -z "$SWARM_ID" ] || [ -z "$AGENTS" ]; then
+  echo "Error: Required parameters missing"
+  echo "Usage: $0 --swarm-id <id> --agents <agent1,agent2,...>"
+  exit 1
+fi
+
+# Calculate max agents if not provided
+if [ -z "$MAX_AGENTS" ]; then
+  IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS"
+  MAX_AGENTS=${#AGENT_ARRAY[@]}
+fi
+
+# Use swarm-id as task-id if not provided
+if [ -z "$TASK_ID" ]; then
+  TASK_ID="$SWARM_ID"
+fi
+
+echo "[Swarm] Initializing swarm: $SWARM_ID"
+echo "[Swarm] Topology: $TOPOLOGY"
+echo "[Swarm] Total agents: $MAX_AGENTS"
+echo "[Swarm] TTL: $TTL seconds ($(($TTL / 86400)) days)"
+
+# Create swarm metadata key
+METADATA_KEY="swarm:${SWARM_ID}:metadata"
+
+# Store base metadata
+# Extract repository name from PWD
+REPO_NAME=$(basename "$(pwd)")
+
+redis-cli hset "$METADATA_KEY" \
+  swarm_id "$SWARM_ID" \
+  task_id "$TASK_ID" \
+  topology "$TOPOLOGY" \
+  max_agents "$MAX_AGENTS" \
+  agents "$AGENTS" \
+  created_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+  status "in_progress" \
+  repository "$REPO_NAME" \
+  cwd "$(pwd)" > /dev/null
+
+# Add extra metadata if provided (JSON string)
+if [ -n "$METADATA_EXTRA" ]; then
+  # Parse JSON and add each key-value pair
+  echo "$METADATA_EXTRA" | jq -r 'to_entries | .[] | "\(.key) \(.value)"' | while read -r KEY VALUE; do
+    redis-cli hset "$METADATA_KEY" "$KEY" "$VALUE" > /dev/null
+  done
+fi
+
+# Set TTL
+redis-cli expire "$METADATA_KEY" "$TTL" > /dev/null
+
+echo "[Swarm] Registered in Redis: $METADATA_KEY"
+echo "[Swarm] ✅ Initialization complete"
+
+# Output swarm ID for chaining
+echo "$SWARM_ID"

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

@@ -0,0 +1,220 @@
+#!/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