claude-flow-novice 2.9.1 → 2.10.1

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

@@ -0,0 +1,165 @@
+#!/bin/bash
+# Redis Coordination Skill - Agent Heartbeat Sender
+# Version: 2.0.0
+# Last Updated: 2025-10-20
+#
+# Usage:
+#   # One-shot heartbeat (original behavior)
+#   ./send-heartbeat.sh --task-id <id> --agent-id <id>
+#
+#   # Start continuous heartbeat loop
+#   ./send-heartbeat.sh start --task-id <id> --agent-id <id> --interval 30 &
+#   HEARTBEAT_PID=$!
+#
+#   # Stop heartbeat loop
+#   ./send-heartbeat.sh stop --task-id <id> --agent-id <id> --pid $HEARTBEAT_PID
+
+# Strict error handling
+set -euo pipefail
+
+# Default values
+ACTION=""
+TASK_ID=""
+AGENT_ID=""
+STATUS="active"
+TTL=60
+INTERVAL=30  # For continuous mode
+HEARTBEAT_PID=""
+DETAILS='{}'
+
+# Parse command-line arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        start|stop|once)
+            ACTION="$1"
+            shift
+            ;;
+        --task-id)
+            TASK_ID="$2"
+            shift 2
+            ;;
+        --agent-id)
+            AGENT_ID="$2"
+            shift 2
+            ;;
+        --status)
+            STATUS="$2"
+            shift 2
+            ;;
+        --ttl)
+            TTL="$2"
+            shift 2
+            ;;
+        --interval)
+            INTERVAL="$2"
+            shift 2
+            ;;
+        --pid)
+            HEARTBEAT_PID="$2"
+            shift 2
+            ;;
+        --details)
+            DETAILS="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Validate required parameters
+if [[ -z "$TASK_ID" || -z "$AGENT_ID" ]]; then
+    echo "Error: task-id and agent-id are required"
+    exit 1
+fi
+
+# If no action specified, default to one-shot (backward compatibility)
+if [ -z "$ACTION" ]; then
+    ACTION="once"
+fi
+
+HEARTBEAT_KEY="swarm:${TASK_ID}:${AGENT_ID}:heartbeat"
+MARKER_FILE="/tmp/heartbeat-${TASK_ID}-${AGENT_ID}.active"
+
+##############################################################################
+# Send single heartbeat
+##############################################################################
+function send_heartbeat() {
+    # Generate heartbeat payload
+    HEARTBEAT_PAYLOAD=$(jq -n \
+        --arg timestamp "$(date +%s)" \
+        --arg status "$STATUS" \
+        --arg task_id "$TASK_ID" \
+        --arg agent_id "$AGENT_ID" \
+        --argjson details "$DETAILS" \
+        '{
+            "timestamp": $timestamp,
+            "status": $status,
+            "task_id": $task_id,
+            "agent_id": $agent_id,
+            "details": $details
+        }')
+
+    # Send heartbeat via Redis with auto-expiration
+    redis-cli setex "$HEARTBEAT_KEY" "$TTL" "$HEARTBEAT_PAYLOAD" >/dev/null
+}
+
+##############################################################################
+# Start continuous heartbeat loop
+##############################################################################
+function start_heartbeat() {
+    # Create marker file
+    touch "$MARKER_FILE"
+
+    # Background heartbeat loop
+    (
+        while [ -f "$MARKER_FILE" ]; do
+            send_heartbeat
+            sleep "$INTERVAL"
+        done
+    ) &
+
+    echo "✓ Heartbeat started for $AGENT_ID (PID: $!, interval: ${INTERVAL}s)" >&2
+}
+
+##############################################################################
+# Stop heartbeat loop
+##############################################################################
+function stop_heartbeat() {
+    # Remove marker file to stop loop
+    rm -f "$MARKER_FILE"
+
+    # Kill heartbeat process if PID provided
+    if [ -n "$HEARTBEAT_PID" ] && kill -0 "$HEARTBEAT_PID" 2>/dev/null; then
+        kill "$HEARTBEAT_PID" 2>/dev/null || true
+    fi
+
+    # Clean up heartbeat key
+    redis-cli DEL "$HEARTBEAT_KEY" >/dev/null
+
+    echo "✓ Heartbeat stopped for $AGENT_ID" >&2
+}
+
+##############################################################################
+# Main
+##############################################################################
+case "$ACTION" in
+    start)
+        start_heartbeat
+        ;;
+    stop)
+        stop_heartbeat
+        ;;
+    once)
+        send_heartbeat
+        echo "✓ Heartbeat sent for $AGENT_ID" >&2
+        ;;
+    *)
+        echo "Error: Invalid action: $ACTION"
+        exit 1
+        ;;
+esac
+
+exit 0

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

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --key)
+            key="$2"
+            shift 2
+            ;;
+        --value)
+            value="$2"
+            shift 2
+            ;;
+        --ttl)
+            ttl="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown argument: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Validate required arguments
+if [[ -z "$key" || -z "$value" ]]; then
+    echo "Error: Both key and value are required"
+    exit 1
+fi
+
+# Default TTL to 3600 if not provided
+ttl=${ttl:-3600}
+
+# Store signal in Redis with specified TTL
+redis-cli setex "$key" "$ttl" "$value"
+
+# Exit successfully
+exit 0

