claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/redis-coordination/agent-log.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+
+# Agent Logging Utility - Dual output (terminal + Redis)
+#
+# Usage:
+#   source agent-log.sh
+#   agent_log "info" "Message here"
+#   agent_log "error" "Error occurred"
+#
+# Or as standalone:
+#   ./agent-log.sh "info" "Agent started" --agent-id "researcher-1" --task-id "task-123"
+
+set -euo pipefail
+
+# Color codes for terminal output
+COLOR_RESET="\033[0m"
+COLOR_DEBUG="\033[0;36m"   # Cyan
+COLOR_INFO="\033[0;32m"    # Green
+COLOR_WARN="\033[0;33m"    # Yellow
+COLOR_ERROR="\033[0;31m"   # Red
+COLOR_AGENT="\033[0;35m"   # Magenta
+
+# Get color for log level
+get_log_color() {
+  local level="$1"
+  case "$level" in
+    debug) echo "$COLOR_DEBUG" ;;
+    info)  echo "$COLOR_INFO" ;;
+    warn)  echo "$COLOR_WARN" ;;
+    error) echo "$COLOR_ERROR" ;;
+    *) echo "$COLOR_RESET" ;;
+  esac
+}
+
+# Main logging function
+# Usage: agent_log <level> <message> [--agent-id <id>] [--task-id <id>] [--no-terminal] [--no-redis]
+agent_log() {
+  local LEVEL="${1:-info}"
+  local MESSAGE="${2:-}"
+  local AGENT_ID="${AGENT_ID:-unknown}"
+  local TASK_ID="${TASK_ID:-unknown}"
+  local REPOSITORY=$(basename "$(pwd)")
+  local NO_TERMINAL=false
+  local NO_REDIS=false
+
+  # Parse optional arguments
+  shift 2 || true
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --agent-id)
+        AGENT_ID="$2"
+        shift 2
+        ;;
+      --task-id)
+        TASK_ID="$2"
+        shift 2
+        ;;
+      --no-terminal)
+        NO_TERMINAL=true
+        shift
+        ;;
+      --no-redis)
+        NO_REDIS=true
+        shift
+        ;;
+      *)
+        shift
+        ;;
+    esac
+  done
+
+  local TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+  local COLOR=$(get_log_color "$LEVEL")
+
+  # 1. Terminal output (with colors)
+  if [ "$NO_TERMINAL" = false ]; then
+    echo -e "${COLOR}[${LEVEL^^}]${COLOR_RESET} ${COLOR_AGENT}[${AGENT_ID}]${COLOR_RESET} ${MESSAGE}"
+  fi
+
+  # 2. File output (no colors, in /tmp)
+  local LOG_FILE="/tmp/agent-${AGENT_ID}.log"
+  echo "[${TIMESTAMP}] [${LEVEL^^}] [${AGENT_ID}] ${MESSAGE}" >> "$LOG_FILE"
+
+  # 3. Redis pub/sub (for portal)
+  if [ "$NO_REDIS" = false ]; then
+    local LOG_PAYLOAD=$(cat <<EOF
+{
+  "level": "${LEVEL}",
+  "message": "${MESSAGE}",
+  "agentId": "${AGENT_ID}",
+  "taskId": "${TASK_ID}",
+  "repository": "${REPOSITORY}",
+  "timestamp": "${TIMESTAMP}"
+}
+EOF
+)
+
+    # Publish to Redis channel: swarm:<task-id>:logs
+    redis-cli publish "swarm:${TASK_ID}:logs" "$LOG_PAYLOAD" > /dev/null 2>&1 || true
+
+    # Also add to sorted set for persistence (with timestamp as score)
+    local SCORE=$(date +%s)
+    redis-cli zadd "swarm:${TASK_ID}:logs:history" "$SCORE" "$LOG_PAYLOAD" > /dev/null 2>&1 || true
+
+    # Set TTL on history (7 days)
+    redis-cli expire "swarm:${TASK_ID}:logs:history" 604800 > /dev/null 2>&1 || true
+  fi
+}
+
+# If script is executed directly (not sourced)
+if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
+  if [ $# -lt 2 ]; then
+    echo "Usage: $0 <level> <message> [--agent-id <id>] [--task-id <id>]"
+    echo ""
+    echo "Levels: debug, info, warn, error"
+    echo ""
+    echo "Examples:"
+    echo "  $0 info \"Agent started\" --agent-id researcher-1 --task-id task-123"
+    echo "  $0 error \"Connection failed\" --agent-id reviewer-2 --task-id task-456"
+    exit 1
+  fi
+
+  agent_log "$@"
+fi

package/.claude/skills/redis-coordination/analyze-task-complexity.sh

@@ -0,0 +1,277 @@
+#!/usr/bin/env bash
+##############################################################################
+# Task Complexity Analyzer
+#
+# Purpose: Deterministically analyze task complexity and determine optimal
+#          number of Loop 3 agents needed.
+#
+# Usage:
+#   ./analyze-task-complexity.sh --task "Build React dashboard" [--difficulty auto]
+#
+# Output (JSON):
+#   {
+#     "complexity_score": 7.5,
+#     "difficulty": "standard",
+#     "domains": ["frontend", "backend"],
+#     "suggested_agents": {
+#       "loop3_count": 3,
+#       "loop2_count": 4
+#     },
+#     "reasoning": "Multi-domain task with moderate scope"
+#   }
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+TASK_DESCRIPTION=""
+DIFFICULTY="auto"  # auto | simple | standard | complex | enterprise
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task)
+      TASK_DESCRIPTION="$2"
+      shift 2
+      ;;
+    --difficulty)
+      DIFFICULTY="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "$TASK_DESCRIPTION" ]; then
+  echo "Error: --task required" >&2
+  exit 1
+fi
+
+##############################################################################
+# Complexity Scoring Algorithm
+##############################################################################
+
+TASK_LOWER=$(echo "$TASK_DESCRIPTION" | tr '[:upper:]' '[:lower:]')
+COMPLEXITY_SCORE=0
+DETECTED_DOMAINS=()
+REASONING=""
+
+# 1. Word Count (longer = more complex)
+WORD_COUNT=$(echo "$TASK_DESCRIPTION" | wc -w)
+if [ "$WORD_COUNT" -lt 5 ]; then
+  WORD_SCORE=1
+elif [ "$WORD_COUNT" -lt 10 ]; then
+  WORD_SCORE=2
+elif [ "$WORD_COUNT" -lt 20 ]; then
+  WORD_SCORE=3
+else
+  WORD_SCORE=4
+fi
+COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + WORD_SCORE))
+
+# 2. Domain Detection (multi-domain = more complex)
+DOMAIN_COUNT=0
+
+if [[ "$TASK_LOWER" =~ react|frontend|ui|component|dashboard ]]; then
+  DETECTED_DOMAINS+=("frontend")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ api|backend|server|endpoint|rest|graphql ]]; then
+  DETECTED_DOMAINS+=("backend")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ database|db|sql|postgres|mongo|redis ]]; then
+  DETECTED_DOMAINS+=("database")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ deploy|infra|docker|k8s|kubernetes|aws|cloud ]]; then
+  DETECTED_DOMAINS+=("infrastructure")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ auth|security|encrypt|permission|rbac ]]; then
+  DETECTED_DOMAINS+=("security")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ test|qa|validation|coverage ]]; then
+  DETECTED_DOMAINS+=("testing")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ architect|design|pattern|system ]]; then
+  DETECTED_DOMAINS+=("architecture")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+if [[ "$TASK_LOWER" =~ rust|cargo|tokio ]]; then
+  DETECTED_DOMAINS+=("rust")
+  DOMAIN_COUNT=$((DOMAIN_COUNT + 1))
+fi
+
+# Domain score: 2 points per domain
+DOMAIN_SCORE=$((DOMAIN_COUNT * 2))
+COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + DOMAIN_SCORE))
+
+# 3. Explicit Scope Indicators
+if [[ "$TASK_LOWER" =~ simple|quick|small|basic|minimal|mvp ]]; then
+  SCOPE_MODIFIER=-2
+  SCOPE_LABEL="reduced (MVP scope detected)"
+elif [[ "$TASK_LOWER" =~ production|enterprise|scalable|robust|complete|full ]]; then
+  SCOPE_MODIFIER=3
+  SCOPE_LABEL="increased (enterprise scope detected)"
+elif [[ "$TASK_LOWER" =~ prototype|poc|proof.of.concept ]]; then
+  SCOPE_MODIFIER=-1
+  SCOPE_LABEL="slightly reduced (prototype scope)"
+else
+  SCOPE_MODIFIER=0
+  SCOPE_LABEL="standard"
+fi
+COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + SCOPE_MODIFIER))
+
+# 4. Feature Counting (and, with, includes, etc.)
+FEATURE_COUNT=0
+if [[ "$TASK_LOWER" =~ " and " ]]; then
+  FEATURE_COUNT=$((FEATURE_COUNT + 1))
+fi
+if [[ "$TASK_LOWER" =~ " with " ]]; then
+  FEATURE_COUNT=$((FEATURE_COUNT + 1))
+fi
+if [[ "$TASK_LOWER" =~ " including " ]]; then
+  FEATURE_COUNT=$((FEATURE_COUNT + 1))
+fi
+
+FEATURE_SCORE=$((FEATURE_COUNT))
+COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + FEATURE_SCORE))
+
+# 5. Integration Keywords (increases complexity)
+INTEGRATION_COUNT=0
+if [[ "$TASK_LOWER" =~ integrat|connect|sync|webhook ]]; then
+  INTEGRATION_COUNT=$((INTEGRATION_COUNT + 1))
+fi
+if [[ "$TASK_LOWER" =~ third.party|external|api ]]; then
+  INTEGRATION_COUNT=$((INTEGRATION_COUNT + 1))
+fi
+
+INTEGRATION_SCORE=$((INTEGRATION_COUNT))
+COMPLEXITY_SCORE=$((COMPLEXITY_SCORE + INTEGRATION_SCORE))
+
+##############################################################################
+# Difficulty Classification
+##############################################################################
+
+if [ "$DIFFICULTY" = "auto" ]; then
+  if [ "$COMPLEXITY_SCORE" -le 3 ]; then
+    DIFFICULTY="simple"
+  elif [ "$COMPLEXITY_SCORE" -le 7 ]; then
+    DIFFICULTY="standard"
+  elif [ "$COMPLEXITY_SCORE" -le 12 ]; then
+    DIFFICULTY="complex"
+  else
+    DIFFICULTY="enterprise"
+  fi
+fi
+
+##############################################################################
+# Agent Count Calculation
+##############################################################################
+
+case "$DIFFICULTY" in
+  simple)
+    # MVP/Simple: 1-2 Loop 3 agents
+    BASE_LOOP3=1
+    BASE_LOOP2=2
+    REASONING="Simple task with minimal scope"
+    ;;
+  standard)
+    # Standard: 2-3 Loop 3 agents
+    BASE_LOOP3=2
+    BASE_LOOP2=3
+    REASONING="Standard task with moderate complexity"
+    ;;
+  complex)
+    # Complex: 3-5 Loop 3 agents
+    BASE_LOOP3=3
+    BASE_LOOP2=4
+    REASONING="Complex task with multiple domains"
+    ;;
+  enterprise)
+    # Enterprise: 5-8 Loop 3 agents
+    BASE_LOOP3=5
+    BASE_LOOP2=5
+    REASONING="Enterprise-grade task with high complexity"
+    ;;
+  *)
+    echo "Error: Invalid difficulty: $DIFFICULTY" >&2
+    exit 1
+    ;;
+esac
+
+# Scale by domain count (1 extra agent per additional domain beyond 2)
+if [ "$DOMAIN_COUNT" -gt 2 ]; then
+  EXTRA_AGENTS=$((DOMAIN_COUNT - 2))
+  LOOP3_COUNT=$((BASE_LOOP3 + EXTRA_AGENTS))
+else
+  LOOP3_COUNT=$BASE_LOOP3
+fi
+
+# Cap at reasonable limits
+if [ "$LOOP3_COUNT" -gt 8 ]; then
+  LOOP3_COUNT=8
+fi
+
+# Loop 2 scales with Loop 3 (but slower: +1 validator per 2 implementers)
+LOOP2_COUNT=$((BASE_LOOP2 + (LOOP3_COUNT - BASE_LOOP3) / 2))
+if [ "$LOOP2_COUNT" -gt 6 ]; then
+  LOOP2_COUNT=6
+fi
+
+# Ensure minimum validators
+if [ "$LOOP2_COUNT" -lt 2 ]; then
+  LOOP2_COUNT=2
+fi
+
+##############################################################################
+# Build Reasoning String
+##############################################################################
+
+REASONING_DETAILS="$REASONING (complexity score: $COMPLEXITY_SCORE, domains: $DOMAIN_COUNT, scope: $SCOPE_LABEL)"
+
+##############################################################################
+# Output JSON
+##############################################################################
+
+# Convert array to JSON array
+DOMAINS_JSON=$(printf '%s\n' "${DETECTED_DOMAINS[@]}" | jq -R . | jq -s .)
+
+jq -nc \
+  --arg complexity "$COMPLEXITY_SCORE" \
+  --arg difficulty "$DIFFICULTY" \
+  --argjson domains "$DOMAINS_JSON" \
+  --arg loop3 "$LOOP3_COUNT" \
+  --arg loop2 "$LOOP2_COUNT" \
+  --arg reasoning "$REASONING_DETAILS" \
+  --arg word_count "$WORD_COUNT" \
+  --arg domain_count "$DOMAIN_COUNT" \
+  --arg feature_count "$FEATURE_COUNT" \
+  '{
+    complexity_score: ($complexity | tonumber),
+    difficulty: $difficulty,
+    domains: $domains,
+    suggested_agents: {
+      loop3_count: ($loop3 | tonumber),
+      loop2_count: ($loop2 | tonumber)
+    },
+    reasoning: $reasoning,
+    analysis: {
+      word_count: ($word_count | tonumber),
+      domain_count: ($domain_count | tonumber),
+      feature_count: ($feature_count | tonumber)
+    }
+  }'