claude-flow-novice 2.9.1 → 2.10.0

package/.claude/skills/cfn-ace-system/monitor-injection-performance.sh

@@ -0,0 +1,138 @@
+#!/bin/bash
+# ACE System: Context Injection Performance Monitoring
+# Phase 3.3 Performance Tracking
+
+set -euo pipefail
+
+# Logging setup
+TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")
+LOG_DIR="/tmp/ace-performance-logs"
+PERFORMANCE_LOG="${LOG_DIR}/injection-performance-${TIMESTAMP}.log"
+METRICS_FILE="${LOG_DIR}/injection-metrics-${TIMESTAMP}.json"
+
+mkdir -p "${LOG_DIR}"
+
+# Redis connection parameters (use environment variables or defaults)
+REDIS_HOST="${REDIS_HOST:-localhost}"
+REDIS_PORT="${REDIS_PORT:-6379}"
+REDIS_DB="${REDIS_DB:-0}"
+
+# Performance tracking functions
+log_message() {
+    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "${PERFORMANCE_LOG}"
+}
+
+calculate_percentile() {
+    local percentiles=("$@")
+    local temp_file=$(mktemp)
+
+    # Sort and calculate percentiles
+    for p in "${percentiles[@]}"; do
+        local percentile_value=$(sort -n "${temp_file}" | awk -v p="${p}" 'BEGIN{c=0} NR>=int(NR*p/100+1){print $1; exit}')
+        echo "P${p}: ${percentile_value}"
+    done
+
+    rm "${temp_file}"
+}
+
+# Injection Performance Monitoring
+monitor_injection_performance() {
+    local domain_metrics_key="cfn_ace:injection:domain_metrics"
+    local latency_key="cfn_ace:injection:latency"
+
+    # Collect domain-specific metrics
+    local domain_hits=$(redis-cli -h "${REDIS_HOST}" -p "${REDIS_PORT}" -n "${REDIS_DB}" \
+        HGETALL "${domain_metrics_key}")
+
+    # Collect latency measurements
+    local latency_measurements=$(redis-cli -h "${REDIS_HOST}" -p "${REDIS_PORT}" -n "${REDIS_DB}" \
+        LRANGE "${latency_key}" 0 -1)
+
+    # Performance Analysis
+    log_message "Collecting Injection Performance Metrics..."
+
+    # Domain Hit Rates
+    log_message "Domain Hit Rates:"
+    echo "${domain_hits}" | while read -r domain hits; do
+        log_message "  ${domain}: ${hits} hits"
+    done
+
+    # Latency Analysis
+    log_message "Latency Analysis:"
+    local percentiles=(50 95 99)
+    local p_results=$(calculate_percentile "${percentiles[@]}" <<< "${latency_measurements}")
+    log_message "${p_results}"
+
+    # Identify Slow Queries
+    local threshold_ms=500  # 500ms threshold for slow queries
+    local slow_queries=$(echo "${latency_measurements}" | awk -v threshold="${threshold_ms}" '$1 > threshold')
+
+    if [ -n "${slow_queries}" ]; then
+        log_message "Slow Queries Detected (>${threshold_ms}ms):"
+        log_message "${slow_queries}"
+    fi
+
+    # Generate Performance Report
+    generate_performance_report
+}
+
+generate_performance_report() {
+    local report_file="${LOG_DIR}/injection-performance-report-${TIMESTAMP}.json"
+
+    jq -n \
+        --arg timestamp "${TIMESTAMP}" \
+        --arg log_file "${PERFORMANCE_LOG}" \
+        --argjson percentiles_50 50 \
+        --argjson percentiles_95 95 \
+        --argjson percentiles_99 99 \
+        '{
+            "timestamp": $timestamp,
+            "log_file": $log_file,
+            "performance_metrics": {
+                "p50_latency_ms": $percentiles_50,
+                "p95_latency_ms": $percentiles_95,
+                "p99_latency_ms": $percentiles_99
+            },
+            "recommendations": [
+                "Investigate SQLite query optimization",
+                "Consider additional Redis caching",
+                "Review domain classifier performance"
+            ]
+        }' > "${report_file}"
+
+    log_message "Performance Report Generated: ${report_file}"
+}
+
+# Main Execution
+main() {
+    log_message "Starting ACE System Injection Performance Monitoring"
+
+    # Pre-flight checks
+    command -v redis-cli >/dev/null 2>&1 || {
+        log_message "Error: redis-cli not found. Please install Redis.";
+        exit 1;
+    }
+
+    command -v jq >/dev/null 2>&1 || {
+        log_message "Error: jq not found. Please install jq.";
+        exit 1;
+    }
+
+    monitor_injection_performance
+
+    log_message "Injection Performance Monitoring Complete"
+}
+
+# Run main and capture exit status
+main "$@"
+exit_status=$?
+
+# Optional: Send metrics to centralized monitoring
+# This could be expanded to push to Prometheus, DataDog, etc.
+if [ ${exit_status} -eq 0 ]; then
+    log_message "Performance monitoring successful"
+else
+    log_message "Performance monitoring encountered issues"
+fi
+
+exit ${exit_status}

