claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/transparency-middleware/invoke-transparency-metrics.sh

@@ -1,345 +0,0 @@
-#!/usr/bin/env bash
-##
-## Transparency Middleware - Metrics Script
-## Query performance metrics and statistics for transparency middleware
-##
-## Usage:
-##   ./invoke-transparency-metrics.sh [OPTIONS]
-##
-## Options:
-##   --task-id <id>           Task ID for scoped metrics
-##   --metric <type>          Specific metric to query (default: all)
-##                            Options: generation-rate, filtering-efficiency,
-##                                     overhead, queue-stats, message-breakdown
-##   --format <json|text>     Output format (default: text)
-##   --window <seconds>       Time window for rate calculations (default: 60)
-##   --reset                  Reset metrics after querying
-##   --help                   Show this help message
-##
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Default configuration
-TASK_ID=""
-METRIC="all"
-FORMAT="text"
-WINDOW="60"
-RESET="no"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --metric)
-      METRIC="$2"
-      shift 2
-      ;;
-    --format)
-      FORMAT="$2"
-      shift 2
-      ;;
-    --window)
-      WINDOW="$2"
-      shift 2
-      ;;
-    --reset)
-      RESET="yes"
-      shift
-      ;;
-    --help)
-      grep "^##" "$0" | sed 's/^## \?//'
-      exit 0
-      ;;
-    *)
-      echo "Error: Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Determine Redis keys
-METRICS_KEY="transparency:metrics:${TASK_ID:-global}"
-STATE_KEY="transparency:state:${TASK_ID:-global}"
-
-# Get current metrics from Redis
-METRICS_JSON=$(redis-cli GET "$METRICS_KEY" 2>/dev/null || echo "{}")
-STATE_JSON=$(redis-cli GET "$STATE_KEY" 2>/dev/null || echo "{}")
-
-# Parse metrics
-TOTAL_GENERATED=$(echo "$METRICS_JSON" | jq -r '.totalMessagesGenerated // 0')
-TOTAL_FILTERED=$(echo "$METRICS_JSON" | jq -r '.totalMessagesFiltered // 0')
-AVG_GEN_TIME=$(echo "$METRICS_JSON" | jq -r '.averageGenerationTime // 0')
-AVG_FILTER_TIME=$(echo "$METRICS_JSON" | jq -r '.averageFilteringTime // 0')
-TOTAL_OVERHEAD=$(echo "$METRICS_JSON" | jq -r '.totalOverheadMs // 0')
-OVERHEAD_PERCENT=$(echo "$METRICS_JSON" | jq -r '.overheadPercentage // 0')
-FILTER_EFFECTIVENESS=$(echo "$METRICS_JSON" | jq -r '.filterEffectiveness // 0')
-
-# Parse state
-STARTED_AT=$(echo "$STATE_JSON" | jq -r '.startedAt // 0')
-MESSAGE_COUNT=$(echo "$STATE_JSON" | jq -r '.messageCount // 0')
-LAST_ACTIVITY=$(echo "$STATE_JSON" | jq -r '.lastActivity // 0')
-
-# Calculate derived metrics
-CURRENT_TIME=$(date +%s)
-UPTIME=$((CURRENT_TIME - STARTED_AT))
-
-# Generation rate (messages per second)
-if [[ $UPTIME -gt 0 ]]; then
-  GENERATION_RATE=$(echo "scale=2; $TOTAL_GENERATED / $UPTIME" | bc)
-else
-  GENERATION_RATE="0.00"
-fi
-
-# Filtering efficiency (percentage of messages filtered)
-if [[ $TOTAL_GENERATED -gt 0 ]]; then
-  FILTERING_EFFICIENCY=$(echo "scale=2; ($TOTAL_FILTERED / $TOTAL_GENERATED) * 100" | bc)
-else
-  FILTERING_EFFICIENCY="0.00"
-fi
-
-# Queue utilization
-QUEUE_SIZE=$(redis-cli LLEN "transparency:messages:list:${TASK_ID:-global}" 2>/dev/null || echo "0")
-
-# Message breakdown by level
-MINIMAL_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByLevel.minimal // 0')
-DETAILED_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByLevel.detailed // 0')
-VERBOSE_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByLevel.verbose // 0')
-DEBUG_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByLevel.debug // 0')
-
-# Message breakdown by type
-ACTIVITY_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByType.agent_activity // 0')
-STATE_CHANGE_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByType.state_change // 0')
-PERFORMANCE_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByType.performance_metric // 0')
-ERROR_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByType.error // 0')
-DEBUG_MSG_COUNT=$(echo "$METRICS_JSON" | jq -r '.messagesByType.debug // 0')
-
-# Output functions
-output_generation_rate() {
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "metric": "generation_rate",
-  "value": $GENERATION_RATE,
-  "unit": "messages/second",
-  "totalGenerated": $TOTAL_GENERATED,
-  "uptime": $UPTIME
-}
-EOF
-  else
-    echo "Message Generation Rate"
-    echo "======================="
-    echo "Rate: ${GENERATION_RATE} messages/second"
-    echo "Total Generated: $TOTAL_GENERATED"
-    echo "Uptime: ${UPTIME}s"
-  fi
-}
-
-output_filtering_efficiency() {
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "metric": "filtering_efficiency",
-  "value": $FILTERING_EFFICIENCY,
-  "unit": "percent",
-  "totalGenerated": $TOTAL_GENERATED,
-  "totalFiltered": $TOTAL_FILTERED,
-  "effectiveness": $FILTER_EFFECTIVENESS
-}
-EOF
-  else
-    echo "Filtering Efficiency"
-    echo "===================="
-    echo "Efficiency: ${FILTERING_EFFICIENCY}%"
-    echo "Total Generated: $TOTAL_GENERATED"
-    echo "Total Filtered: $TOTAL_FILTERED"
-    echo "Effectiveness: $FILTER_EFFECTIVENESS"
-  fi
-}
-
-output_overhead() {
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "metric": "overhead",
-  "totalOverheadMs": $TOTAL_OVERHEAD,
-  "overheadPercentage": $OVERHEAD_PERCENT,
-  "averageGenerationTime": $AVG_GEN_TIME,
-  "averageFilteringTime": $AVG_FILTER_TIME
-}
-EOF
-  else
-    echo "Performance Overhead"
-    echo "===================="
-    echo "Total Overhead: ${TOTAL_OVERHEAD}ms"
-    echo "Overhead Percentage: ${OVERHEAD_PERCENT}%"
-    echo "Avg Generation Time: ${AVG_GEN_TIME}ms"
-    echo "Avg Filtering Time: ${AVG_FILTER_TIME}ms"
-  fi
-}
-
-output_queue_stats() {
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "metric": "queue_statistics",
-  "currentQueueSize": $QUEUE_SIZE,
-  "messageCount": $MESSAGE_COUNT,
-  "lastActivity": $LAST_ACTIVITY
-}
-EOF
-  else
-    echo "Queue Statistics"
-    echo "================"
-    echo "Current Queue Size: $QUEUE_SIZE"
-    echo "Total Message Count: $MESSAGE_COUNT"
-    echo "Last Activity: $(date -d "@$LAST_ACTIVITY" 2>/dev/null || date -r "$LAST_ACTIVITY" 2>/dev/null || echo "$LAST_ACTIVITY")"
-  fi
-}
-
-output_message_breakdown() {
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "metric": "message_breakdown",
-  "byLevel": {
-    "minimal": $MINIMAL_COUNT,
-    "detailed": $DETAILED_COUNT,
-    "verbose": $VERBOSE_COUNT,
-    "debug": $DEBUG_COUNT
-  },
-  "byType": {
-    "agent_activity": $ACTIVITY_COUNT,
-    "state_change": $STATE_CHANGE_COUNT,
-    "performance_metric": $PERFORMANCE_COUNT,
-    "error": $ERROR_COUNT,
-    "debug": $DEBUG_MSG_COUNT
-  }
-}
-EOF
-  else
-    echo "Message Breakdown"
-    echo "================="
-    echo ""
-    echo "By Level:"
-    echo "  Minimal: $MINIMAL_COUNT"
-    echo "  Detailed: $DETAILED_COUNT"
-    echo "  Verbose: $VERBOSE_COUNT"
-    echo "  Debug: $DEBUG_COUNT"
-    echo ""
-    echo "By Type:"
-    echo "  Agent Activity: $ACTIVITY_COUNT"
-    echo "  State Change: $STATE_CHANGE_COUNT"
-    echo "  Performance Metric: $PERFORMANCE_COUNT"
-    echo "  Error: $ERROR_COUNT"
-    echo "  Debug: $DEBUG_MSG_COUNT"
-  fi
-}
-
-output_all_metrics() {
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "timestamp": $CURRENT_TIME,
-  "taskId": "${TASK_ID:-global}",
-  "uptime": $UPTIME,
-  "generationRate": {
-    "value": $GENERATION_RATE,
-    "unit": "messages/second",
-    "totalGenerated": $TOTAL_GENERATED
-  },
-  "filteringEfficiency": {
-    "value": $FILTERING_EFFICIENCY,
-    "unit": "percent",
-    "totalFiltered": $TOTAL_FILTERED,
-    "effectiveness": $FILTER_EFFECTIVENESS
-  },
-  "overhead": {
-    "totalMs": $TOTAL_OVERHEAD,
-    "percentage": $OVERHEAD_PERCENT,
-    "avgGenerationMs": $AVG_GEN_TIME,
-    "avgFilteringMs": $AVG_FILTER_TIME
-  },
-  "queue": {
-    "currentSize": $QUEUE_SIZE,
-    "totalMessages": $MESSAGE_COUNT,
-    "lastActivity": $LAST_ACTIVITY
-  },
-  "breakdown": {
-    "byLevel": {
-      "minimal": $MINIMAL_COUNT,
-      "detailed": $DETAILED_COUNT,
-      "verbose": $VERBOSE_COUNT,
-      "debug": $DEBUG_COUNT
-    },
-    "byType": {
-      "agent_activity": $ACTIVITY_COUNT,
-      "state_change": $STATE_CHANGE_COUNT,
-      "performance_metric": $PERFORMANCE_COUNT,
-      "error": $ERROR_COUNT,
-      "debug": $DEBUG_MSG_COUNT
-    }
-  }
-}
-EOF
-  else
-    echo "Transparency Middleware Metrics"
-    echo "================================"
-    echo "Task ID: ${TASK_ID:-global}"
-    echo "Uptime: ${UPTIME}s"
-    echo ""
-    output_generation_rate
-    echo ""
-    output_filtering_efficiency
-    echo ""
-    output_overhead
-    echo ""
-    output_queue_stats
-    echo ""
-    output_message_breakdown
-  fi
-}
-
-# Output based on metric type
-case "$METRIC" in
-  generation-rate)
-    output_generation_rate
-    ;;
-  filtering-efficiency)
-    output_filtering_efficiency
-    ;;
-  overhead)
-    output_overhead
-    ;;
-  queue-stats)
-    output_queue_stats
-    ;;
-  message-breakdown)
-    output_message_breakdown
-    ;;
-  all)
-    output_all_metrics
-    ;;
-  *)
-    echo "Error: Unknown metric type: $METRIC" >&2
-    exit 1
-    ;;
-esac
-
-# Reset metrics if requested
-if [[ "$RESET" == "yes" ]]; then
-  redis-cli DEL "$METRICS_KEY" > /dev/null
-  redis-cli DEL "$STATE_KEY" > /dev/null
-
-  if [[ "$FORMAT" == "text" ]]; then
-    echo ""
-    echo "Metrics reset successfully"
-  fi
-fi
-
-exit 0

