claude-flow-novice 2.10.4 → 2.10.6

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

@@ -0,0 +1,121 @@
+#!/bin/bash
+# Claude Flow: Security Scanning Hook
+# Version: 1.4.0
+
+set -euo pipefail
+
+# Security Scanning Configuration
+SCAN_TYPES=(
+    "SQL_INJECTION"
+    "XSS_VULNERABILITY"
+    "HARDCODED_SECRETS"
+    "INSECURE_DEPENDENCIES"
+)
+
+# Logging Configuration
+LOG_DIR=".artifacts/security-logs"
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+LOG_FILE="${LOG_DIR}/security-scan-${TIMESTAMP}.log"
+
+# Ensure log directory exists
+mkdir -p "${LOG_DIR}"
+
+# Create log file
+touch "${LOG_FILE}"
+
+# Security Scanning Function
+run_security_scan() {
+    local file_path="$1"
+    local file_extension="${file_path##*.}"
+    local scan_confidence=0
+    local vulnerabilities=()
+
+    echo "Scanning file: ${file_path}" >&2
+
+    # SQL Injection Detection
+    if grep -qE "(SELECT|INSERT|UPDATE|DELETE).*['\"].*['\"]" "${file_path}"; then
+        vulnerabilities+=("SQL_INJECTION")
+        ((scan_confidence+=25))
+    fi
+
+    # XSS Vulnerability Detection
+    if grep -qE "innerHTML|document\.write|eval\(" "${file_path}"; then
+        vulnerabilities+=("XSS_VULNERABILITY")
+        ((scan_confidence+=25))
+    fi
+
+    # Hardcoded Secrets Detection
+    if grep -qE "(password|secret|token|api_key).*=.*['\"]" "${file_path}"; then
+        vulnerabilities+=("HARDCODED_SECRETS")
+        ((scan_confidence+=25))
+    fi
+
+    # Dependency Vulnerability Detection (Basic)
+    if [[ "${file_extension}" == "json" ]] && grep -qE '"(version|dependencies)"' "${file_path}"; then
+        # Check for vulnerable package versions using basic regex (can be expanded)
+        if grep -qE '"(version|dependencies)".*[0-9]+\.[0-9]+\.[0-9]+' "${file_path}"; then
+            vulnerabilities+=("INSECURE_DEPENDENCIES")
+            ((scan_confidence+=25))
+        fi
+    fi
+
+    # Output JSON Results
+    local json_result
+    json_result=$(jq -n \
+        --arg confidence "${scan_confidence}" \
+        --arg passed "$([ ${#vulnerabilities[@]} -eq 0 ] && echo true || echo false)" \
+        --arg vulns "$(printf '%s\n' "${vulnerabilities[@]}" | jq -R . | jq -s .)" \
+        '{
+            passed: ($passed | test("true")),
+            confidence: ($confidence | tonumber),
+            vulnerabilities: $vulns
+        }')
+
+    # Write to log
+    if [ ${#vulnerabilities[@]} -gt 0 ]; then
+        echo "Security Vulnerabilities Detected in ${file_path}:" >&2
+        for vuln in "${vulnerabilities[@]}"; do
+            echo " - ${vuln}" >&2
+        done
+        echo "Confidence Score: ${scan_confidence}/100" >&2
+    else
+        echo "No security vulnerabilities detected in ${file_path}" >&2
+    fi
+
+    # Output JSON
+    echo "${json_result}"
+}
+
+# Main Security Scanning Logic
+main() {
+    local file_path="${1:?Provide file path to scan}"
+
+    # Skip scanning for certain file types or paths
+    if [[ "${file_path}" =~ \.(min\.|test\.|spec\.) ]]; then
+        jq -n '{
+            passed: true,
+            confidence: 100,
+            vulnerabilities: []
+        }'
+        exit 0
+    fi
+
+    run_security_scan "${file_path}"
+    exit_code=$?
+
+    # Exit with appropriate code for coordination
+    case ${exit_code} in
+        0)
+            exit 0  # No vulnerabilities
+            ;;
+        1)
+            exit 2  # Vulnerabilities detected (non-blocking)
+            ;;
+        *)
+            exit 1  # Unexpected error
+            ;;
+    esac
+}
+
+# Entry point
+main "$@"

