claude-flow-novice 2.8.1 → 2.9.0

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

@@ -1,333 +0,0 @@
-#!/usr/bin/env bash
-##
-## Transparency Middleware - Level Management Script
-## Get, set, and manage transparency levels for the middleware
-##
-## Usage:
-##   ./invoke-transparency-level.sh [OPTIONS]
-##
-## Options:
-##   --get                    Get current transparency level
-##   --set <level>            Set transparency level (minimal|detailed|verbose|debug)
-##   --agent-id <id>          Configure level for specific agent
-##   --task-id <id>           Configure level for specific task
-##   --impact                 Assess impact of level change
-##   --format <json|text>     Output format (default: text)
-##   --help                   Show this help message
-##
-## Transparency Levels:
-##   minimal   - Critical errors and state changes only
-##   detailed  - Important activities, errors, and performance metrics
-##   verbose   - All agent activities with context
-##   debug     - Full debugging information with performance traces
-##
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Default configuration
-ACTION=""
-LEVEL=""
-AGENT_ID=""
-TASK_ID=""
-IMPACT="no"
-FORMAT="text"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --get)
-      ACTION="get"
-      shift
-      ;;
-    --set)
-      ACTION="set"
-      LEVEL="$2"
-      shift 2
-      ;;
-    --agent-id)
-      AGENT_ID="$2"
-      shift 2
-      ;;
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --impact)
-      IMPACT="yes"
-      shift
-      ;;
-    --format)
-      FORMAT="$2"
-      shift 2
-      ;;
-    --help)
-      grep "^##" "$0" | sed 's/^## \?//'
-      exit 0
-      ;;
-    *)
-      echo "Error: Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Validate action
-if [[ -z "$ACTION" ]]; then
-  echo "Error: No action specified. Use --get or --set" >&2
-  exit 1
-fi
-
-# Determine Redis keys
-if [[ -n "$AGENT_ID" ]]; then
-  CONFIG_KEY="transparency:config:agent:${AGENT_ID}"
-  SCOPE="agent:${AGENT_ID}"
-elif [[ -n "$TASK_ID" ]]; then
-  CONFIG_KEY="transparency:config:${TASK_ID}"
-  SCOPE="task:${TASK_ID}"
-else
-  CONFIG_KEY="transparency:config:global"
-  SCOPE="global"
-fi
-
-# Level descriptions
-declare -A LEVEL_DESCRIPTIONS
-LEVEL_DESCRIPTIONS["minimal"]="Critical errors and state changes only. Minimal overhead (<1%)."
-LEVEL_DESCRIPTIONS["detailed"]="Important activities, errors, and performance metrics. Low overhead (1-3%)."
-LEVEL_DESCRIPTIONS["verbose"]="All agent activities with context. Moderate overhead (3-5%)."
-LEVEL_DESCRIPTIONS["debug"]="Full debugging information with performance traces. High overhead (5-10%)."
-
-# Get current level
-get_level() {
-  # Get config from Redis
-  local config=$(redis-cli GET "$CONFIG_KEY" 2>/dev/null || echo "{}")
-
-  if [[ "$config" == "(nil)" || -z "$config" ]]; then
-    # Check global config if scope-specific not found
-    if [[ "$SCOPE" != "global" ]]; then
-      config=$(redis-cli GET "transparency:config:global" 2>/dev/null || echo "{}")
-    fi
-  fi
-
-  local current_level=$(echo "$config" | jq -r '.level // "detailed"')
-  local performance_monitoring=$(echo "$config" | jq -r '.enablePerformanceMonitoring // true')
-  local context_filtering=$(echo "$config" | jq -r '.enableContextFiltering // true')
-  local message_filtering=$(echo "$config" | jq -r '.enableMessageFiltering // true')
-  local max_overhead=$(echo "$config" | jq -r '.maxOverheadPercent // 5')
-
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "scope": "$SCOPE",
-  "level": "$current_level",
-  "description": "${LEVEL_DESCRIPTIONS[$current_level]:-Unknown level}",
-  "config": {
-    "enablePerformanceMonitoring": $performance_monitoring,
-    "enableContextFiltering": $context_filtering,
-    "enableMessageFiltering": $message_filtering,
-    "maxOverheadPercent": $max_overhead
-  }
-}
-EOF
-  else
-    echo "Current Transparency Level"
-    echo "=========================="
-    echo "Scope: $SCOPE"
-    echo "Level: $current_level"
-    echo "Description: ${LEVEL_DESCRIPTIONS[$current_level]:-Unknown level}"
-    echo ""
-    echo "Configuration:"
-    echo "  Performance Monitoring: $performance_monitoring"
-    echo "  Context Filtering: $context_filtering"
-    echo "  Message Filtering: $message_filtering"
-    echo "  Max Overhead: ${max_overhead}%"
-  fi
-}
-
-# Set transparency level
-set_level() {
-  # Validate level
-  if [[ ! "$LEVEL" =~ ^(minimal|detailed|verbose|debug)$ ]]; then
-    echo "Error: Invalid level. Must be one of: minimal, detailed, verbose, debug" >&2
-    exit 1
-  fi
-
-  # Get current config or create new one
-  local config=$(redis-cli GET "$CONFIG_KEY" 2>/dev/null || echo "{}")
-
-  if [[ "$config" == "(nil)" || -z "$config" ]]; then
-    # Create default config
-    config=$(cat <<EOF
-{
-  "level": "detailed",
-  "enablePerformanceMonitoring": true,
-  "enableContextFiltering": true,
-  "enableMessageFiltering": true,
-  "maxOverheadPercent": 5,
-  "messageQueueSize": 1000,
-  "flushInterval": 5000,
-  "excludedPatterns": [],
-  "includedPatterns": []
-}
-EOF
-)
-  fi
-
-  # Update level
-  local updated_config=$(echo "$config" | jq --arg level "$LEVEL" '.level = $level')
-
-  # Adjust settings based on level
-  case "$LEVEL" in
-    minimal)
-      updated_config=$(echo "$updated_config" | jq '.maxOverheadPercent = 1 | .messageQueueSize = 100 | .enableContextFiltering = false')
-      ;;
-    detailed)
-      updated_config=$(echo "$updated_config" | jq '.maxOverheadPercent = 3 | .messageQueueSize = 1000 | .enableContextFiltering = true')
-      ;;
-    verbose)
-      updated_config=$(echo "$updated_config" | jq '.maxOverheadPercent = 5 | .messageQueueSize = 5000 | .enableContextFiltering = true')
-      ;;
-    debug)
-      updated_config=$(echo "$updated_config" | jq '.maxOverheadPercent = 10 | .messageQueueSize = 10000 | .enableContextFiltering = true')
-      ;;
-  esac
-
-  # Save to Redis
-  redis-cli SET "$CONFIG_KEY" "$updated_config" > /dev/null
-
-  # Publish event
-  local event_json=$(cat <<EOF
-{
-  "event": "level_changed",
-  "timestamp": $(date +%s),
-  "scope": "$SCOPE",
-  "oldLevel": "$(echo "$config" | jq -r '.level // "unknown"')",
-  "newLevel": "$LEVEL",
-  "config": $updated_config
-}
-EOF
-)
-  redis-cli PUBLISH "transparency:events" "$event_json" > /dev/null
-
-  # Output result
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "success": true,
-  "scope": "$SCOPE",
-  "level": "$LEVEL",
-  "description": "${LEVEL_DESCRIPTIONS[$LEVEL]}",
-  "config": $updated_config
-}
-EOF
-  else
-    echo "Transparency Level Updated"
-    echo "=========================="
-    echo "Scope: $SCOPE"
-    echo "New Level: $LEVEL"
-    echo "Description: ${LEVEL_DESCRIPTIONS[$LEVEL]}"
-    echo ""
-    echo "Updated Configuration:"
-    echo "$updated_config" | jq -r 'to_entries | .[] | "  \(.key): \(.value)"'
-  fi
-}
-
-# Assess impact of level change
-assess_impact() {
-  if [[ -z "$LEVEL" ]]; then
-    echo "Error: --set <level> is required for impact assessment" >&2
-    exit 1
-  fi
-
-  # Get current level
-  local config=$(redis-cli GET "$CONFIG_KEY" 2>/dev/null || echo '{"level":"detailed"}')
-  local current_level=$(echo "$config" | jq -r '.level // "detailed"')
-
-  # Get current metrics
-  local metrics_key="transparency:metrics:${TASK_ID:-global}"
-  local metrics=$(redis-cli GET "$metrics_key" 2>/dev/null || echo "{}")
-
-  local total_generated=$(echo "$metrics" | jq -r '.totalMessagesGenerated // 0')
-  local avg_overhead=$(echo "$metrics" | jq -r '.overheadPercentage // 0')
-
-  # Estimate impact multipliers
-  declare -A MESSAGE_MULTIPLIER
-  MESSAGE_MULTIPLIER["minimal"]=0.2
-  MESSAGE_MULTIPLIER["detailed"]=1.0
-  MESSAGE_MULTIPLIER["verbose"]=3.0
-  MESSAGE_MULTIPLIER["debug"]=5.0
-
-  declare -A OVERHEAD_ESTIMATE
-  OVERHEAD_ESTIMATE["minimal"]=0.5
-  OVERHEAD_ESTIMATE["detailed"]=2.0
-  OVERHEAD_ESTIMATE["verbose"]=4.0
-  OVERHEAD_ESTIMATE["debug"]=8.0
-
-  # Calculate projected impact
-  local current_multiplier=${MESSAGE_MULTIPLIER[$current_level]}
-  local new_multiplier=${MESSAGE_MULTIPLIER[$LEVEL]}
-  local multiplier_ratio=$(echo "scale=2; $new_multiplier / $current_multiplier" | bc)
-
-  local projected_messages=$(echo "scale=0; $total_generated * $multiplier_ratio" | bc)
-  local projected_overhead=${OVERHEAD_ESTIMATE[$LEVEL]}
-
-  if [[ "$FORMAT" == "json" ]]; then
-    cat <<EOF
-{
-  "currentLevel": "$current_level",
-  "proposedLevel": "$LEVEL",
-  "impact": {
-    "messageVolumeChange": "$multiplier_ratio",
-    "projectedMessages": $projected_messages,
-    "projectedOverhead": $projected_overhead,
-    "overheadChange": "$(echo "scale=2; $projected_overhead - $avg_overhead" | bc)"
-  },
-  "recommendation": "$([ "$LEVEL" == "debug" ] && echo "Use only for troubleshooting" || echo "Safe to use")"
-}
-EOF
-  else
-    echo "Impact Assessment"
-    echo "================="
-    echo "Current Level: $current_level"
-    echo "Proposed Level: $LEVEL"
-    echo ""
-    echo "Projected Impact:"
-    echo "  Message Volume Change: ${multiplier_ratio}x"
-    echo "  Projected Messages: $projected_messages"
-    echo "  Current Overhead: ${avg_overhead}%"
-    echo "  Projected Overhead: ${projected_overhead}%"
-    echo "  Overhead Change: +$(echo "scale=2; $projected_overhead - $avg_overhead" | bc)%"
-    echo ""
-    if [[ "$LEVEL" == "debug" ]]; then
-      echo "Recommendation: Use debug level only for troubleshooting"
-    elif [[ "$LEVEL" == "minimal" ]]; then
-      echo "Recommendation: Minimal level reduces visibility significantly"
-    else
-      echo "Recommendation: Safe to use for production"
-    fi
-  fi
-}
-
-# Execute action
-case "$ACTION" in
-  get)
-    get_level
-    ;;
-  set)
-    if [[ "$IMPACT" == "yes" ]]; then
-      assess_impact
-      echo ""
-      echo "Proceeding with level change..."
-      echo ""
-    fi
-    set_level
-    ;;
-  *)
-    echo "Error: Unknown action: $ACTION" >&2
-    exit 1
-    ;;
-esac
-
-exit 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