claude-flow-novice 2.14.32 → 2.14.33

package/claude-assets/skills/cfn-redis-data-extraction/extract.sh

@@ -0,0 +1,306 @@
+#!/bin/bash
+# CFN Redis Data Extraction Script
+# Extracts complete Redis coordination data from completed CFN Loop tasks
+
+set -euo pipefail
+
+# Default values
+OUTPUT_DIR="./analysis/cfn-loop-data"
+INCLUDE_PERFORMANCE=false
+TASK_IDS=()
+VERBOSE=false
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_IDS+=("$2")
+      shift 2
+      ;;
+    --task-ids)
+      IFS=',' read -ra TASK_IDS <<< "$2"
+      shift 2
+      ;;
+    --output-dir)
+      OUTPUT_DIR="$2"
+      shift 2
+      ;;
+    --include-performance)
+      INCLUDE_PERFORMANCE=true
+      shift
+      ;;
+    --verbose)
+      VERBOSE=true
+      shift
+      ;;
+    -h|--help)
+      echo "Usage: $0 --task-id <TASK_ID> [--output-dir <DIR>] [--include-performance] [--verbose]"
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required arguments
+if [[ ${#TASK_IDS[@]} -eq 0 ]]; then
+  echo "Error: --task-id or --task-ids is required"
+  exit 1
+fi
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+# Redis connection check
+if ! redis-cli ping > /dev/null 2>&1; then
+  echo "Error: Redis is not accessible"
+  exit 1
+fi
+
+# Function to extract task data
+extract_task_data() {
+  local task_id="$1"
+  local output_file="$OUTPUT_DIR/cfn-loop-${task_id}-extracted.json"
+
+  [[ "$VERBOSE" == true ]] && echo "Extracting data for task: $task_id"
+
+  # Get all Redis keys for the task
+  local redis_keys
+  redis_keys=$(redis-cli keys "*${task_id}*" 2>/dev/null | sort)
+
+  if [[ -z "$redis_keys" ]]; then
+    echo "Warning: No Redis keys found for task: $task_id"
+    return 1
+  fi
+
+  # Initialize JSON structure
+  local json_data
+  json_data=$(cat << EOF
+{
+  "task_id": "$task_id",
+  "extraction_timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "extraction_version": "1.0.0",
+  "redis_keys_analyzed": $(echo "$redis_keys" | wc -l),
+  "agents": {},
+  "metadata": {},
+  "summary": {}
+}
+EOF
+)
+
+  # Process each Redis key
+  local agent_count=0
+  local completion_signals=0
+  local total_confidence=0
+  local confidence_count=0
+  declare -A agent_loops
+  declare -A agent_types
+
+  while IFS= read -r key; do
+    [[ -z "$key" ]] && continue
+
+    # Skip if not a swarm key
+    [[ ! "$key" =~ ^swarm: ]] && continue
+
+    # Extract agent information from key
+    local agent_id=""
+    local data_type=""
+
+    if [[ "$key" =~ ^swarm:([^:]+):([^:]+):([^:]+)$ ]]; then
+      local task_key="${BASH_REMATCH[1]}"
+      agent_id="${BASH_REMATCH[2]}"
+      data_type="${BASH_REMATCH[3]}"
+
+      # Determine agent type and loop number
+      local agent_type=""
+      local loop_number=""
+
+      if [[ "$agent_id" =~ ^cfn-v3-coordinator ]]; then
+        agent_type="coordinator"
+        loop_number="coordination"
+      elif [[ "$agent_id" =~ -validation$ ]]; then
+        agent_type="${agent_id%-validation}"
+        loop_number="2"
+      elif [[ "$agent_id" =~ -[0-9]+$ ]]; then
+        agent_type="${agent_id%-*}"
+        loop_number="3"
+      elif [[ "$agent_id" =~ product-owner$ ]]; then
+        agent_type="product-owner"
+        loop_number="4"
+      else
+        agent_type="$agent_id"
+        loop_number="unknown"
+      fi
+
+      # Store agent classification
+      agent_types["$agent_id"]="$agent_type"
+      agent_loops["$agent_id"]="$loop_number"
+
+      # Initialize agent in JSON if not exists
+      if [[ ! "$json_data" =~ "\"$agent_id\":" ]]; then
+        ((agent_count++))
+        json_data=$(echo "$json_data" | jq ".agents += {\"$agent_id\": {\"agent_type\": \"$agent_type\", \"loop\": \"$loop_number\", \"data\": {}}}")
+      fi
+
+      # Extract data based on type
+      case "$data_type" in
+        "confidence")
+          local confidence
+          confidence=$(redis-cli get "$key" 2>/dev/null || echo "null")
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].confidence = $confidence")
+          if [[ "$confidence" != "null" ]]; then
+            total_confidence=$(echo "$total_confidence + $confidence" | bc -l)
+            ((confidence_count++))
+          fi
+          ;;
+        "done")
+          local completion_signal
+          completion_signal=$(redis-cli type "$key" 2>/dev/null)
+          if [[ "$completion_signal" == "list" ]]; then
+            completion_signal=$(redis-cli lrange "$key" 0 -1 2>/dev/null | head -1 || echo "null")
+          else
+            completion_signal=$(redis-cli get "$key" 2>/dev/null || echo "null")
+          fi
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].completion_signal = \"$completion_signal\"")
+          ((completion_signals++))
+          ;;
+        "messages")
+          local messages_json="[]"
+          local message_count
+          message_count=$(redis-cli llen "$key" 2>/dev/null || echo "0")
+
+          if [[ "$message_count" -gt 0 ]]; then
+            messages_json=$(redis-cli lrange "$key" 0 -1 2>/dev/null | jq -R . | jq -s .)
+          fi
+
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].messages = $messages_json")
+          ;;
+        "result")
+          local result_type
+          result_type=$(redis-cli type "$key" 2>/dev/null)
+          local result="null"
+
+          case "$result_type" in
+            "string")
+              result=$(redis-cli get "$key" 2>/dev/null || echo "null")
+              ;;
+            "list")
+              result=$(redis-cli lrange "$key" 0 -1 2>/dev/null | jq -R . | jq -s .)
+              ;;
+          esac
+
+          json_data=$(echo "$json_data" | jq ".agents[\"$agent_id\"].result = $result")
+          ;;
+      esac
+    fi
+  done <<< "$redis_keys"
+
+  # Calculate averages and summary
+  local avg_confidence="0"
+  if [[ "$confidence_count" -gt 0 ]]; then
+    avg_confidence=$(echo "scale=3; $total_confidence / $confidence_count" | bc -l)
+  fi
+
+  # Extract task context if available
+  local task_context
+  task_context=$(redis-cli get "cfn_loop:task:$task_id:context" 2>/dev/null || echo "{}")
+
+  # Extract completed agents list
+  local completed_agents
+  completed_agents=$(redis-cli lrange "swarm:$task_id:completed_agents" 0 -1 2>/dev/null | jq -R . | jq -s . || echo "[]")
+
+  # Update summary
+  json_data=$(echo "$json_data" | jq "
+    .summary += {
+      \"total_agents\": $agent_count,
+      \"completion_signals\": $completion_signals,
+      \"average_confidence\": $avg_confidence,
+      \"confidence_scores_count\": $confidence_count,
+      \"completed_agents\": $completed_agents,
+      \"extraction_status\": \"success\"
+    }
+  ")
+
+  # Add task context
+  json_data=$(echo "$json_data" | jq ".metadata.task_context = \"$task_context\"")
+
+  # Add performance metrics if requested
+  if [[ "$INCLUDE_PERFORMANCE" == true ]]; then
+    local redis_memory
+    redis_memory=$(redis-cli info memory 2>/dev/null | grep "used_memory_human" | cut -d: -f2 | tr -d '\r' || echo "\"unknown\"")
+    local redis_clients
+    redis_clients=$(redis-cli info clients 2>/dev/null | grep "connected_clients" | cut -d: -f2 | tr -d '\r' || echo "0")
+
+    json_data=$(echo "$json_data" | jq "
+      .metadata.performance = {
+        \"redis_memory_usage\": \"$redis_memory\",
+        \"redis_connected_clients\": $redis_clients,
+        \"extraction_duration_ms\": 0
+      }
+    ")
+  fi
+
+  # Write to file
+  echo "$json_data" | jq '.' > "$output_file"
+
+  [[ "$VERBOSE" == true ]] && echo "Data extracted to: $output_file"
+
+  # Generate summary report
+  local summary_file="$OUTPUT_DIR/cfn-loop-${task_id}-summary.txt"
+  cat > "$summary_file" << EOF
+CFN Loop Data Extraction Summary
+================================
+
+Task ID: $task_id
+Extraction Time: $(date -u +%Y-%m-%dT%H:%M:%SZ)
+Output File: $output_file
+
+Statistics:
+- Redis Keys Analyzed: $(echo "$redis_keys" | wc -l)
+- Total Agents: $agent_count
+- Completion Signals: $completion_signals
+- Average Confidence: $avg_confidence
+- Confidence Scores: $confidence_count
+
+Agent Types:
+$(for agent_id in "${!agent_types[@]}"; do
+  echo "- $agent_id: ${agent_types[$agent_id]} (Loop ${agent_loops[$agent_id]})"
+done | sort)
+
+Status: Successfully extracted
+EOF
+
+  [[ "$VERBOSE" == true ]] && echo "Summary report generated: $summary_file"
+
+  return 0
+}
+
+# Main execution
+echo "CFN Redis Data Extraction Started"
+echo "================================="
+echo "Output Directory: $OUTPUT_DIR"
+echo "Include Performance: $INCLUDE_PERFORMANCE"
+echo ""
+
+# Process each task
+for task_id in "${TASK_IDS[@]}"; do
+  echo "Processing task: $task_id"
+  if extract_task_data "$task_id"; then
+    echo "✅ Successfully extracted data for: $task_id"
+  else
+    echo "❌ Failed to extract data for: $task_id"
+  fi
+  echo ""
+done
+
+echo "CFN Redis Data Extraction Completed"
+echo "==================================="
+echo "Output Directory: $OUTPUT_DIR"
+echo "Files Generated:"
+find "$OUTPUT_DIR" -name "cfn-loop-*.json" -o -name "cfn-loop-*.txt" | while read -r file; do
+  echo "  - $file"
+done
+
+exit 0

package/claude-assets/skills/hook-pipeline/security-scanner.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+
+##############################################################################
+# Security Scanner for Post-Edit Hooks
+# Version: 1.0.0
+##############################################################################
+
+set -euo pipefail
+
+# Function to perform basic security scanning on files
+security_scan() {
+    local file_path="$1"
+    local agent_id="${2:-unknown}"
+
+    # Initialize security scan results
+    local scan_result='{"confidence":0.9,"issues":[],"details":"{\\\"scanner\\\":\\\"basic-security\\\",\\\"timestamp\\\":\\\"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'\\\"}"}'
+
+    # Check if file exists
+    if [[ ! -f "$file_path" ]]; then
+        scan_result='{"confidence":0,"issues":[{"severity":"error","message":"File not found","line":0}],"details":"{\\\"error\\\":\\\"file_not_found\\\"}"}'
+        echo "$scan_result"
+        return 1
+    fi
+
+    # Basic security checks
+    local issues=()
+    local confidence=0.9
+
+    # Check for potential secrets/passwords
+    if grep -i -E "(password|secret|key|token)\s*[:=]\s*['\"]?[a-zA-Z0-9+/=]{20,}" "$file_path" >/dev/null 2>&1; then
+        issues+=("{\"severity\":\"critical\",\"message\":\"Potential hardcoded secret detected\",\"type\":\"secret_exposure\"}")
+        confidence=0.3
+    fi
+
+    # Check for API keys patterns
+    if grep -E "(AIza[A-Za-z0-9_-]{35}|[a-zA-Z0-9_-]{40,})" "$file_path" >/dev/null 2>&1; then
+        issues+=("{\"severity\":\"high\",\"message\":\"Potential API key pattern detected\",\"type\":\"api_key\"}")
+        confidence=0.5
+    fi
+
+    # Check for SQL injection patterns
+    if grep -E "(SELECT|INSERT|UPDATE|DELETE).*(\\$|\\$\\{|\\\$\)" "$file_path" >/dev/null 2>&1; then
+        issues+=("{\"severity\":\"medium\",\"message\":\"Unsanitized variable in SQL query\",\"type\":\"sql_injection\"}")
+        confidence=0.7
+    fi
+
+    # Check for eval() usage (security risk)
+    if grep -E "eval\\s*\\(" "$file_path" >/dev/null 2>&1; then
+        issues+=("{\"severity\":\"medium\",\"message\":\"Use of eval() function detected\",\"type\":\"eval_usage\"}")
+        confidence=0.8
+    fi
+
+    # Check for shell command injection patterns
+    if grep -E "(exec|system|shell_exec)\\s*\\(" "$file_path" >/dev/null 2>&1; then
+        issues+=("{\"severity\":\"medium\",\"message\":\"Use of system execution functions\",\"type\":\"command_injection\"}")
+        confidence=0.8
+    fi
+
+    # Build JSON result
+    local issues_json="[]"
+    if [[ ${#issues[@]} -gt 0 ]]; then
+        issues_json="[$(IFS=','; echo "${issues[*]}")]"
+    fi
+
+    scan_result="{\"confidence\":$confidence,\"issues\":$issues_json,\"details\":\"{\\\"scanner\\\":\\\"basic-security\\\",\\\"timestamp\\\":\\\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\\\",\\\"file\\\":\\\"$file_path\\\",\\\"agent_id\\\":\\\"$agent_id\\\"}\"}"
+
+    echo "$scan_result"
+
+    # Return appropriate exit code based on findings
+    if [[ ${#issues[@]} -gt 0 ]]; then
+        return 1
+    else
+        return 0
+    fi
+}
+
+# Main execution
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    # Script called directly
+    if [[ $# -lt 1 ]]; then
+        echo "Usage: $0 <file_path> [--agent-id <id>]" >&2
+        exit 1
+    fi
+
+    file_path="$1"
+    agent_id="unknown"
+
+    # Parse optional arguments
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --agent-id)
+                agent_id="$2"
+                shift 2
+                ;;
+            *)
+                shift
+                ;;
+        esac
+    done
+
+    security_scan "$file_path" "$agent_id"
+fi

package/claude-assets/skills/pre-edit-backup/backup.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+
+##############################################################################
+# Pre-Edit Backup Script - Creates safe file backups before modifications
+# Version: 1.0.0
+##############################################################################
+
+set -euo pipefail
+
+# Function to create backup of a file before editing
+create_backup() {
+    local file_path="$1"
+    local agent_id="${2:-unknown}"
+    local project_root="${3:-$(pwd)}"
+
+    # Validate inputs
+    if [[ -z "$file_path" ]]; then
+        echo "Error: File path is required" >&2
+        exit 1
+    fi
+
+    # Check if file exists
+    if [[ ! -f "$file_path" ]]; then
+        echo "Warning: File does not exist: $file_path" >&2
+        # Create empty backup path for new files
+        echo "$project_root/.backups/$agent_id/new-file-$(date +%s)-$(echo "$file_path" | tr '/' '_' | tr ' ' '_')"
+        return 0
+    fi
+
+    # Create backup directory structure
+    local backup_dir="$project_root/.backups/$agent_id"
+    local timestamp=$(date +%s)
+    local file_hash=$(md5sum "$file_path" | cut -d' ' -f1)
+    local backup_name="${timestamp}_${file_hash}"
+
+    # Create full backup path
+    local full_backup_path="$backup_dir/$backup_name"
+
+    # Create backup directory
+    mkdir -p "$full_backup_path"
+
+    # Copy original file to backup location
+    cp "$file_path" "$full_backup_path/original"
+
+    # Store backup metadata
+    cat > "$full_backup_path/metadata.json" << EOF
+{
+  "timestamp": "$timestamp",
+  "agent_id": "$agent_id",
+  "original_file": "$file_path",
+  "file_hash": "$file_hash",
+  "backup_path": "$full_backup_path",
+  "created_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+}
+EOF
+
+    # Create revert script
+    cat > "$full_backup_path/revert.sh" << EOF
+#!/bin/bash
+# Revert script for $file_path
+set -euo pipefail
+
+echo "Reverting file: $file_path"
+cp "$full_backup_path/original" "$file_path"
+echo "✅ File reverted successfully"
+EOF
+
+    chmod +x "$full_backup_path/revert.sh"
+
+    # Output backup path for caller
+    echo "$full_backup_path"
+
+    echo "✅ Backup created: $full_backup_path" >&2
+}
+
+# Main execution
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    # Script called directly
+    if [[ $# -lt 1 ]]; then
+        echo "Usage: $0 <file_path> [--agent-id <id>] [--project-root <path>]" >&2
+        exit 1
+    fi
+
+    file_path="$1"
+    agent_id="unknown"
+    project_root="$(pwd)"
+
+    # Parse optional arguments
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --agent-id)
+                agent_id="$2"
+                shift 2
+                ;;
+            --project-root)
+                project_root="$2"
+                shift 2
+                ;;
+            *)
+                # Skip unknown arguments
+                shift
+                ;;
+        esac
+    done
+
+    create_backup "$file_path" "$agent_id" "$project_root"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.14.32",
+  "version": "2.14.33",
   "description": "AI agent orchestration framework with namespace-isolated skills, agents, and CFN Loop validation. Safe installation with ~0.01% collision risk.",
   "main": "dist/index.js",
   "type": "module",
@@ -113,7 +113,17 @@
     "portal:restart": "npm run portal:stop && npm run portal:start",
     "portal:status": "./scripts/portal-status.sh",
     "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "docker:build": "docker build -f Dockerfile.production -t claude-flow-novice:production .",
+    "docker:deploy": "./scripts/deploy-production.sh",
+    "docker:stop": "docker-compose -f docker-compose.production.yml down",
+    "docker:logs": "docker-compose -f docker-compose.production.yml logs -f",
+    "docker:status": "docker-compose -f docker-compose.production.yml ps",
+    "docker:test": "node tests/docker/production-deployment-test.js",
+    "docker:orchestrator": "node tests/docker/production-agent-orchestrator.js",
+    "test:docker:redis-coordination": "node tests/docker/cfn-coordination-test.js",
+    "test:docker:concurrent": "node tests/hello-world-docker/concurrent-agent-test.js",
+    "test:docker:container": "bash tests/docker/container-test-runner.sh"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.67.0",
@@ -123,14 +133,13 @@
     "commander": "^11.1.0",
     "dotenv": "^17.2.3",
     "glob": "^11.0.3",
+    "ioredis": "^5.8.2",
     "lodash": "^4.17.21",
     "redis": "^5.8.3",
     "socket.io": "^4.8.1",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7"
   },
-  "optionalDependencies": {},
-  "peerDependencies": {},
   "engines": {
     "node": ">=18.0.0"
   },