package/claude-assets/skills/cfn-hook-pipeline/test-root-warning-resolution.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+set -e
+
+RESULTS_FILE=".artifacts/analytics/root-warning-test.json"
+LOG_FILE=".artifacts/logs/post-edit-pipeline.log"
+mkdir -p .artifacts/analytics .artifacts/logs
+
+echo "═══════════════════════════════════════════════════════════"
+echo "🧪 Testing ROOT_WARNING Detection (50 test files)"
+echo "Hook Pipeline: Detect files in root, warn with suggested location"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+
+# Track results
+TOTAL_FILES=0
+WARNINGS_DETECTED=0
+FAILED_DETECTION=0
+declare -a FAILED_TESTS
+
+test_root_warning() {
+  local filename=$1
+  local expected_location=$2
+
+  TOTAL_FILES=$((TOTAL_FILES + 1))
+
+  # Create file in root directory (trigger ROOT_WARNING)
+  echo "Test content $TOTAL_FILES - $(date)" > "$filename"
+
+  echo -n "[Test $TOTAL_FILES] Creating $filename in root... "
+
+  # Run post-edit hook to detect ROOT_WARNING
+  local warning_detected=false
+  local suggested=""
+
+  # Check if hook script exists
+  if [ -f "config/hooks/post-edit-pipeline.js" ]; then
+    # Run actual hook (captures output)
+    HOOK_OUTPUT=$(node config/hooks/post-edit-pipeline.js "$filename" --memory-key "test/root-warning/$TOTAL_FILES" 2>&1)
+
+    # Check if ROOT_WARNING was printed
+    if echo "$HOOK_OUTPUT" | grep -q "ROOT DIRECTORY WARNING"; then
+      warning_detected=true
+      # Extract suggested location from output
+      suggested=$(echo "$HOOK_OUTPUT" | grep -A 1 "SUGGESTED LOCATIONS" | tail -1 | sed 's/.*\. \(.*\) (.*/\1/' | xargs)
+    fi
+
+    # Also check log file if it exists
+    if [ -f "$LOG_FILE" ]; then
+      LAST_LOG=$(tail -1 "$LOG_FILE" 2>/dev/null || echo '{}')
+      status=$(echo "$LAST_LOG" | jq -r '.status // "UNKNOWN"' 2>/dev/null || echo "UNKNOWN")
+      if [ "$status" = "ROOT_WARNING" ]; then
+        warning_detected=true
+      fi
+    fi
+  fi
+
+  # Validate warning detection
+  if [ "$warning_detected" = true ]; then
+    echo "✅ WARNING detected (suggested: $suggested or similar)"
+    WARNINGS_DETECTED=$((WARNINGS_DETECTED + 1))
+  else
+    echo "❌ No WARNING detected"
+    FAILED_DETECTION=$((FAILED_DETECTION + 1))
+    FAILED_TESTS+=("$filename (expected warning)")
+  fi
+
+  # Cleanup
+  rm -f "$filename"
+}
+
+echo "──────────────────────────────────────"
+echo "Testing source files (10 tests)"
+echo "──────────────────────────────────────"
+for i in {1..10}; do
+  test_root_warning "test-source-$i.js" "src/test-source-$i.js"
+done
+
+echo ""
+echo "──────────────────────────────────────"
+echo "Testing documentation files (10 tests)"
+echo "──────────────────────────────────────"
+for i in {1..10}; do
+  test_root_warning "test-doc-$i.md" "docs/test-doc-$i.md"
+done
+
+echo ""
+echo "──────────────────────────────────────"
+echo "Testing configuration files (10 tests)"
+echo "──────────────────────────────────────"
+for i in {1..10}; do
+  test_root_warning "test-config-$i.json" "config/test-config-$i.json"
+done
+
+echo ""
+echo "──────────────────────────────────────"
+echo "Testing test files (10 tests)"
+echo "──────────────────────────────────────"
+for i in {1..10}; do
+  test_root_warning "test-spec-$i.test.js" "tests/test-spec-$i.test.js"
+done
+
+echo ""
+echo "──────────────────────────────────────"
+echo "Testing script files (10 tests)"
+echo "──────────────────────────────────────"
+for i in {1..10}; do
+  test_root_warning "test-script-$i.sh" "scripts/test-script-$i.sh"
+done
+
+# Calculate detection rate
+DETECTION_RATE=$(echo "scale=2; ($WARNINGS_DETECTED / $TOTAL_FILES) * 100" | bc)
+
+# Generate report
+cat > $RESULTS_FILE << REPORT
+{
+  "total_files_tested": $TOTAL_FILES,
+  "warnings_detected": $WARNINGS_DETECTED,
+  "failed_detection": $FAILED_DETECTION,
+  "detection_rate": $DETECTION_RATE,
+  "passed": $(echo "$DETECTION_RATE == 100.00" | bc -l | grep -q 1 && echo "true" || echo "false"),
+  "threshold": 100,
+  "test_type": "warning_detection",
+  "test_date": "$(date -I)"
+}
+REPORT
+
+echo ""
+echo "═══════════════════════════════════════════════════════════"
+echo "TEST RESULTS"
+echo "═══════════════════════════════════════════════════════════"
+cat $RESULTS_FILE
+echo ""
+
+if [ $FAILED_DETECTION -gt 0 ]; then
+  echo "⚠️  Failed tests:"
+  for test in "${FAILED_TESTS[@]}"; do
+    echo "   - $test"
+  done
+  echo ""
+fi
+
+if echo "$DETECTION_RATE == 100.00" | bc -l | grep -q 1; then
+  echo "✅ SUCCESS: 100% ROOT_WARNING detection rate ($WARNINGS_DETECTED/$TOTAL_FILES)"
+  exit 0
+else
+  echo "❌ FAILED: ${DETECTION_RATE}% detection rate ($WARNINGS_DETECTED/$TOTAL_FILES detected)"
+  exit 1
+fi