package/.claude/skills/cfn-ace-system/optimize-injection-pipeline.sh

@@ -0,0 +1,169 @@
+#!/bin/bash
+# ACE System: Context Injection Pipeline Optimization
+# Phase 3.3 Performance Enhancement
+
+set -euo pipefail
+
+# Logging and Configuration
+TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")
+LOG_DIR="/tmp/ace-optimization-logs"
+OPTIMIZATION_LOG="${LOG_DIR}/injection-optimization-${TIMESTAMP}.log"
+BENCHMARK_RESULTS="${LOG_DIR}/benchmark-${TIMESTAMP}.json"
+
+mkdir -p "${LOG_DIR}"
+
+# Configuration Parameters
+REDIS_TTL=3600  # 1 hour cache TTL
+CACHE_WARMUP_DOMAINS=("software_engineering" "devops" "machine_learning" "data_science")
+SQLITE_CACHE_SIZE=2000  # Prepare statements cache size
+
+log_message() {
+    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "${OPTIMIZATION_LOG}"
+}
+
+# Redis Caching Strategy
+configure_redis_cache() {
+    local redis_host="${REDIS_HOST:-localhost}"
+    local redis_port="${REDIS_PORT:-6379}"
+
+    log_message "Configuring Redis Caching Strategy"
+
+    # Set global cache configuration
+    redis-cli -h "${redis_host}" -p "${redis_port}" \
+        CONFIG SET maxmemory-policy allkeys-lru
+    redis-cli -h "${redis_host}" -p "${redis_port}" \
+        CONFIG SET maxmemory 1GB
+
+    # Warm up cache for common domains
+    for domain in "${CACHE_WARMUP_DOMAINS[@]}"; do
+        log_message "Warming up cache for domain: ${domain}"
+        redis-cli -h "${redis_host}" -p "${redis_port}" \
+            SETEX "cfn_ace:domain_cache:${domain}" "${REDIS_TTL}" "$(generate_domain_cache_entry "${domain}")"
+    done
+}
+
+generate_domain_cache_entry() {
+    local domain="$1"
+    # Simulate generating a comprehensive domain context entry
+    jq -n \
+        --arg domain "${domain}" \
+        '{
+            "domain": $domain,
+            "anti_patterns": ["over_engineering", "premature_optimization"],
+            "best_practices": ["modular_design", "clear_interfaces"],
+            "timestamp": now
+        }'
+}
+
+# SQLite Optimization
+optimize_sqlite_queries() {
+    local sqlite_db="/path/to/ace_system.sqlite"
+
+    log_message "Optimizing SQLite Query Performance"
+
+    # Prepare common anti-pattern queries
+    sqlite3 "${sqlite_db}" << EOF
+    -- Pragma configurations for performance
+    PRAGMA journal_mode=WAL;
+    PRAGMA cache_size=-${SQLITE_CACHE_SIZE};
+    PRAGMA mmap_size=30000000;
+
+    -- Prepared statements for common queries
+    PREPARE anti_pattern_query AS
+        SELECT * FROM anti_patterns
+        WHERE domain = ? AND confidence_threshold > ?;
+EOF
+
+    log_message "SQLite optimization complete"
+}
+
+# Benchmark Performance Improvements
+benchmark_performance() {
+    local iterations=50
+    local total_time_before=0
+    local total_time_after=0
+
+    log_message "Running Performance Benchmarks"
+
+    # Benchmark Before Optimization
+    for ((i=1; i<=iterations; i++)); do
+        local start_time=$(date +%s.%N)
+        run_sample_context_injection "before"
+        local end_time=$(date +%s.%N)
+        total_time_before=$(echo "${total_time_before} + (${end_time} - ${start_time})" | bc)
+    done
+
+    # Apply Optimizations
+    configure_redis_cache
+    optimize_sqlite_queries
+
+    # Benchmark After Optimization
+    for ((i=1; i<=iterations; i++)); do
+        local start_time=$(date +%s.%N)
+        run_sample_context_injection "after"
+        local end_time=$(date +%s.%N)
+        total_time_after=$(echo "${total_time_after} + (${end_time} - ${start_time})" | bc)
+    done
+
+    # Calculate Performance Improvement
+    local avg_before=$(echo "scale=4; ${total_time_before} / ${iterations}" | bc)
+    local avg_after=$(echo "scale=4; ${total_time_after} / ${iterations}" | bc)
+    local improvement_percentage=$(echo "scale=2; (1 - ${avg_after} / ${avg_before}) * 100" | bc)
+
+    # Generate Benchmark Report
+    jq -n \
+        --arg timestamp "${TIMESTAMP}" \
+        --arg avg_before "${avg_before}" \
+        --arg avg_after "${avg_after}" \
+        --arg improvement "${improvement_percentage}" \
+        '{
+            "timestamp": $timestamp,
+            "before_optimization_avg_ms": $avg_before,
+            "after_optimization_avg_ms": $avg_after,
+            "improvement_percentage": $improvement
+        }' > "${BENCHMARK_RESULTS}"
+
+    log_message "Performance Improvement: ${improvement_percentage}%"
+}
+
+# Simulate Context Injection for Benchmarking
+run_sample_context_injection() {
+    local phase="$1"
+    # Simulate context injection process
+    local domain="software_engineering"
+
+    if [ "${phase}" == "before" ]; then
+        # Simulate non-optimized path
+        redis-cli HGET "cfn_ace:domain_metrics" "${domain}"
+    else
+        # Simulate optimized path with Redis cache
+        redis-cli HGETALL "cfn_ace:domain_cache:${domain}"
+    fi
+}
+
+# Main Execution
+main() {
+    log_message "Starting ACE System Context Injection Optimization"
+
+    # Pre-flight checks
+    command -v redis-cli >/dev/null 2>&1 || {
+        log_message "Error: redis-cli not found. Please install Redis.";
+        exit 1;
+    }
+
+    command -v sqlite3 >/dev/null 2>&1 || {
+        log_message "Error: sqlite3 not found. Please install SQLite.";
+        exit 1;
+    }
+
+    benchmark_performance
+
+    log_message "Context Injection Optimization Complete"
+}
+
+# Execute main function
+main "$@"
+exit_status=$?
+
+# Exit with benchmark status
+exit ${exit_status}

