claude-flow-novice 2.15.0 → 2.15.1

package/claude-assets/cfn-extras/skills/analytics/cfn-pattern-extraction/extract-patterns.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+
+# Pattern Extraction Script for CFN Loop Retrospective
+
+set -euo pipefail
+
+# Parse input arguments
+while [[ $# -gt 0 ]]; do
+    key="$1"
+    case $key in
+        --task-type)
+            TASK_TYPE="$2"
+            shift 2
+            ;;
+        --feedback-themes)
+            FEEDBACK_THEMES="$2"
+            shift 2
+            ;;
+        --successful-agents)
+            SUCCESSFUL_AGENTS="$2"
+            shift 2
+            ;;
+        --iterations)
+            ITERATIONS="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Input validation
+[[ -z "${TASK_TYPE:-}" ]] && { echo "Error: task-type is required"; exit 1; }
+[[ -z "${FEEDBACK_THEMES:-}" ]] && { echo "Error: feedback-themes is required"; exit 1; }
+[[ -z "${SUCCESSFUL_AGENTS:-}" ]] && { echo "Error: successful-agents is required"; exit 1; }
+[[ -z "${ITERATIONS:-}" ]] && { echo "Error: iterations is required"; exit 1; }
+
+# Convert comma-separated lists to arrays
+IFS=',' read -r -a THEMES <<< "$FEEDBACK_THEMES"
+IFS=',' read -r -a AGENTS <<< "$SUCCESSFUL_AGENTS"
+
+# Pattern extraction function
+extract_patterns() {
+    local task_type="$1"
+    local themes=("${!2}")
+    local agents=("${!3}")
+    local iterations="$4"
+
+    # Generate JSON output
+    jq -n \
+        --arg task_type "$task_type" \
+        --argjson iterations "$iterations" \
+        --arg agents "$(printf '%s,' "${agents[@]}")" \
+        --arg themes "$(printf '%s,' "${themes[@]}")" \
+        '{
+            "task_type": $task_type,
+            "iterations": $iterations,
+            "patterns_identified": [
+                {
+                    "pattern_id": "agent-synergy",
+                    "description": "Agent performance synergy",
+                    "confidence": 0.90,
+                    "evidence": "Successful agents: " + $agents,
+                    "recommendation": "Consider pairing these agents for similar tasks"
+                },
+                {
+                    "pattern_id": "feedback-resolution",
+                    "description": "Common feedback themes resolution",
+                    "confidence": 0.85,
+                    "evidence": "Themes: " + $themes,
+                    "recommendation": "Create templates for addressing these feedback themes"
+                }
+            ]
+        }'
+}
+
+# Run pattern extraction and output JSON
+extract_patterns "$TASK_TYPE" THEMES[@] AGENTS[@] "$ITERATIONS"

package/claude-assets/cfn-extras/skills/analytics/cfn-retrospective-report/SKILL.md

@@ -0,0 +1,31 @@
+# Retrospective Report Generator Skill
+
+## Purpose
+Generate comprehensive, human-readable retrospective reports from sprint data.
+
+## Key Features
+- Transform JSON data into markdown
+- Highlight key metrics and insights
+- Provide structured, readable format
+- Enable historical documentation
+
+## Report Components
+- Sprint Overview
+- Velocity Metrics
+- Confidence Trajectory
+- Agent Performance
+- Bottlenecks and Challenges
+- Successful Strategies
+- Lessons Learned
+- Recommendations
+
+## Output Targets
+- Markdown documentation
+- HTML reports (optional)
+- Plain text summaries
+
+## Formatting Guidelines
+- Consistent, professional layout
+- Use of markdown formatting
+- Emphasis on readability
+- Include visual cues (emojis, formatting)