package/claude-assets/skills/cfn-hybrid-routing/README.md

@@ -0,0 +1,50 @@
+# Hybrid Routing Skill
+
+## Overview
+Provides adaptive routing strategies for distributed communication systems, supporting multiple communication channels and fallback mechanisms.
+
+## Features
+- Dynamic route selection
+- Primary and secondary communication channels
+- Load-balanced path selection
+- Contextual routing strategies
+
+## Dependencies
+- jq
+- redis-cli
+- openssl
+- (Optional) websocketd
+
+## Configuration
+Refer to `config.json` for detailed routing configuration parameters.
+
+### Spawning Workers
+```bash
+./spawn-worker.sh
+```
+
+### Dependency Check
+```bash
+./check-dependencies.sh
+```
+
+## Performance Targets
+- Routing Accuracy: ≥0.85
+- Channel Transition Time: <50ms
+- Packet Loss: Minimal
+
+## Security
+- TLS 1.3 Encryption
+- JWT Authentication
+- Rate Limiting
+
+## Usage Example
+```bash
+# Spawn routing workers
+.claude/skills/hybrid-routing/spawn-worker.sh
+```
+
+## Troubleshooting
+1. Ensure all dependencies are installed
+2. Verify Redis server connectivity
+3. Check network configurations

package/claude-assets/skills/cfn-hybrid-routing/SKILL.md

@@ -0,0 +1,46 @@
+# Hybrid Routing Skill
+
+## Overview
+Implements adaptive routing strategies for distributed systems with multi-channel communication.
+
+## Purpose
+- Dynamic route selection
+- Fallback mechanism implementation
+- Performance optimization
+- Low-latency communication channels
+
+## Routing Strategies
+1. Primary-Secondary Channel Routing
+2. Load-balanced Path Selection
+3. Contextual Routing
+
+## Configuration Parameters
+- `primary_channel`: Main communication route
+- `secondary_channel`: Backup communication path
+- `routing_algorithm`: Routing selection method
+- `latency_threshold`: Maximum acceptable delay
+
+## Operational Modes
+- Synchronous Routing
+- Asynchronous Routing
+- Failover Routing
+
+## Dependencies
+- Redis Pub/Sub
+- Agent Coordination Framework
+- Performance Monitoring
+
+## Security Considerations
+- Encrypted channel selection
+- Authentication for route transitions
+- Minimal exposure surface
+
+## Performance Metrics
+- Route success rate
+- Channel switching latency
+- Routing decision confidence
+
+## Validation Criteria
+- ≥0.85 routing accuracy
+- <50ms channel transition time
+- Minimal packet loss

