claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/management/cleanup-memory.sh

@@ -1,197 +0,0 @@
-#!/bin/bash
-
-# Memory Cleanup Script for CFN Operations
-# Post-execution hook to clean up memory resources
-
-set -euo pipefail
-
-# Configuration
-CLEANUP_DELAY=5  # Seconds to wait before cleanup
-LOG_FILE="/tmp/cfn-memory-cleanup.log"
-PROFILE_DIR="/tmp/claude-memory-profiles"
-
-# Colors
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-log() {
-    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
-}
-
-cleanup_temp_files() {
-    log "Cleaning up temporary files"
-
-    # Clean old profile files (older than 24 hours)
-    if [[ -d "$PROFILE_DIR" ]]; then
-        local old_profiles=$(find "$PROFILE_DIR" -name "*.heapprofile" -mtime +1 2>/dev/null || true)
-        if [[ -n "$old_profiles" ]]; then
-            echo "$old_profiles" | xargs rm -f 2>/dev/null || true
-            log "Removed old heap profiles"
-        fi
-    fi
-
-    # Clean temp directories
-    find /tmp -name "claude-*" -type d -mtime +1 -exec rm -rf {} + 2>/dev/null || true
-    find /tmp -name "*claude*" -type f -mtime +1 -delete 2>/dev/null || true
-}
-
-cleanup_zombie_processes() {
-    log "Checking for zombie Claude processes"
-
-    local zombie_pids=$(ps aux | awk '$8 ~ /^Z/ && $11 ~ /claude/ {print $2}' || true)
-
-    if [[ -n "$zombie_pids" ]]; then
-        echo -e "${YELLOW}Found zombie Claude processes: $zombie_pids${NC}"
-        # Zombies can't be killed directly, but we can log them
-        log "Zombie processes detected: $zombie_pids"
-    fi
-}
-
-cleanup_hanging_processes() {
-    log "Checking for hanging Claude processes"
-
-    # Find processes that have been running > 2 hours
-    local hanging_pids=$(ps -eo pid,etime,cmd | awk '$3 ~ /claude/ && $2 ~ /([0-9]{2}:|[0-9]{3}-)/ {print $1}' || true)
-
-    if [[ -n "$hanging_pids" ]]; then
-        echo -e "${YELLOW}Found long-running Claude processes: $hanging_pids${NC}"
-
-        for pid in $hanging_pids; do
-            if kill -0 "$pid" 2>/dev/null; then
-                local process_info=$(ps -p "$pid" -o pid,etime,pcpu,rss,cmd --no-headers)
-                echo "  PID $pid: $process_info"
-
-                # Check if process is consuming excessive memory (>4GB)
-                local rss_kb=$(ps -p "$pid" -o rss= --no-headers 2>/dev/null || echo "0")
-                local rss_mb=$((rss_kb / 1024))
-
-                if [[ $rss_mb -gt 4096 ]]; then
-                    echo -e "${YELLOW}  ⚠️  High memory usage: ${rss_mb}MB${NC}"
-                    log "High memory process detected: PID $pid, Memory: ${rss_mb}MB"
-
-                    # Ask user before killing (interactive mode)
-                    if [[ -t 0 ]]; then
-                        echo -n "Kill this process? (y/N): "
-                        read -r response
-                        if [[ "$response" =~ ^[Yy]$ ]]; then
-                            kill -TERM "$pid" 2>/dev/null || true
-                            sleep 2
-                            kill -KILL "$pid" 2>/dev/null || true
-                            echo "Process $pid terminated"
-                            log "Terminated high memory process: PID $pid"
-                        fi
-                    else
-                        # Non-interactive mode - just log
-                        log "High memory process (non-interactive): PID $pid, Memory: ${rss_mb}MB"
-                    fi
-                fi
-            fi
-        done
-    fi
-}
-
-cleanup_network_resources() {
-    log "Cleaning up network resources"
-
-    # Find and close hanging network connections
-    local hanging_connections=$(netstat -tnp 2>/dev/null | grep 'ESTABLISHED' | grep 'claude' || true)
-
-    if [[ -n "$hanging_connections" ]]; then
-        local connection_count=$(echo "$hanging_connections" | wc -l)
-        echo -e "${BLUE}Found $connection_count established Claude connections${NC}"
-
-        # Just log them - don't actively close as it might disrupt valid operations
-        log "Active connections: $connection_count"
-    fi
-}
-
-trim_memory_usage() {
-    log "Triggering memory trim operations"
-
-    # Trigger garbage collection if Node.js processes are running
-    local node_pids=$(pgrep -f "node.*claude" || true)
-
-    if [[ -n "$node_pids" ]]; then
-        echo -e "${BLUE}Triggering garbage collection for Node.js processes${NC}"
-
-        while read -r pid; do
-            if [[ -n "$pid" ]] && kill -0 "$pid" 2>/dev/null; then
-                # Send SIGUSR2 to trigger heap dump (if the process is configured to handle it)
-                kill -USR2 "$pid" 2>/dev/null || true
-                log "Sent memory trim signal to PID $pid"
-            fi
-        done <<< "$node_pids"
-    fi
-
-    # Linux-specific memory operations
-    if [[ -f /proc/sys/vm/drop_caches ]]; then
-        # Note: This requires root privileges
-        if [[ $EUID -eq 0 ]]; then
-            echo -e "${BLUE}Dropping system caches${NC}"
-            sync
-            echo 3 > /proc/sys/vm/drop_caches 2>/dev/null || true
-            log "Dropped system caches"
-        else
-            echo -e "${YELLOW}System cache drop requires root privileges${NC}"
-        fi
-    fi
-}
-
-generate_cleanup_report() {
-    log "Generating cleanup report"
-
-    echo ""
-    echo -e "${GREEN}=== Memory Cleanup Report ===${NC}"
-
-    # Current memory status
-    if command -v free &> /dev/null; then
-        echo -e "${BLUE}Current Memory Status:${NC}"
-        free -h
-        echo ""
-    fi
-
-    # Claude processes
-    local claude_pids=$(pgrep -f "claude" || true)
-    if [[ -n "$claude_pids" ]]; then
-        echo -e "${BLUE}Active Claude Processes:${NC}"
-        ps -p $claude_pids -o pid,pcpu,rss,etime,cmd 2>/dev/null || true
-        echo ""
-    else
-        echo -e "${GREEN}No active Claude processes found${NC}"
-        echo ""
-    fi
-
-    # Temporary files
-    if [[ -d "$PROFILE_DIR" ]]; then
-        local profile_count=$(find "$PROFILE_DIR" -name "*.heapprofile" 2>/dev/null | wc -l)
-        echo -e "${BLUE}Profile files: $profile_count${NC}"
-    fi
-
-    echo -e "${GREEN}Cleanup completed${NC}"
-    log "Cleanup report generated"
-}
-
-main() {
-    echo -e "${BLUE}Starting memory cleanup...${NC}"
-    log "Memory cleanup started"
-
-    # Wait a bit to allow processes to finish naturally
-    sleep $CLEANUP_DELAY
-
-    # Perform cleanup operations
-    cleanup_temp_files
-    cleanup_zombie_processes
-    cleanup_hanging_processes
-    cleanup_network_resources
-    trim_memory_usage
-
-    # Generate final report
-    generate_cleanup_report
-
-    log "Memory cleanup completed"
-}
-
-# Run main function
-main "$@"

