claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/skills/cfn-memory-persistence/lib/auto/test-memory-persistence.sh

@@ -1,236 +0,0 @@
-#!/bin/bash
-# Comprehensive Test Suite for Automatic Memory Persistence Skill
-
-set -e
-
-# Source parameterized query library for SQL injection prevention
-PROJECT_ROOT="/mnt/c/Users/masha/Documents/claude-flow-novice"
-source "$PROJECT_ROOT/.claude/skills/bootstrap/sqlite-params.sh"
-
-# Temporary test database
-TEST_DB="/tmp/test_memory_persistence_$(date +%s).sqlite"
-
-# Mock SQLite database creation for testing
-setup_mock_database() {
-    sqlite3 "$TEST_DB" << EOF
-CREATE TABLE agent_outputs (
-    task_id TEXT NOT NULL,
-    agent_id TEXT NOT NULL,
-    output TEXT NOT NULL,
-    confidence REAL NOT NULL,
-    iteration INTEGER NOT NULL,
-    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (task_id, agent_id, iteration)
-);
-CREATE INDEX idx_agent_task ON agent_outputs(agent_id, task_id);
-EOF
-}
-
-# Mock persist-agent-output.sh for testing - using parameterized query
-mock_persist_agent_output() {
-    local task_id="$1"
-    local agent_id="$2"
-    local output="$3"
-    local confidence="$4"
-    local iteration="$5"
-
-    sqlite_upsert "$TEST_DB" \
-        "INSERT OR REPLACE INTO agent_outputs (task_id, agent_id, output, confidence, iteration) VALUES (?1, ?2, ?3, ?4, ?5);" \
-        "$task_id" "$agent_id" "$output" "$confidence" "$iteration"
-}
-
-# Mock query-agent-history.sh for testing - using parameterized query
-mock_query_agent_history() {
-    local agent_id="$1"
-    local task_id="$2"
-
-    sqlite_select "$TEST_DB" \
-        "SELECT task_id, agent_id, output, confidence, iteration FROM agent_outputs WHERE agent_id = ?1 AND task_id = ?2;" \
-        "$agent_id" "$task_id"
-}
-
-# Test 1: Successful output persistence with complete fields
-test_output_persistence() {
-    local task_id="test_task_complete_$(date +%s)"
-    local agent_id="test_agent_complete"
-    local test_output="Comprehensive agent output with complete details"
-    local confidence=0.95
-    local iteration=1
-
-    # Persist output
-    mock_persist_agent_output "$task_id" "$agent_id" "$test_output" "$confidence" "$iteration"
-
-    # Query and validate
-    local query_result
-    query_result=$(mock_query_agent_history "$agent_id" "$task_id")
-
-    if [ -z "$query_result" ]; then
-        echo "Test 1 failed: No output retrieved for complete fields"
-        return 1
-    fi
-
-    # Validate specific fields (using different field splitting)
-    local retrieved_task_id retrieved_agent_id retrieved_output retrieved_confidence retrieved_iteration
-    IFS='|' read -r retrieved_task_id retrieved_agent_id retrieved_output retrieved_confidence retrieved_iteration <<< "$query_result"
-
-    if [ "$retrieved_task_id" != "$task_id" ] ||
-       [ "$retrieved_agent_id" != "$agent_id" ] ||
-       [ "$retrieved_output" != "$test_output" ] ||
-       [ "$(echo "$retrieved_confidence != $confidence" | bc)" -eq 1 ] ||
-       [ "$retrieved_iteration" != "$iteration" ]; then
-        echo "Test 1 failed: Retrieved data does not match persisted data"
-        return 1
-    fi
-
-    echo "Test 1: Complete output persistence passed"
-    return 0
-}
-
-# Test 2: Multiple agent outputs for same task
-test_multiple_agent_outputs() {
-    local task_id="test_task_multiple_$(date +%s)"
-    local agent_id_1="test_agent_1"
-    local agent_id_2="test_agent_2"
-    local test_output_1="First agent output"
-    local test_output_2="Second agent output"
-    local confidence_1=0.85
-    local confidence_2=0.90
-    local iteration_1=1
-    local iteration_2=2
-
-    # Persist outputs for multiple agents
-    mock_persist_agent_output "$task_id" "$agent_id_1" "$test_output_1" "$confidence_1" "$iteration_1"
-    mock_persist_agent_output "$task_id" "$agent_id_2" "$test_output_2" "$confidence_2" "$iteration_2"
-
-    # Query and validate multiple agent outputs
-    local query_result_1 query_result_2
-    query_result_1=$(mock_query_agent_history "$agent_id_1" "$task_id")
-    query_result_2=$(mock_query_agent_history "$agent_id_2" "$task_id")
-
-    if [ -z "$query_result_1" ] || [ -z "$query_result_2" ]; then
-        echo "Test 2 failed: Missing outputs for multiple agents"
-        return 1
-    fi
-
-    echo "Test 2: Multiple agent outputs for same task passed"
-    return 0
-}
-
-# Test 3: Error handling for invalid/missing data
-test_invalid_data_handling() {
-    local task_id="test_task_invalid_$(date +%s)"
-    local agent_id="test_agent_invalid"
-
-    # Attempt to query non-existent data
-    local query_result
-    query_result=$(mock_query_agent_history "$agent_id" "$task_id")
-
-    if [ -n "$query_result" ]; then
-        echo "Test 3 failed: Non-empty result for non-existent data"
-        return 1
-    fi
-
-    echo "Test 3: Invalid data handling passed"
-    return 0
-}
-
-# Test 4: Iteration and confidence tracking
-test_iteration_confidence_tracking() {
-    local task_id="test_task_iterations_$(date +%s)"
-    local agent_id="test_agent_iterations"
-    local outputs=("Initial output" "Improved output" "Final output")
-    local confidences=(0.70 0.85 0.95)
-    local iterations=(1 2 3)
-
-    # Persist multiple iterations with increasing confidence
-    for i in "${!outputs[@]}"; do
-        mock_persist_agent_output "$task_id" "$agent_id" "${outputs[i]}" "${confidences[i]}" "${iterations[i]}"
-    done
-
-    # Verify iterations are tracked - using parameterized query
-    local iteration_count
-    iteration_count=$(sqlite_select "$TEST_DB" \
-        "SELECT COUNT(DISTINCT iteration) FROM agent_outputs WHERE task_id = ?1 AND agent_id = ?2;" \
-        "$task_id" "$agent_id")
-
-    if [ "$iteration_count" -ne 3 ]; then
-        echo "Test 4 failed: Incorrect iteration tracking"
-        return 1
-    fi
-
-    echo "Test 4: Iteration and confidence tracking passed"
-    return 0
-}
-
-# Test 5: ACL-level validation simulation
-test_acl_simulation() {
-    local task_id="test_task_acl_$(date +%s)"
-    local authorized_agent="authorized_agent"
-    local unauthorized_agent="unauthorized_agent"
-    local output="Confidential agent output"
-    local confidence=0.90
-    local iteration=1
-
-    # Simulate persisting output
-    mock_persist_agent_output "$task_id" "$authorized_agent" "$output" "$confidence" "$iteration"
-
-    # Verify authorized agent can access
-    local auth_query_result
-    auth_query_result=$(mock_query_agent_history "$authorized_agent" "$task_id")
-
-    if [ -z "$auth_query_result" ]; then
-        echo "Test 5 (Part A) failed: Authorized agent cannot access output"
-        return 1
-    fi
-
-    # Simulate unauthorized access attempt
-    local unauth_query_result
-    unauth_query_result=$(mock_query_agent_history "$unauthorized_agent" "$task_id")
-
-    if [ -n "$unauth_query_result" ]; then
-        echo "Test 5 (Part B) failed: Unauthorized agent could access output"
-        return 1
-    fi
-
-    echo "Test 5: ACL-level validation simulation passed"
-    return 0
-}
-
-# Main test runner
-main() {
-    echo "Running Comprehensive Memory Persistence Tests..."
-
-    # Setup test database
-    setup_mock_database
-
-    # Run tests
-    local total_tests=5
-    local passed_tests=0
-
-    # Execute each test
-    test_output_persistence && passed_tests=$((passed_tests+1))
-    test_multiple_agent_outputs && passed_tests=$((passed_tests+1))
-    test_invalid_data_handling && passed_tests=$((passed_tests+1))
-    test_iteration_confidence_tracking && passed_tests=$((passed_tests+1))
-    test_acl_simulation && passed_tests=$((passed_tests+1))
-
-    # Calculate confidence
-    local confidence=$(echo "scale=2; $passed_tests / $total_tests" | bc)
-
-    # Cleanup test database
-    rm -f "$TEST_DB"
-
-    # Report results
-    if [ "$passed_tests" -eq "$total_tests" ]; then
-        echo "All Memory Persistence Tests Passed!"
-        echo "Test Confidence: $confidence"
-        exit 0
-    else
-        echo "Memory Persistence Test Suite Failed: $passed_tests/$total_tests tests passed"
-        echo "Test Confidence: $confidence"
-        exit 1
-    fi
-}
-
-# Execute main test runner
-main

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