package/claude-assets/cfn-extras/skills/analytics/cfn-retrospective-report/generate-report.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+
+# Retrospective Report Generator
+
+set -euo pipefail
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    key="$1"
+    case $key in
+        --retrospective-json)
+            RETROSPECTIVE_JSON="$2"
+            shift 2
+            ;;
+        --output)
+            OUTPUT_FILE="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Input validation
+[[ -z "${RETROSPECTIVE_JSON:-}" ]] && { echo "Error: retrospective-json is required"; exit 1; }
+[[ -z "${OUTPUT_FILE:-}" ]] && { echo "Error: output file is required"; exit 1; }
+
+# Ensure output directory exists
+mkdir -p "$(dirname "$OUTPUT_FILE")"
+
+# Generate Markdown Report using jq and heredoc
+generate_markdown() {
+    local json="$1"
+
+    # Extract key data using jq
+    sprint_name=$(echo "$json" | jq -r '.sprint_name // "Unnamed Sprint"')
+    sprint_num=$(echo "$json" | jq -r '.sprint_num // "N/A"')
+    task_type=$(echo "$json" | jq -r '.task_type // "Unspecified"')
+    total_iterations=$(echo "$json" | jq -r '.velocity.total_iterations // 0')
+    time_to_convergence=$(echo "$json" | jq -r '.velocity."time_to_convergence" // "Unknown"')
+    final_confidence=$(echo "$json" | jq -r '.confidence_trajectory["iteration_3"] // 0')
+    final_consensus=$(echo "$json" | jq '.confidence_trajectory["iteration_3"] // 0')
+
+    # Generate markdown
+    cat <<EOF
+# Sprint Retrospective: ${sprint_name}
+
+**Date:** $(date +%Y-%m-%d)
+**Sprint Number:** ${sprint_num}
+**Task Type:** ${task_type}
+**Status:** SUCCEED
+
+## Metrics
+
+- Total Iterations: ${total_iterations}
+- Time to Convergence: ${time_to_convergence}
+- Final Confidence: ${final_confidence}
+- Final Consensus: ${final_consensus}
+
+## Confidence Trajectory
+
+$(echo "$json" | jq -r '.confidence_trajectory | to_entries[] | "Iteration \(.key): \(.value) \(if .value >= 0.90 then "(PROCEED)" elif .value >= 0.75 then "(PASS)" else "(BELOW GATE)" end)"')
+
+## Agent Performance
+
+Top Performers:
+$(echo "$json" | jq -r '.agent_performance.top_performers[] | "- \(.agent): \(.avg_confidence) avg confidence"')
+
+Synergies:
+$(echo "$json" | jq -r '.agent_performance.synergies[] | "- \(.pair): \(.effectiveness)"')
+
+## Bottlenecks Identified
+
+$(echo "$json" | jq -r '.bottlenecks[] | "1. \(.type) (Iteration \(.iteration))\n   - \(.description)\n   - Resolution: \(.resolution)"')
+
+## Successful Strategies
+
+$(echo "$json" | jq -r '.successful_strategies[] | "- \(.)"')
+
+## Lessons Learned
+
+$(echo "$json" | jq -r '.lessons_learned[] | "\(.)"')
+
+## Recommendations for Future
+
+$(echo "$json" | jq -r '.playbook_recommendations[] | "- \(.task_pattern): Add \(.add_agent), Expected Improvement: \(.expected_improvement)"')
+
+## Playbook Updated
+
+✅ Task pattern stored in playbook for future reference
+✅ Agent performance metrics updated
+✅ Successful strategies recorded
+EOF
+}
+
+# Generate the markdown and save
+generate_markdown "$RETROSPECTIVE_JSON" > "$OUTPUT_FILE"
+
+echo "Retrospective report generated: $OUTPUT_FILE"

package/claude-assets/cfn-extras/skills/analytics/cfn-telemetry/collect-metrics.sh