package/claude-assets/skills/cfn-hybrid-routing/check-dependencies.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Hybrid Routing Skill Dependency Checker
+
+DEPENDENCIES=(
+    "jq"
+    "redis-cli"
+    "openssl"
+)
+
+OPTIONAL_DEPENDENCIES=(
+    "websocketd"
+)
+
+check_dependency() {
+    local dep="$1"
+    if ! command -v "$dep" &> /dev/null; then
+        echo "Error: Dependency '$dep' not found."
+        return 1
+    fi
+}
+
+main() {
+    echo "Checking Required Dependencies for Hybrid Routing Skill..."
+
+    # Check required dependencies
+    for dep in "${DEPENDENCIES[@]}"; do
+        if ! check_dependency "$dep"; then
+            echo "CRITICAL: Unable to proceed without $dep"
+            exit 1
+        fi
+    done
+
+    # Check optional dependencies
+    for dep in "${OPTIONAL_DEPENDENCIES[@]}"; do
+        if ! command -v "$dep" &> /dev/null; then
+            echo "Warning: Optional dependency '$dep' not found. Some advanced routing features may be limited."
+        fi
+    done
+
+    # Additional Redis connectivity check
+    if ! redis-cli ping &> /dev/null; then
+        echo "Error: Cannot connect to Redis server"
+        exit 1
+    fi
+
+    echo "✅ All dependencies validated successfully"
+    exit 0
+}
+
+main "$@"

package/claude-assets/skills/cfn-hybrid-routing/config.json

@@ -0,0 +1,26 @@
+{
+    "skill_name": "hybrid-routing",
+    "version": "1.0.0",
+    "routing_strategies": {
+        "primary": {
+            "type": "redis-pubsub",
+            "priority": 1,
+            "latency_threshold_ms": 50
+        },
+        "secondary": {
+            "type": "websocket",
+            "priority": 2,
+            "latency_threshold_ms": 100
+        }
+    },
+    "performance_targets": {
+        "routing_accuracy": 0.85,
+        "channel_transition_time_ms": 50,
+        "packet_loss_percentage": 0.01
+    },
+    "security_configuration": {
+        "encryption": "TLS_1_3",
+        "authentication_method": "JWT",
+        "rate_limit_per_second": 1000
+    }
+}

package/claude-assets/skills/cfn-hybrid-routing/spawn-worker.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Hybrid Routing Worker Spawner
+# Dynamically configures and launches routing workers
+
+CONFIG_PATH="$(dirname "$0")/config.json"
+
+# Load configuration
+SKILL_NAME=$(jq -r '.skill_name' "$CONFIG_PATH")
+PRIMARY_CHANNEL=$(jq -r '.routing_strategies.primary.type' "$CONFIG_PATH")
+SECONDARY_CHANNEL=$(jq -r '.routing_strategies.secondary.type' "$CONFIG_PATH")
+
+# Worker spawning function
+spawn_routing_worker() {
+    local channel_type="$1"
+    local worker_id="$2"
+
+    case "$channel_type" in
+        "redis-pubsub")
+            ./.claude/skills/cfn-redis-coordination/spawn-agent.sh \
+                --skill-id "$SKILL_NAME" \
+                --agent-id "routing-worker-$worker_id" \
+                --strategy "$channel_type"
+            ;;
+        "websocket")
+            ./.claude/skills/cfn-agent-spawning/spawn-agent.sh \
+                --skill-id "$SKILL_NAME" \
+                --agent-id "routing-worker-$worker_id" \
+                --strategy "$channel_type"
+            ;;
+        *)
+            echo "Unsupported channel type: $channel_type"
+            exit 1
+            ;;
+    esac
+}
+
+# Spawn primary and secondary workers
+spawn_routing_worker "$PRIMARY_CHANNEL" "primary"
+spawn_routing_worker "$SECONDARY_CHANNEL" "secondary"
+
+# Final status report
+echo "Hybrid Routing Workers Spawned Successfully"

package/claude-assets/skills/cfn-improvement-recommender/SKILL.md

@@ -0,0 +1,33 @@
+# Improvement Recommender Skill
+
+## Purpose
+Generate actionable improvement suggestions based on sprint retrospective data.
+
+## Core Capabilities
+- Analyze sprint performance metrics
+- Identify bottlenecks and inefficiencies
+- Recommend targeted improvements
+- Provide confidence scores for recommendations
+
+## Recommendation Categories
+- Agent Selection
+- Feedback Processing
+- Validation Criteria
+- Iteration Management
+- Complexity Estimation
+
+## Evaluation Criteria
+- Frequency of issue occurrence
+- Impact on sprint velocity
+- Cost of implementing recommendation
+- Potential performance improvement
+
+## Improvement Scoring Model
+- Confidence Level (0.0 - 1.0)
+- Expected Benefit Quantification
+- Implementation Complexity Rating
+
+## Continuous Learning
+- Track recommendation effectiveness
+- Update recommendation strategies
+- Learn from successful interventions