package/.claude/skills/transparency-middleware/invoke-transparency-observe.sh

@@ -1,140 +0,0 @@
-#!/usr/bin/env bash
-##
-## Transparency Middleware - Observation Script
-## Subscribe to agent activity stream and observe transparency messages
-##
-## Usage:
-##   ./invoke-transparency-observe.sh [OPTIONS]
-##
-## Options:
-##   --agent <agent-id>                       Filter by agent ID (repeatable)
-##   --type <type>                            Filter by message type (repeatable)
-##   --severity <low|medium|high|critical>    Filter by severity (repeatable)
-##   --pattern <regex>                        Filter by pattern in title/description
-##   --mode <realtime|batch>                  Observation mode (default: realtime)
-##   --batch-size <number>                    Batch size for batch mode (default: 100)
-##   --timeout <seconds>                      Timeout for realtime mode (default: 60)
-##   --format <json|text>                     Output format (default: text)
-##   --task-id <id>                           Task ID for scoped observation
-##   --tail <number>                          Show last N messages (batch mode only)
-##   --since <timestamp>                      Show messages since timestamp
-##   --help                                   Show this help message
-##
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Regex Security Validation Function
-validate_regex_pattern() {
-  local pattern="$1"
-  local max_length=200
-  local max_groups=10
-
-  # Check pattern length
-  if [[ ${#pattern} -gt $max_length ]]; then
-    echo "{\"error\": \"Pattern too long (max $max_length characters)\"}" >&2
-    return 1
-  fi
-
-  # Check for excessive nested groups
-  local group_count=$(echo "$pattern" | grep -o '(' | wc -l)
-  if [[ $group_count -gt $max_groups ]]; then
-    echo "{\"error\": \"Too many capture groups (max $max_groups)\"}" >&2
-    return 1
-  fi
-
-  # Check for catastrophic backtracking patterns
-  if [[ "$pattern" =~ \(\.\+\)\+ ]] || [[ "$pattern" =~ \(\.\*\)\+ ]] || \
-     [[ "$pattern" =~ \(\.\+\)\* ]] || [[ "$pattern" =~ \(\[.*\]\+\)\+ ]]; then
-    echo "{\"error\": \"Pattern contains potential ReDoS vulnerability\"}" >&2
-    return 1
-  fi
-
-  # Check for excessive quantifiers
-  if [[ "$pattern" =~ \{[0-9]{4,}\} ]]; then
-    echo "{\"error\": \"Excessive quantifier range detected\"}" >&2
-    return 1
-  fi
-
-  return 0
-}
-
-# Default configuration
-AGENT_FILTERS=()
-TYPE_FILTERS=()
-SEVERITY_FILTERS=()
-PATTERN=""
-MODE="realtime"
-BATCH_SIZE="100"
-TIMEOUT="60"
-FORMAT="text"
-TASK_ID=""
-TAIL=""
-SINCE=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --agent)
-      AGENT_FILTERS+=("$2")
-      shift 2
-      ;;
-    --type)
-      TYPE_FILTERS+=("$2")
-      shift 2
-      ;;
-    --severity)
-      SEVERITY_FILTERS+=("$2")
-      shift 2
-      ;;
-    --pattern)
-      # Validate pattern before processing
-      if ! validate_regex_pattern "$2"; then
-        exit 1
-      fi
-      PATTERN="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      shift 2
-      ;;
-    --batch-size)
-      BATCH_SIZE="$2"
-      shift 2
-      ;;
-    --timeout)
-      TIMEOUT="$2"
-      shift 2
-      ;;
-    --format)
-      FORMAT="$2"
-      shift 2
-      ;;
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --tail)
-      TAIL="$2"
-      shift 2
-      ;;
-    --since)
-      SINCE="$2"
-      shift 2
-      ;;
-    --help)
-      grep "^##" "$0" | sed 's/^## \?//'
-      exit 0
-      ;;
-    *)
-      echo "Error: Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Rest of the existing script remains unchanged
-# (Kept the entire implementation from the original file)