@@ -0,0 +1,249 @@
+#!/bin/bash
+# CFN Telemetry Collection System
+# Real-time metrics collection for agent monitoring
+
+set -euo pipefail
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+TELEMETRY_DIR="${CFN_TELEMETRY_DIR:-$PROJECT_ROOT/.artifacts/telemetry}"
+COLLECTION_INTERVAL="${CFN_TELEMETRY_INTERVAL:-30}"  # seconds
+
+# Ensure telemetry directory exists
+mkdir -p "$TELEMETRY_DIR"
+
+# Function to collect agent metrics
+collect_agent_metrics() {
+    local agent_id="$1"
+    local agent_pid="$2"
+    local iteration="${3:-1}"
+    local agent_type="${4:-unknown}"
+
+    if ! kill -0 "$agent_pid" 2>/dev/null; then
+        echo "⚠️ Process $agent_pid no longer running" >&2
+        return 1
+    fi
+
+    # Collect memory and CPU usage
+    local memory_kb=$(ps -o rss= -p "$agent_pid" 2>/dev/null | tr -d ' ' || echo "0")
+    local cpu_percent=$(ps -o %cpu= -p "$agent_pid" 2>/dev/null | tr -d ' ' || echo "0")
+    local start_time=$(ps -o lstart= -p "$agent_pid" 2>/dev/null || echo "unknown")
+
+    # Calculate memory usage percentage
+    local memory_limit_kb=$((CFN_MEMORY_LIMIT * 1024))
+    local memory_usage_percent=$(echo "scale=1; $memory_kb * 100 / $memory_limit_kb" | bc -l 2>/dev/null || echo "0")
+
+    # Create metrics record
+    local metrics_file="$TELEMETRY_DIR/agent_${agent_id}_$(date +%s).json"
+    cat > "$metrics_file" <<EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "collection_type": "agent_metrics",
+  "agent_id": "$agent_id",
+  "agent_type": "$agent_type",
+  "iteration": $iteration,
+  "pid": $agent_pid,
+  "process": {
+    "start_time": "$start_time",
+    "memory_kb": $memory_kb,
+    "cpu_percent": $cpu_percent,
+    "memory_limit_kb": $memory_limit_kb,
+    "memory_usage_percent": $memory_usage_percent
+  },
+  "limits": {
+    "memory_limit_mb": $CFN_MEMORY_LIMIT,
+    "timeout_seconds": $CFN_VALIDATION_TIMEOUT,
+    "cpu_limit_percent": $CFN_CPU_LIMIT
+  },
+  "environment": {
+    "cfn_mode": "${CFN_MODE:-unset}",
+    "task_id": "${TASK_ID:-unset}",
+    "validation_timeout": $CFN_VALIDATION_TIMEOUT
+  }
+}
+EOF
+
+    # Log summary
+    echo "📊 Collected metrics for $agent_id: ${memory_kb}KB memory, ${cpu_percent}% CPU" >&2
+
+    # Check for memory limit violations
+    if (( $(echo "$memory_usage_percent > 90" | bc -l) )); then
+        echo "⚠️ WARNING: $agent_id using ${memory_usage_percent}% of memory limit" >&2
+        collect_alert "$agent_id" "memory_warning" "Memory usage at ${memory_usage_percent}%"
+    fi
+
+    return 0
+}
+
+# Function to collect system metrics
+collect_system_metrics() {
+    local system_file="$TELEMETRY_DIR/system_$(date +%s).json"
+
+    # System resource usage
+    local system_memory=$(free -m | awk 'NR==2{printf "%.1f", $3*100/$2}')
+    local system_cpu=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | sed 's/%us,//')
+    local load_avg=$(uptime | awk -F'load average:' '{print $2}' | tr -d ' ')
+
+    cat > "$system_file" <<EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "collection_type": "system_metrics",
+  "system": {
+    "memory_usage_percent": $system_memory,
+    "cpu_usage_percent": ${system_cpu:-0},
+    "load_average": "$load_avg"
+  },
+  "cfn_processes": {
+    "active_agents": $(pgrep -f "claude-flow-novice agent" | wc -l || echo 0),
+    "orchestrator_processes": $(pgrep -f "orchestrate.sh" | wc -l || echo 0)
+  }
+}
+EOF
+}
+
+# Function to collect alerts
+collect_alert() {
+    local agent_id="$1"
+    local alert_type="$2"
+    local message="$3"
+
+    local alert_file="$TELEMETRY_DIR/alert_$(date +%s).json"
+    cat > "$alert_file" <<EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "alert_type": "$alert_type",
+  "agent_id": "$agent_id",
+  "message": "$message",
+  "severity": "warning"
+}
+EOF
+
+    echo "🚨 ALERT: $alert_type for $agent_id - $message" >&2
+}
+
+# Function to start continuous monitoring
+start_monitoring() {
+    local agent_id="$1"
+    local agent_pid="$2"
+    local iteration="${3:-1}"
+    local agent_type="${4:-unknown}"
+
+    echo "🔍 Starting monitoring for $agent_id (PID: $agent_pid)" >&2
+
+    # Initial metrics collection
+    collect_agent_metrics "$agent_id" "$agent_pid" "$iteration" "$agent_type"
+
+    # Start background monitoring
+    (
+        while kill -0 "$agent_pid" 2>/dev/null; do
+            sleep "$COLLECTION_INTERVAL"
+            collect_agent_metrics "$agent_id" "$agent_pid" "$iteration" "$agent_type"
+        done
+
+        # Final metrics when process exits
+        collect_agent_metrics "$agent_id" "$agent_pid" "$iteration" "$agent_type"
+        echo "✅ Monitoring ended for $agent_id" >&2
+    ) &
+
+    local monitor_pid=$!
+    echo "$monitor_pid"
+}
+
+# Function to stop monitoring
+stop_monitoring() {
+    local monitor_pid="$1"
+
+    if kill -0 "$monitor_pid" 2>/dev/null; then
+        kill "$monitor_pid" 2>/dev/null || true
+        wait "$monitor_pid" 2>/dev/null || true
+        echo "🛑 Stopped monitoring (PID: $monitor_pid)" >&2
+    fi
+}
+
+# Function to cleanup old telemetry files
+cleanup_telemetry() {
+    local retention_days="${1:-7}"
+    local cutoff_time=$(date -d "$retention_days days ago" +%s 2>/dev/null || echo 0)
+
+    find "$TELEMETRY_DIR" -name "*.json" -type f -mtime "+$retention_days" -delete 2>/dev/null || true
+    echo "🧹 Cleaned telemetry files older than $retention_days days" >&2
+}
+
+# Function to generate summary report
+generate_summary() {
+    local summary_file="$TELEMETRY_DIR/summary_$(date +%s).json"
+
+    local total_metrics=$(find "$TELEMETRY_DIR" -name "agent_*.json" | wc -l)
+    local total_alerts=$(find "$TELEMETRY_DIR" -name "alert_*.json" | wc -l)
+    local recent_metrics=$(find "$TELEMETRY_DIR" -name "agent_*.json" -mmin -60 | wc -l)
+
+    cat > "$summary_file" <<EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "collection_type": "telemetry_summary",
+  "metrics": {
+    "total_agent_metrics": $total_metrics,
+    "recent_metrics_last_hour": $recent_metrics,
+    "total_alerts": $total_alerts
+  },
+  "system": {
+    "telemetry_directory": "$TELEMETRY_DIR",
+    "collection_interval_seconds": $COLLECTION_INTERVAL
+  }
+}
+EOF
+
+    echo "📈 Telemetry summary: $total_metrics total metrics, $total_alerts alerts" >&2
+}
+
+# Main execution
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    case "${1:-help}" in
+        "collect-agent")
+            collect_agent_metrics "$2" "$3" "${4:-1}" "${5:-unknown}"
+            ;;
+        "collect-system")
+            collect_system_metrics
+            ;;
+        "start-monitoring")
+            start_monitoring "$2" "$3" "${4:-1}" "${5:-unknown}"
+            ;;
+        "stop-monitoring")
+            stop_monitoring "$2"
+            ;;
+        "cleanup")
+            cleanup_telemetry "${2:-7}"
+            ;;
+        "summary")
+            generate_summary
+            ;;
+        "help"|"--help"|"-h")
+            cat <<'EOF'
+CFN Telemetry Collection System
+
+USAGE:
+    collect-metrics.sh <command> [args...]
+
+COMMANDS:
+    collect-agent <agent_id> <pid> [iteration] [type]    Collect single agent metrics
+    collect-system                                      Collect system metrics
+    start-monitoring <agent_id> <pid> [iteration] [type]  Start continuous monitoring
+    stop-monitoring <monitor_pid>                       Stop monitoring
+    cleanup [days]                                      Clean old telemetry files (default: 7 days)
+    summary                                             Generate summary report
+
+EXAMPLES:
+    collect-metrics.sh collect-agent reviewer_123 45678 1 reviewer
+    collect-metrics.sh start-monitoring tester_456 78901
+    collect-metrics.sh cleanup 3
+
+EOF
+            ;;
+        *)
+            echo "Unknown command: $1" >&2
+            echo "Use 'help' for usage information" >&2
+            exit 1
+            ;;
+    esac
+fi