package/.claude/skills/cfn-ace-system/query-anti-patterns.sh

@@ -0,0 +1,276 @@
+#!/bin/bash
+
+# ACE System Anti-Pattern Query System
+# Purpose: Query relevant anti-patterns based on task classification to prevent repeating mistakes
+# Usage: query-anti-patterns.sh "task description" [--limit N] [--format json|simple]
+
+set -euo pipefail
+
+TASK_DESCRIPTION=""
+LIMIT=3
+MIN_CONFIDENCE=0.0
+OUTPUT_FORMAT="json"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --limit)
+      LIMIT="$2"
+      shift 2
+      ;;
+    --min-confidence)
+      MIN_CONFIDENCE="$2"
+      shift 2
+      ;;
+    --format)
+      OUTPUT_FORMAT="$2"
+      shift 2
+      ;;
+    *)
+      if [ -z "$TASK_DESCRIPTION" ]; then
+        TASK_DESCRIPTION="$1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+if [ -z "$TASK_DESCRIPTION" ]; then
+  echo "Usage: query-anti-patterns.sh 'task description' [--limit N] [--format json|simple]" >&2
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+DB_PATH="${PROJECT_ROOT}/ace-context.db"
+CLASSIFIER_PATH="${SCRIPT_DIR}/../cfn-task-classifier/classify-task.sh"
+
+# Verify dependencies
+if [ ! -f "$CLASSIFIER_PATH" ]; then
+  echo "ERROR: Task classifier not found at $CLASSIFIER_PATH" >&2
+  exit 1
+fi
+
+if [ ! -f "$DB_PATH" ]; then
+  echo "ERROR: ACE database not found at $DB_PATH" >&2
+  exit 1
+fi
+
+# Step 1: Classify task to extract domains
+CLASSIFICATION=$("$CLASSIFIER_PATH" "$TASK_DESCRIPTION" --format=json)
+if [ $? -ne 0 ]; then
+  echo "ERROR: Task classification failed" >&2
+  exit 1
+fi
+
+DOMAINS=$(echo "$CLASSIFICATION" | jq -r '.domains[]' 2>/dev/null || echo "")
+COMPLEXITY=$(echo "$CLASSIFICATION" | jq -r '.complexity' 2>/dev/null || echo "medium")
+TASK_TYPE=$(echo "$CLASSIFICATION" | jq -r '.task_type' 2>/dev/null || echo "general")
+
+# Handle empty domains
+if [ -z "$DOMAINS" ]; then
+  DOMAINS="general"
+fi
+
+# Step 2: Query anti-patterns by domain with severity sorting
+TEMP_RESULTS="/tmp/ace-antipattern-results-$$.json"
+echo "[]" > "$TEMP_RESULTS"
+
+for DOMAIN in $DOMAINS; do
+  # Query anti-patterns for this domain
+  QUERY_RESULT=$(sqlite3 "$DB_PATH" -json << EOF
+SELECT
+  id,
+  reflection_type,
+  json_extract(extracted_lessons, '\$.anti_pattern') as anti_pattern,
+  json_extract(extracted_lessons, '\$.solution') as solution,
+  json_extract(extracted_lessons, '\$.impact') as impact,
+  json_extract(metadata, '\$.severity') as severity,
+  json_extract(metadata, '\$.domain') as domain,
+  json_extract(metadata, '\$.sprint_ref') as sprint_ref,
+  json_extract(metadata, '\$.keywords') as keywords,
+  json_extract(execution_trace, '\$.iterations') as iterations_caused,
+  confidence,
+  created_at,
+  success_count,
+  total_count
+FROM context_reflections
+WHERE reflection_type IN ('anti-pattern', 'warning', 'failure')
+  AND (
+    json_extract(metadata, '\$.domain') = '$DOMAIN'
+    OR json_extract(metadata, '\$.domain') = 'general'
+  )
+  AND confidence >= $MIN_CONFIDENCE
+  AND curator_status IN ('curated', 'pending')
+ORDER BY
+  CASE json_extract(metadata, '\$.severity')
+    WHEN 'critical' THEN 1
+    WHEN 'high' THEN 2
+    WHEN 'medium' THEN 3
+    ELSE 4
+  END,
+  confidence DESC,
+  created_at DESC;
+EOF
+)
+
+  # Merge results
+  if [ -n "$QUERY_RESULT" ] && [ "$QUERY_RESULT" != "[]" ]; then
+    MERGED=$(jq -s '.[0] + .[1]' "$TEMP_RESULTS" <(echo "$QUERY_RESULT"))
+    echo "$MERGED" > "$TEMP_RESULTS"
+  fi
+done
+
+# Step 3: Deduplication - remove similar anti-patterns
+# Strategy: Group by first 60 characters of anti_pattern, keep highest confidence
+DEDUPED_RESULTS=$(jq '
+  group_by(.anti_pattern[:60]) |
+  map(
+    sort_by(-.confidence) |
+    .[0]
+  )
+' "$TEMP_RESULTS")
+
+echo "$DEDUPED_RESULTS" > "$TEMP_RESULTS"
+
+# Step 4: Calculate relevance scores
+# Scoring factors:
+# - Severity weight: 50% (critical=1.0, high=0.8, medium=0.5, low=0.3)
+# - Domain match: 30% (exact=1.0, general=0.5)
+# - Recency: 10% (exponential decay, half-life=90 days)
+# - Frequency: 10% (based on usage ratio: success_count/total_count)
+
+SCORED_RESULTS=$(jq --arg current_date "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '
+  map(
+    . as $item |
+
+    # Calculate severity score
+    (
+      if .severity == "critical" then 1.0
+      elif .severity == "high" then 0.8
+      elif .severity == "medium" then 0.5
+      elif .severity == "low" then 0.3
+      else 0.4
+      end
+    ) as $severity_score |
+
+    # Calculate domain match score
+    (
+      if (.domain | type == "array") then
+        if (.domain | any(. == $item.domain)) then 1.0 else 0.5 end
+      else
+        if .domain == $item.domain then 1.0 else 0.5 end
+      end
+    ) as $domain_score |
+
+    # Calculate recency score (exponential decay)
+    # Handle both Unix timestamps and SQLite datetime strings
+    (
+      if (.created_at | type == "number") then
+        .created_at
+      elif (.created_at | type == "string") then
+        (.created_at | gsub(" "; "T") | . + "Z" | fromdateiso8601)
+      else
+        ($current_date | fromdateiso8601)
+      end
+    ) as $created_timestamp |
+
+    (
+      (
+        ($current_date | fromdateiso8601) - $created_timestamp
+      ) / 86400
+    ) as $days_ago |
+
+    (
+      if $days_ago <= 0 then 1.0
+      elif $days_ago > 1000 then 0.1
+      else (1.0 / (1.0 + ($days_ago / 90.0)))
+      end
+    ) as $recency_score |
+
+    # Calculate frequency score (failure rate)
+    (
+      if (.total_count // 0) > 0 then
+        (1.0 - ((.success_count // 0) / (.total_count // 1)))
+      else 0.5
+      end
+    ) as $frequency_score |
+
+    # Combined relevance score
+    (
+      (0.5 * $severity_score) +
+      (0.3 * $domain_score) +
+      (0.1 * $recency_score) +
+      (0.1 * $frequency_score)
+    ) as $relevance_score |
+
+    . + {
+      relevance_score: ($relevance_score | . * 100 | round / 100),
+      scoring_breakdown: {
+        severity: ($severity_score | . * 100 | round / 100),
+        domain: ($domain_score | . * 100 | round / 100),
+        recency: ($recency_score | . * 100 | round / 100),
+        frequency: ($frequency_score | . * 100 | round / 100)
+      }
+    }
+  ) |
+  sort_by(-.relevance_score)
+' "$TEMP_RESULTS")
+
+# Step 5: Limit results
+FINAL_RESULTS=$(echo "$SCORED_RESULTS" | jq ".[:$LIMIT]")
+TOTAL_COUNT=$(echo "$SCORED_RESULTS" | jq 'length')
+
+# Step 6: Output results
+case "$OUTPUT_FORMAT" in
+  json)
+    echo "$FINAL_RESULTS" | jq \
+      --arg task "$TASK_DESCRIPTION" \
+      --arg domains "$(echo $DOMAINS | tr '\n' ',' | sed 's/,$//')" \
+      --arg complexity "$COMPLEXITY" \
+      --arg task_type "$TASK_TYPE" \
+      --argjson total_count "$TOTAL_COUNT" \
+      --argjson limit "$LIMIT" \
+      '{
+        query: {
+          task: $task,
+          domains: ($domains | split(",")),
+          complexity: $complexity,
+          task_type: $task_type
+        },
+        anti_patterns: .,
+        total_count: $total_count,
+        filtered_count: (. | length),
+        limit: $limit
+      }'
+    ;;
+
+  simple)
+    echo "=== Anti-Pattern Query Results ==="
+    echo "Task: $TASK_DESCRIPTION"
+    echo "Domains: $(echo $DOMAINS | tr '\n' ',' | sed 's/,$//')"
+    echo "Total Found: $TOTAL_COUNT"
+    echo "Returned: $(echo "$FINAL_RESULTS" | jq 'length')"
+    echo ""
+
+    echo "$FINAL_RESULTS" | jq -r '
+      .[] |
+      "[\(.severity // "medium" | ascii_upcase)] \(.domain // "general") - Relevance: \(.relevance_score)\n" +
+      "  Anti-Pattern: \(.anti_pattern // "N/A")\n" +
+      "  Solution: \(.solution // "N/A")\n" +
+      "  Sprint Ref: \(.sprint_ref // "N/A")\n" +
+      "  Confidence: \(.confidence)\n"
+    '
+    ;;
+
+  *)
+    echo "ERROR: Unknown format $OUTPUT_FORMAT" >&2
+    rm -f "$TEMP_RESULTS"
+    exit 1
+    ;;
+esac
+
+# Cleanup
+rm -f "$TEMP_RESULTS"
+
+exit 0