package/.claude/skills/cfn-redis-coordination/store-context.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+
+# Redis Context Storage Primitive
+# Updated interface to match orchestrator expectations
+# Supports both legacy (--key --context) and new (--task-id --key --value --namespace) interfaces
+
+# Initialize variables
+task_id=""
+key=""
+value=""
+namespace="swarm"
+ttl=3600
+append_mode=false
+
+# 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
+            ;;
+        --context)
+            # Legacy support: --context is alias for --value
+            value="$2"
+            shift 2
+            ;;
+        --namespace)
+            namespace="$2"
+            shift 2
+            ;;
+        --ttl)
+            ttl="$2"
+            shift 2
+            ;;
+        --append)
+            append_mode=true
+            shift
+            ;;
+        *)
+            echo "Unknown argument: $1" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# Construct Redis key based on interface mode
+if [[ -n "$task_id" ]]; then
+    # New interface: {namespace}:{task_id}:{key}
+    redis_key="${namespace}:${task_id}:${key}"
+else
+    # Legacy interface: key is used directly
+    redis_key="$key"
+fi
+
+# Validate required arguments
+if [[ -z "$redis_key" || -z "$value" ]]; then
+    echo "Error: Both key and value are required" >&2
+    echo "Usage: $0 --task-id <id> --key <key> --value <data> [--namespace <ns>] [--ttl <seconds>] [--append]" >&2
+    echo "   or: $0 --key <full-key> --context <data> [--ttl <seconds>]" >&2
+    exit 1
+fi
+
+# Handle append mode
+if [ "$append_mode" = true ]; then
+    # Get existing value
+    existing=$(redis-cli get "$redis_key" 2>/dev/null)
+
+    # Append new value (comma-separated)
+    if [[ -n "$existing" && "$existing" != "(nil)" ]]; then
+        value="${existing},${value}"
+    fi
+fi
+
+# Store in Redis with specified TTL
+redis-cli setex "$redis_key" "$ttl" "$value" >/dev/null
+
+# Exit successfully
+exit 0

package/.claude/skills/cfn-redis-coordination/store-epic-context.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Store Epic Context in Redis
+# Stores epic-level context for CLI-spawned agents to access
+#
+# Usage:
+#   ./store-epic-context.sh --task-id <id> \
+#                           --epic-context <json> \
+#                           [--phase-context <json>] \
+#                           [--success-criteria <json>] \
+#                           [--ttl <seconds>]
+#
+# Example:
+#   ./store-epic-context.sh --task-id "epic-auth-123" \
+#     --epic-context '{
+#       "epicGoal": "Build authentication system",
+#       "inScope": ["JWT auth", "RBAC", "Session management"],
+#       "outOfScope": ["OAuth", "MFA", "Biometrics"],
+#       "phases": ["assessment", "implementation", "validation"]
+#     }' \
+#     --phase-context '{
+#       "currentPhase": "assessment",
+#       "dependencies": [],
+#       "deliverables": ["Requirements doc", "Architecture design"]
+#     }' \
+#     --success-criteria '{
+#       "acceptanceCriteria": [
+#         "Core functionality implemented",
+#         "Tests pass >80% coverage",
+#         "Security review complete"
+#       ],
+#       "gateThreshold": 0.75,
+#       "consensusThreshold": 0.90
+#     }' \
+#     --ttl 86400
+#
+# Redis Keys Created:
+#   - swarm:<task-id>:epic-context
+#   - swarm:<task-id>:phase-context
+#   - swarm:<task-id>:success-criteria
+#
+# These keys are automatically read by cfn-spawn and injected as environment
+# variables into spawned agents:
+#   - EPIC_CONTEXT
+#   - PHASE_CONTEXT
+#   - SUCCESS_CRITERIA
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+TASK_ID=""
+EPIC_CONTEXT=""
+PHASE_CONTEXT=""
+SUCCESS_CRITERIA=""
+TTL=86400  # 24 hours default
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --epic-context)
+      EPIC_CONTEXT="$2"
+      shift 2
+      ;;
+    --phase-context)
+      PHASE_CONTEXT="$2"
+      shift 2
+      ;;
+    --success-criteria)
+      SUCCESS_CRITERIA="$2"
+      shift 2
+      ;;
+    --ttl)
+      TTL="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [ -z "$TASK_ID" ]; then
+  echo "Error: --task-id is required"
+  exit 1
+fi
+
+if [ -z "$EPIC_CONTEXT" ]; then
+  echo "Error: --epic-context is required"
+  exit 1
+fi
+
+# Store epic context
+echo "Storing epic context for task: $TASK_ID"
+
+if [ -n "$EPIC_CONTEXT" ]; then
+  redis-cli set "swarm:${TASK_ID}:epic-context" "$EPIC_CONTEXT" EX "$TTL" > /dev/null
+  echo "  ✓ Epic context stored (TTL: ${TTL}s)"
+fi
+
+if [ -n "$PHASE_CONTEXT" ]; then
+  redis-cli set "swarm:${TASK_ID}:phase-context" "$PHASE_CONTEXT" EX "$TTL" > /dev/null
+  echo "  ✓ Phase context stored (TTL: ${TTL}s)"
+fi
+
+if [ -n "$SUCCESS_CRITERIA" ]; then
+  redis-cli set "swarm:${TASK_ID}:success-criteria" "$SUCCESS_CRITERIA" EX "$TTL" > /dev/null
+  echo "  ✓ Success criteria stored (TTL: ${TTL}s)"
+fi
+
+echo "✅ Context storage complete"
+echo ""
+echo "CLI-spawned agents will automatically receive this context via environment variables:"
+echo "  - EPIC_CONTEXT"
+echo "  - PHASE_CONTEXT"
+echo "  - SUCCESS_CRITERIA"