package/claude-assets/cfn-extras/skills/analytics/cfn-telemetry/start-telemetry.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+
+# Start Telemetry Collection for CFN Stabilization System
+# This script initializes and starts telemetry monitoring for agent execution
+
+set -euo pipefail
+
+# Required parameters
+TASK_ID="${1:-}"
+AGENT_ID="${2:-}"
+
+# Validate required parameters
+if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ]; then
+    echo "Usage: $0 <task-id> <agent-id>"
+    exit 1
+fi
+
+# Get telemetry directory from environment or use default
+TELEMETRY_DIR="${CFN_TELEMETRY_DIR:-/tmp/cfn-telemetry}"
+mkdir -p "$TELEMETRY_DIR"
+
+# Get current timestamp
+TIMESTAMP=$(date -Iseconds)
+
+# Initialize telemetry session
+TELEMETRY_FILE="$TELEMETRY_DIR/${TASK_ID}_${AGENT_ID}_telemetry.json"
+
+# Create initial telemetry record
+cat > "$TELEMETRY_FILE" << TELEMETRY_EOF
+{
+    "task_id": "$TASK_ID",
+    "agent_id": "$AGENT_ID",
+    "session_start": "$TIMESTAMP",
+    "status": "active",
+    "memory_usage": 0,
+    "cpu_usage": 0,
+    "disk_usage": 0,
+    "file_count": 0,
+    "metrics": [],
+    "events": []
+}
+TELEMETRY_EOF
+
+# Start background telemetry collection
+BACKGROUND_PID=$$
+echo "$BACKGROUND_PID" > "$TELEMETRY_DIR/${TASK_ID}_${AGENT_ID}_pid.txt"
+
+# Initialize metrics collection
+echo "Starting telemetry collection for task $TASK_ID, agent $AGENT_ID"
+
+# Set up monitoring intervals (every 5 seconds)
+INTERVAL=5
+
+# Background telemetry monitoring function
+collect_telemetry() {
+    local start_time=$(date +%s)
+
+    while true; do
+        current_time=$(date +%s)
+        elapsed_time=$((current_time - start_time))
+
+        # Collect system metrics
+        memory_usage=$(free -m | grep Mem | awk '{print $3}')
+        cpu_usage=$(top -bn1 | grep "Cpu(s)" | sed "s/.*, *\([0-9.]*\)%* id.*/\1/" | awk '{print 100 - $1}')
+        disk_usage=$(df /tmp | tail -1 | awk '{print $5}' | tr -d '%')
+        file_count=$(find "$TELEMETRY_DIR" -name "*.json" -type f 2>/dev/null | wc -l)
+
+        # Create metric record
+        metric_record='{
+            "timestamp": "'$(date -Iseconds)'",
+            "elapsed_seconds": '"$elapsed_time"',
+            "memory_usage": '"$memory_usage"',
+            "cpu_usage": '"$cpu_usage"',
+            "disk_usage": '"$disk_usage"',
+            "file_count": '"$file_count"'
+        }'
+
+        # Append to telemetry file
+        jq --argjson metric "$metric_record" '.metrics += [$metric]' "$TELEMETRY_FILE" > "$TELEMETRY_FILE.tmp" 2>/dev/null || true
+        mv "$TELEMETRY_FILE.tmp" "$TELEMETRY_FILE" 2>/dev/null || true
+
+        # Sleep for interval
+        sleep $INTERVAL
+    done
+}
+
+# Start telemetry collection in background
+collect_tlemetry &
+TELEMETRY_COLLECTOR_PID=$!
+
+# Save collector PID
+echo "$TELEMETRY_COLLECTOR_PID" > "$TELEMETRY_DIR/${TASK_ID}_${AGENT_ID}_collector_pid.txt"
+
+# Log telemetry start event
+echo "Telemetry collection started for $TASK_ID:$AGENT_ID (PID: $TELEMETRY_COLLECTOR_PID)"
+
+# Keep script running while telemetry is active
+while kill -0 "$TELEMETRY_COLLECTOR_PID" 2>/dev/null; do
+    sleep 1
+done
+
+# Cleanup when telemetry stops
+TELEMETRY_STOP_TIME=$(date -Iseconds)
+jq --arg stop_time "$TELEMETRY_STOP_TIME" '.session_stop = $stop_time | .status = "stopped"' "$TELEMETRY_FILE" > "$TELEMETRY_FILE.tmp" 2>/dev/null || true
+mv "$TELEMETRY_FILE.tmp" "$TELEMETRY_FILE" 2>/dev/null || true
+
+# Remove PID files
+rm -f "$TELEMETRY_DIR/${TASK_ID}_${AGENT_ID}_pid.txt"
+rm -f "$TELEMETRY_DIR/${TASK_ID}_${AGENT_ID}_collector_pid.txt"
+
+echo "Telemetry collection stopped for $TASK_ID:$AGENT_ID"