package/claude-assets/skills/cfn-memory-persistence/lib/redis/SKILL.md

@@ -1,42 +0,0 @@
----
-name: cfn-redis-coordination
-description: Redis-based agent coordination with pub/sub and waiting mode
-version: 1.0.0
-tags: [redis, coordination, pub-sub, waiting-mode]
-status: production
----
-
-# Redis Coordination Submodule
-
-**Parent Skill:** cfn-memory-persistence
-**Purpose:** Redis-based coordination for agent synchronization and waiting mode
-
-## Components
-
-- `bash-wrappers/` - Bash wrapper scripts for Redis operations
-- `data/` - SQLite database for local persistence
-- `dist/` - Compiled TypeScript
-- `coverage/` - Test coverage reports
-
-## Key Operations
-
-- Agent waiting mode (BLPOP-based)
-- Confidence score collection
-- Context storage and retrieval
-- Swarm coordination signals
-- Agent completion tracking
-
-## Usage
-
-```bash
-# Invoke waiting mode
-./.claude/skills/cfn-memory-persistence/lib/redis/bash-wrappers/invoke-waiting-mode.sh \
-  --task-id "task-123" \
-  --agent-id "agent-456" \
-  --action wait
-
-# Store context
-./.claude/skills/cfn-memory-persistence/lib/redis/bash-wrappers/store-context.sh \
-  --task-id "task-123" \
-  --context "implementation context"
-```

package/claude-assets/skills/cfn-memory-persistence/lib/redis/agent-log.sh.backup

@@ -1,128 +0,0 @@
-#!/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
-
-# Source centralized Redis functions (provides graceful fallback for Task mode)
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "${SCRIPT_DIR}/redis-functions.sh"
-
-# 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-assets/skills/cfn-memory-persistence/lib/redis/agent-recovery.sh.backup

@@ -1,75 +0,0 @@
-#!/bin/bash
-# Redis Coordination Skill - Agent Emergency Recovery
-# Version: 1.0.0
-# Last Updated: 2025-10-19
-
-# Strict error handling
-set -euo pipefail
-
-# Default values
-TASK_ID=""
-AGENT_ID=""
-RECOVERY_MODE="soft"  # Options: soft, hard
-
-# Parse command-line arguments
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --task-id)
-            TASK_ID="$2"
-            shift 2
-            ;;
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --mode)
-            RECOVERY_MODE="$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
-
-# Log recovery attempt
-echo "[$(date -u)] Attempting ${RECOVERY_MODE} recovery for agent: ${AGENT_ID}" >> /var/log/claude-flow/agent-recovery.log
-
-# Retrieve agent context before recovery
-AGENT_CONTEXT=$(redis-cli get "swarm:${TASK_ID}:${AGENT_ID}:context")
-
-# Recovery actions based on mode
-case "$RECOVERY_MODE" in
-    "soft")
-        # Soft recovery: Spawn new agent with previous context
-        cfn-spawn agent "$AGENT_ID" \
-            --task-id "$TASK_ID" \
-            --recovery-context "$AGENT_CONTEXT"
-        ;;
-    "hard")
-        # Hard recovery: Full agent replacement
-        cfn-spawn agent "$AGENT_ID" \
-            --task-id "$TASK_ID" \
-            --mode replace \
-            --recovery-context "$AGENT_CONTEXT"
-        ;;
-    *)
-        echo "Invalid recovery mode: ${RECOVERY_MODE}"
-        exit 1
-        ;;
-esac
-
-# Update active agents set
-redis-cli sadd "swarm:${TASK_ID}:active-agents" "$AGENT_ID"
-
-# Log recovery completion
-echo "[$(date -u)] Recovery completed for agent: ${AGENT_ID}" >> /var/log/claude-flow/agent-recovery.log
-
-exit 0