package/claude-assets/skills/cfn-improvement-recommender/recommend-improvements.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+
+# Improvement Recommendation Script
+
+set -euo pipefail
+
+# Parse input arguments
+while [[ $# -gt 0 ]]; do
+    key="$1"
+    case $key in
+        --task-type)
+            TASK_TYPE="$2"
+            shift 2
+            ;;
+        --bottlenecks)
+            BOTTLENECKS="$2"
+            shift 2
+            ;;
+        --iterations)
+            ITERATIONS="$2"
+            shift 2
+            ;;
+        --estimated)
+            ESTIMATED_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 "${BOTTLENECKS:-}" ]] && { echo "Error: bottlenecks is required"; exit 1; }
+[[ -z "${ITERATIONS:-}" ]] && { echo "Error: iterations is required"; exit 1; }
+[[ -z "${ESTIMATED_ITERATIONS:-}" ]] && { echo "Error: estimated iterations is required"; exit 1; }
+
+# Convert comma-separated lists to arrays
+IFS=',' read -r -a BOTTLENECK_LIST <<< "$BOTTLENECKS"
+
+# Improvement recommendation function
+recommend_improvements() {
+    local task_type="$1"
+    local bottlenecks=("${!2}")
+    local iterations="$3"
+    local estimated_iterations="$4"
+
+    # Calculate iteration efficiency
+    local efficiency=$(echo "scale=2; $estimated_iterations / $iterations" | bc)
+
+    # Generate JSON output with improvement recommendations
+    jq -n \
+        --arg task_type "$task_type" \
+        --argjson iterations "$iterations" \
+        --arg estimated_iterations "$estimated_iterations" \
+        --arg efficiency "$efficiency" \
+        --arg bottlenecks "$(printf '%s,' "${bottlenecks[@]}")" \
+        '{
+            "task_type": $task_type,
+            "actual_iterations": $iterations,
+            "estimated_iterations": $estimated_iterations,
+            "iteration_efficiency": $efficiency,
+            "improvements": [
+                {
+                    "category": "agent_selection",
+                    "suggestion": "Refine agent selection based on task complexity",
+                    "expected_benefit": "Reduce iterations by adding specialized agents",
+                    "confidence": 0.85,
+                    "impacted_bottlenecks": $bottlenecks
+                },
+                {
+                    "category": "feedback_processing",
+                    "suggestion": "Create standardized feedback templates",
+                    "expected_benefit": "Faster issue resolution",
+                    "confidence": 0.75,
+                    "impacted_bottlenecks": $bottlenecks
+                },
+                {
+                    "category": "iteration_optimization",
+                    "suggestion": "Implement dynamic iteration scaling",
+                    "expected_benefit": "More precise iteration planning",
+                    "confidence": 0.80,
+                    "current_efficiency": $efficiency
+                }
+            ]
+        }'
+}
+
+# Run improvement recommendation and output JSON
+recommend_improvements "$TASK_TYPE" BOTTLENECK_LIST[@] "$ITERATIONS" "$ESTIMATED_ITERATIONS"

package/claude-assets/skills/cfn-intervention-detector/SKILL.md

@@ -0,0 +1,39 @@
+# Intervention Detector Skill
+
+## Purpose
+Detect problematic patterns in agent performance during CFN Loop iterations that may require intervention.
+
+## Detection Mechanisms
+1. **Confidence Plateau**:
+   - Minimal confidence improvement over multiple iterations
+   - Threshold: Δ < 0.05 for 2+ consecutive iterations
+
+2. **Recurring Feedback**:
+   - Same feedback theme repeated 3+ times
+   - Indicates underlying issue not being addressed
+
+3. **Deliverables Stuck**:
+   - No new files created in 2+ consecutive iterations
+
+## Configuration
+- Configurable thresholds
+- Flexible input parsing
+- JSON output for easy integration
+
+## Usage
+```bash
+./detect-intervention.sh \
+  --iteration N \
+  --confidence-history "0.72,0.75,0.76" \
+  --feedback-history "theme1;theme2;theme3"
+```
+
+## Output Formats
+- Trigger type
+- Detailed reasoning
+- Recommended action
+
+## Implementation Notes
+- Use bash for performance
+- Minimize external dependencies
+- Provide clear, actionable output