@@ -1,271 +0,0 @@
-# CFN Memory Management Skill
-
-**Purpose:** Prevent and detect memory leaks in Claude CLI operations through proactive monitoring, limits, and profiling.
-
-## Overview
-
-This skill implements memory leak prevention strategies based on real-world memory spike analysis. It provides automated memory monitoring, profiling, and safe defaults to prevent Claude CLI from exhausting system memory.
-
-## Features
-
-- **Automatic Memory Limits**: Configurable memory caps with safe defaults
-- **Heap Profiling**: Built-in profiling for memory allocation analysis
-- **Real-time Monitoring**: Live memory usage tracking with alerts
-- **Crash Detection**: Automatic detection of memory exhaustion events
-- **Profile Analysis**: Tools to analyze heap profiles and identify leaks
-
-## Configuration
-
-### Default Memory Limits
-```bash
-# Safe default (reduced from 16GB)
-export NODE_OPTIONS="--max-old-space-size=8192"
-
-# For production environments
-export CLAUDE_MEMORY_LIMIT="8GB"
-export CLAUDE_MEMORY_PROFILE_DIR="/tmp/claude-memory-profiles"
-```
-
-### Environment Variables
-- `CLAUDE_MEMORY_LIMIT`: Memory limit in MB (default: 8192)
-- `CLAUDE_MEMORY_PROFILE_DIR`: Directory for heap profiles (default: /tmp/claude-memory-profiles)
-- `CLAUDE_MEMORY_MONITORING`: Enable/disable monitoring (default: true)
-- `CLAUDE_MEMORY_ALERT_THRESHOLD`: Alert threshold in MB (default: 6144)
-
-## Usage
-
-### Start Claude with Memory Profiling
-```bash
-# Use the memory leak prevention script
-./scripts/memory-leak-prevention.sh profile --limit 6144
-
-# Or set environment manually
-export NODE_OPTIONS="--max-old-space-size=6144 --inspect=0.0.0.0:9229 --heap-prof"
-npx claude-flow-novice
-```
-
-### Monitor Existing Process
-```bash
-./scripts/memory-leak-prevention.sh monitor --pid 12345 --duration 600
-```
-
-### Install Debug Tools
-```bash
-./scripts/memory-leak-prevention.sh install-tools
-```
-
-### Analyze Memory Profiles
-```bash
-./scripts/memory-leak-prevention.sh analyze --output ./profiles
-```
-
-## Memory Leak Detection Patterns
-
-### High-Risk Indicators
-- RSS memory > 8GB within 5 minutes of launch
-- Multiple simultaneous TLS connections (>50)
-- High number of open files (>1000)
-- Large heap arenas (>1GB allocations)
-- Bun Pool worker count > 20
-
-### Automatic Detection
-The skill monitors for these patterns and triggers alerts:
-```bash
-# Check for memory spikes
-if [[ $rss_mb -gt 8192 ]]; then
-    log "⚠️  High memory usage detected: ${rss_mb}MB RSS"
-    # Trigger profiling dump
-    kill -USR2 $target_pid 2>/dev/null || true
-fi
-```
-
-## Integration with CFN Loop
-
-### Memory-Safe CFN Loop Execution
-```bash
-# Before starting CFN Loop
-export NODE_OPTIONS="--max-old-space-size=4096"
-export CLAUDE_MEMORY_MONITORING=true
-
-# Execute with memory bounds
-/cfn-loop-cli "task description" --mode=standard
-```
-
-### Agent Memory Management
-Agents spawned via CLI automatically inherit memory limits:
-```bash
-# Agent inherits parent process memory limits
-npx claude-flow-novice agent-spawn \
-  --agent-type backend-developer \
-  --memory-limit 2048 \
-  --enable-profiling
-```
-
-## Debugging Tools
-
-### Heap Profile Analysis
-```javascript
-// Analyze heap profile data
-const fs = require('fs');
-const profile = JSON.parse(fs.readFileSync('profile.heapprofile', 'utf8'));
-
-// Find largest allocations
-const allocations = profile.heapProfile.samples
-  .sort((a, b) => b.size - a.size)
-  .slice(0, 10);
-
-allocations.forEach((alloc, i) => {
-  console.log(`${i+1}. ${alloc.functionName}: ${(alloc.size/1024/1024).toFixed(2)}MB`);
-});
-```
-
-### Memory Usage Monitoring
-```bash
-# Real-time memory monitoring
-watch -n 5 'ps aux | grep claude | grep -v grep'
-
-# Network connection monitoring
-netstat -an | grep ESTABLISHED | grep -c
-
-# File descriptor monitoring
-lsof -p <PID> | wc -l
-```
-
-## Recovery Procedures
-
-### When Memory Leak Detected
-1. **Immediate Action**: Kill the process to prevent system exhaustion
-   ```bash
-   kill -9 <PID>
-   ```
-
-2. **Save Diagnostic Data**:
-   ```bash
-   # Save memory map
-   cat /proc/<PID>/smaps > memory-smaps.log
-
-   # Save process info
-   ps auxf > process-tree.log
-   ```
-
-3. **Restart with Limits**:
-   ```bash
-   export NODE_OPTIONS="--max-old-space-size=4096"
-   ./scripts/memory-leak-prevention.sh profile
-   ```
-
-### Automatic Recovery
-The skill includes automatic recovery mechanisms:
-- Memory threshold monitoring
-- Process termination on memory exhaustion
-- Automatic profile generation on crashes
-- Safe restart procedures
-
-## Performance Impact
-
-### Monitoring Overhead
-- **CPU**: < 1% overhead for monitoring
-- **Memory**: ~10MB additional for monitoring data
-- **I/O**: Minimal logging impact
-
-### Profiling Overhead
-- **CPU**: 10-15% overhead when profiling enabled
-- **Memory**: ~50MB additional for profile data
-- **Startup**: 2-3 second delay for profiler initialization
-
-## Best Practices
-
-### Development Environment
-```bash
-# Use profiling for development
-export NODE_OPTIONS="--max-old-space-size=4096 --inspect --heap-prof"
-```
-
-### Production Environment
-```bash
-# Use conservative limits
-export NODE_OPTIONS="--max-old-space-size=6144"
-export CLAUDE_MEMORY_MONITORING=false
-```
-
-### WSL Specific
-```bash
-# WSL memory optimization
-export NODE_OPTIONS="--max-old-space-size=4096"
-echo 1 | sudo tee /proc/sys/vm/overcommit_memory  # Enable memory overcommit
-```
-
-## Troubleshooting
-
-### Common Issues
-1. **High memory usage**: Reduce memory limit, restart with profiling
-2. **Slow performance**: Disable profiling in production
-3. **Connection issues**: Check WSL memory limits
-4. **Profile corruption**: Use larger memory limits for profiling
-
-### Debug Mode
-```bash
-# Enable verbose debugging
-export CLAUDE_MEMORY_DEBUG=true
-export CLAUDE_MEMORY_LOG_LEVEL=trace
-
-./scripts/memory-leak-prevention.sh profile --debug
-```
-
-## Integration Hooks
-
-### Pre-Execution Hook
-```bash
-#!/bin/bash
-# .claude/hooks/cfn-pre-execution/memory-check.sh
-
-./.claude/skills/cfn-memory-management/check-memory.sh
-if [[ $? -ne 0 ]]; then
-    echo "❌ Memory check failed. Please free memory before proceeding."
-    exit 1
-fi
-```
-
-### Post-Execution Hook
-```bash
-#!/bin/bash
-# .claude/hooks/cfn-post-execution/memory-cleanup.sh
-
-./.claude/skills/cfn-memory-management/cleanup-memory.sh
-```
-
-## Metrics and Monitoring
-
-### Key Metrics
-- RSS memory usage
-- Heap size and allocation patterns
-- Number of open file descriptors
-- Network connection count
-- Process/thread count
-
-### Alert Thresholds
-- **Critical**: RSS > 8GB or connections > 100
-- **Warning**: RSS > 6GB or connections > 50
-- **Info**: RSS > 4GB or connections > 25
-
-## Dependencies
-
-- `node` >= 18.0.0
-- `strace` (for system call tracing)
-- `perf` (for performance profiling)
-- `lsof` (for file descriptor monitoring)
-- `ps` (for process monitoring)
-
-## Security Considerations
-
-- Profiles may contain sensitive data - stored in /tmp with restricted permissions
-- Debugging ports should not be exposed publicly
-- Memory limits prevent DoS attacks
-- All temporary files are automatically cleaned up
-
-## Version History
-
-- **v1.0.0**: Initial implementation based on memory leak analysis
-- **v1.1.0**: Added automatic recovery mechanisms
-- **v1.2.0**: Integrated with CFN Loop orchestration
-- **v1.3.0**: Added WSL-specific optimizations

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

