claude-flow-novice 2.8.1 → 2.9.0

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

@@ -1,126 +0,0 @@
-#!/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/redis-coordination/init-swarm.sh

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