@@ -1,160 +0,0 @@
-#!/bin/bash
-
-# Memory Check Script for CFN Operations
-# Pre-execution hook to ensure sufficient memory is available
-
-set -euo pipefail
-
-# Configuration
-MIN_FREE_MB=2048  # Minimum 2GB free memory required
-WARNING_THRESHOLD_MB=4096  # Warning at 4GB
-LOG_FILE="/tmp/cfn-memory-check.log"
-
-# Colors
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-GREEN='\033[0;32m'
-NC='\033[0m'
-
-log() {
-    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
-}
-
-check_system_memory() {
-    local total_mb=0
-    local available_mb=0
-    local used_mb=0
-
-    if command -v free &> /dev/null; then
-        # Linux/WSL
-        local mem_info=$(free -m | awk 'NR==2{print $2,$3,$7}')
-        total_mb=$(echo "$mem_info" | cut -d' ' -f1)
-        used_mb=$(echo "$mem_info" | cut -d' ' -f2)
-        available_mb=$(echo "$mem_info" | cut -d' ' -f3)
-    elif command -v vm_stat &> /dev/null; then
-        # macOS
-        local page_size=$(vm_stat | head -1 | sed 's/.*page size of \([0-9]*\).*/\1/')
-        local free_pages=$(vm_stat | awk '/free/ {gsub(/\./, "", $3); print $3}')
-        local active_pages=$(vm_stat | awk '/active/ {gsub(/\./, "", $3); print $3}')
-        local inactive_pages=$(vm_stat | awk '/inactive/ {gsub(/\./, "", $3); print $3}')
-        local wired_pages=$(vm_stat | awk '/wired/ {gsub(/\./, "", $3); print $3}')
-
-        total_mb=$(((active_pages + inactive_pages + wired_pages + free_pages) * page_size / 1024 / 1024))
-        available_mb=$((free_pages * page_size / 1024 / 1024))
-        used_mb=$((total_mb - available_mb))
-    else
-        log "ERROR: Cannot determine system memory (free/vm_stat not available)"
-        return 1
-    fi
-
-    echo "${total_mb},${used_mb},${available_mb}"
-}
-
-check_claude_processes() {
-    local claude_pids=$(pgrep -f "claude" || true)
-    local total_claude_memory=0
-    local process_count=0
-
-    if [[ -n "$claude_pids" ]]; then
-        while read -r pid; do
-            if [[ -n "$pid" ]] && kill -0 "$pid" 2>/dev/null; then
-                local rss_kb=$(ps -p "$pid" -o rss= --no-headers 2>/dev/null || echo "0")
-                local rss_mb=$((rss_kb / 1024))
-                total_claude_memory=$((total_claude_memory + rss_mb))
-                process_count=$((process_count + 1))
-            fi
-        done <<< "$claude_pids"
-    fi
-
-    echo "${process_count},${total_claude_memory}"
-}
-
-main() {
-    log "Starting memory check for CFN operation"
-
-    # Check system memory
-    local mem_info=$(check_system_memory)
-    IFS=',' read -r total_mb used_mb available_mb <<< "$mem_info"
-
-    echo "System Memory Status:"
-    echo "  Total: ${total_mb}MB"
-    echo "  Used: ${used_mb}MB"
-    echo "  Available: ${available_mb}MB"
-
-    # Check Claude processes
-    local claude_info=$(check_claude_processes)
-    IFS=',' read -r claude_count claude_memory_mb <<< "$claude_info"
-
-    if [[ $claude_count -gt 0 ]]; then
-        echo "Claude Processes:"
-        echo "  Count: $claude_count"
-        echo "  Memory: ${claude_memory}MB"
-    fi
-
-    # Calculate available memory for new operation
-    local available_for_operation=$((available_mb - claude_memory_mb))
-
-    echo "Available for CFN operation: ${available_for_operation}MB"
-
-    # Check thresholds
-    if [[ $available_for_operation -lt $MIN_FREE_MB ]]; then
-        echo -e "${RED}❌ Insufficient memory for CFN operation${NC}"
-        echo "Required: ${MIN_FREE_MB}MB, Available: ${available_for_operation}MB"
-        echo ""
-        echo "Suggestions:"
-        echo "  1. Close existing Claude processes: pkill -f claude"
-        echo "  2. Free system memory: sudo sync && sudo sysctl vm.drop_caches=3"
-        echo "  3. Restart your terminal/shell session"
-        echo "  4. Reduce memory requirements with smaller tasks"
-
-        log "CRITICAL: Insufficient memory - Required: ${MIN_FREE_MB}MB, Available: ${available_for_operation}MB"
-        return 1
-    elif [[ $available_for_operation -lt $WARNING_THRESHOLD_MB ]]; then
-        echo -e "${YELLOW}⚠️  Low memory warning${NC}"
-        echo "Available: ${available_for_operation}MB (Recommended: ${WARNING_THRESHOLD_MB}MB+)"
-        echo "Consider closing other applications for optimal performance"
-
-        log "WARNING: Low memory - Available: ${available_for_operation}MB"
-    else
-        echo -e "${GREEN}✅ Sufficient memory available${NC}"
-        log "OK: Sufficient memory - Available: ${available_for_operation}MB"
-    fi
-
-    # Check for memory leak indicators
-    if [[ $claude_count -gt 0 ]]; then
-        local avg_claude_memory=$((claude_memory_mb / claude_count))
-        if [[ $avg_claude_memory -gt 4096 ]]; then
-            echo -e "${YELLOW}⚠️  High Claude memory usage detected${NC}"
-            echo "Average per process: ${avg_claude_memory}MB"
-            echo "Consider restarting Claude processes"
-
-            log "WARNING: High Claude memory usage - Average: ${avg_claude_memory}MB"
-        fi
-    fi
-
-    # Check WSL-specific issues
-    if [[ -f /proc/version ]] && grep -qi microsoft /proc/version; then
-        echo "WSL Environment Detected:"
-
-        # Check WSL memory limits
-        if [[ -f /proc/meminfo ]]; then
-            local wsl_total=$(grep MemTotal /proc/meminfo | awk '{print int($2/1024)}')
-            if [[ $wsl_total -lt 8192 ]]; then
-                echo -e "${YELLOW}⚠️  Low WSL memory limit: ${wsl_total}MB${NC}"
-                echo "Consider increasing WSL memory in .wslconfig"
-                echo ""
-                echo "Create %USERPROFILE%\\.wslconfig with:"
-                echo "[wsl2]"
-                echo "memory=16GB"
-                echo "swap=4GB"
-            fi
-        fi
-    fi
-
-    echo ""
-    echo "Memory check completed successfully"
-    return 0
-}
-
-# Run main function
-main "$@"