@claude-flow/cli 3.0.2 → 3.1.0-alpha.2

package/.claude/helpers/statusline.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/**
+ * Claude Flow V3 Statusline Generator
+ * Displays real-time V3 implementation progress and system status
+ *
+ * Usage: node statusline.js [--json] [--compact]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Configuration
+const CONFIG = {
+  enabled: true,
+  showProgress: true,
+  showSecurity: true,
+  showSwarm: true,
+  showHooks: true,
+  showPerformance: true,
+  refreshInterval: 30000,
+  maxAgents: 15,
+  topology: 'hierarchical-mesh',
+};
+
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[0;31m',
+  green: '\x1b[0;32m',
+  yellow: '\x1b[0;33m',
+  blue: '\x1b[0;34m',
+  purple: '\x1b[0;35m',
+  cyan: '\x1b[0;36m',
+  brightRed: '\x1b[1;31m',
+  brightGreen: '\x1b[1;32m',
+  brightYellow: '\x1b[1;33m',
+  brightBlue: '\x1b[1;34m',
+  brightPurple: '\x1b[1;35m',
+  brightCyan: '\x1b[1;36m',
+  brightWhite: '\x1b[1;37m',
+};
+
+// Get user info
+function getUserInfo() {
+  let name = 'user';
+  let gitBranch = '';
+  let modelName = 'Opus 4.5';
+
+  try {
+    name = execSync('git config user.name 2>/dev/null || echo "user"', { encoding: 'utf-8' }).trim();
+    gitBranch = execSync('git branch --show-current 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim();
+  } catch (e) {
+    // Ignore errors
+  }
+
+  return { name, gitBranch, modelName };
+}
+
+// Get learning stats from memory database
+function getLearningStats() {
+  const memoryPaths = [
+    path.join(process.cwd(), '.swarm', 'memory.db'),
+    path.join(process.cwd(), '.claude', 'memory.db'),
+    path.join(process.cwd(), 'data', 'memory.db'),
+  ];
+
+  let patterns = 0;
+  let sessions = 0;
+  let trajectories = 0;
+
+  // Try to read from sqlite database
+  for (const dbPath of memoryPaths) {
+    if (fs.existsSync(dbPath)) {
+      try {
+        // Count entries in memory file (rough estimate from file size)
+        const stats = fs.statSync(dbPath);
+        const sizeKB = stats.size / 1024;
+        // Estimate: ~2KB per pattern on average
+        patterns = Math.floor(sizeKB / 2);
+        sessions = Math.max(1, Math.floor(patterns / 10));
+        trajectories = Math.floor(patterns / 5);
+        break;
+      } catch (e) {
+        // Ignore
+      }
+    }
+  }
+
+  // Also check for session files
+  const sessionsPath = path.join(process.cwd(), '.claude', 'sessions');
+  if (fs.existsSync(sessionsPath)) {
+    try {
+      const sessionFiles = fs.readdirSync(sessionsPath).filter(f => f.endsWith('.json'));
+      sessions = Math.max(sessions, sessionFiles.length);
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  return { patterns, sessions, trajectories };
+}
+
+// Get V3 progress from learning state (grows as system learns)
+function getV3Progress() {
+  const learning = getLearningStats();
+
+  // DDD progress based on actual learned patterns
+  // New install: 0 patterns = 0/5 domains, 0% DDD
+  // As patterns grow: 10+ patterns = 1 domain, 50+ = 2, 100+ = 3, 200+ = 4, 500+ = 5
+  let domainsCompleted = 0;
+  if (learning.patterns >= 500) domainsCompleted = 5;
+  else if (learning.patterns >= 200) domainsCompleted = 4;
+  else if (learning.patterns >= 100) domainsCompleted = 3;
+  else if (learning.patterns >= 50) domainsCompleted = 2;
+  else if (learning.patterns >= 10) domainsCompleted = 1;
+
+  const totalDomains = 5;
+  const dddProgress = Math.min(100, Math.floor((domainsCompleted / totalDomains) * 100));
+
+  return {
+    domainsCompleted,
+    totalDomains,
+    dddProgress,
+    patternsLearned: learning.patterns,
+    sessionsCompleted: learning.sessions
+  };
+}
+
+// Get security status based on actual scans
+function getSecurityStatus() {
+  // Check for security scan results in memory
+  const scanResultsPath = path.join(process.cwd(), '.claude', 'security-scans');
+  let cvesFixed = 0;
+  const totalCves = 3;
+
+  if (fs.existsSync(scanResultsPath)) {
+    try {
+      const scans = fs.readdirSync(scanResultsPath).filter(f => f.endsWith('.json'));
+      // Each successful scan file = 1 CVE addressed
+      cvesFixed = Math.min(totalCves, scans.length);
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  // Also check .swarm/security for audit results
+  const auditPath = path.join(process.cwd(), '.swarm', 'security');
+  if (fs.existsSync(auditPath)) {
+    try {
+      const audits = fs.readdirSync(auditPath).filter(f => f.includes('audit'));
+      cvesFixed = Math.min(totalCves, Math.max(cvesFixed, audits.length));
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  const status = cvesFixed >= totalCves ? 'CLEAN' : cvesFixed > 0 ? 'IN_PROGRESS' : 'PENDING';
+
+  return {
+    status,
+    cvesFixed,
+    totalCves,
+  };
+}
+
+// Get swarm status
+function getSwarmStatus() {
+  let activeAgents = 0;
+  let coordinationActive = false;
+
+  try {
+    const ps = execSync('ps aux 2>/dev/null | grep -c agentic-flow || echo "0"', { encoding: 'utf-8' });
+    activeAgents = Math.max(0, parseInt(ps.trim()) - 1);
+    coordinationActive = activeAgents > 0;
+  } catch (e) {
+    // Ignore errors
+  }
+
+  return {
+    activeAgents,
+    maxAgents: CONFIG.maxAgents,
+    coordinationActive,
+  };
+}
+
+// Get system metrics (dynamic based on actual state)
+function getSystemMetrics() {
+  let memoryMB = 0;
+  let subAgents = 0;
+
+  try {
+    const mem = execSync('ps aux | grep -E "(node|agentic|claude)" | grep -v grep | awk \'{sum += \$6} END {print int(sum/1024)}\'', { encoding: 'utf-8' });
+    memoryMB = parseInt(mem.trim()) || 0;
+  } catch (e) {
+    // Fallback
+    memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
+  }
+
+  // Get learning stats for intelligence %
+  const learning = getLearningStats();
+
+  // Intelligence % based on learned patterns (0 patterns = 0%, 1000+ = 100%)
+  const intelligencePct = Math.min(100, Math.floor((learning.patterns / 10) * 1));
+
+  // Context % based on session history (0 sessions = 0%, grows with usage)
+  const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
+
+  // Count active sub-agents from process list
+  try {
+    const agents = execSync('ps aux 2>/dev/null | grep -c "claude-flow.*agent" || echo "0"', { encoding: 'utf-8' });
+    subAgents = Math.max(0, parseInt(agents.trim()) - 1);
+  } catch (e) {
+    // Ignore
+  }
+
+  return {
+    memoryMB,
+    contextPct,
+    intelligencePct,
+    subAgents,
+  };
+}
+
+// Generate progress bar
+function progressBar(current, total) {
+  const width = 5;
+  const filled = Math.round((current / total) * width);
+  const empty = width - filled;
+  return '[' + '\u25CF'.repeat(filled) + '\u25CB'.repeat(empty) + ']';
+}
+
+// Generate full statusline
+function generateStatusline() {
+  const user = getUserInfo();
+  const progress = getV3Progress();
+  const security = getSecurityStatus();
+  const swarm = getSwarmStatus();
+  const system = getSystemMetrics();
+  const lines = [];
+
+  // Header Line
+  let header = `${c.bold}${c.brightPurple}▊ Claude Flow V3 ${c.reset}`;
+  header += `${swarm.coordinationActive ? c.brightCyan : c.dim}● ${c.brightCyan}${user.name}${c.reset}`;
+  if (user.gitBranch) {
+    header += `  ${c.dim}│${c.reset}  ${c.brightBlue}⎇ ${user.gitBranch}${c.reset}`;
+  }
+  header += `  ${c.dim}│${c.reset}  ${c.purple}${user.modelName}${c.reset}`;
+  lines.push(header);
+
+  // Separator
+  lines.push(`${c.dim}─────────────────────────────────────────────────────${c.reset}`);
+
+  // Line 1: DDD Domain Progress
+  const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
+  lines.push(
+    `${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
+    `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ` +
+    `${c.brightYellow}⚡ 1.0x${c.reset} ${c.dim}→${c.reset} ${c.brightYellow}2.49x-7.47x${c.reset}`
+  );
+
+  // Line 2: Swarm + CVE + Memory + Context + Intelligence
+  const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
+  const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
+  let securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
+  let securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
+
+  lines.push(
+    `${c.brightYellow}🤖 Swarm${c.reset}  ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
+    `${c.brightPurple}👥 ${system.subAgents}${c.reset}    ` +
+    `${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset}    ` +
+    `${c.brightCyan}💾 ${system.memoryMB}MB${c.reset}    ` +
+    `${c.brightGreen}📂 ${String(system.contextPct).padStart(3)}%${c.reset}    ` +
+    `${c.dim}🧠 ${String(system.intelligencePct).padStart(3)}%${c.reset}`
+  );
+
+  // Line 3: Architecture status
+  const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
+  lines.push(
+    `${c.brightPurple}🔧 Architecture${c.reset}    ` +
+    `${c.cyan}DDD${c.reset} ${dddColor}●${String(progress.dddProgress).padStart(3)}%${c.reset}  ${c.dim}│${c.reset}  ` +
+    `${c.cyan}Security${c.reset} ${securityColor}●${security.status}${c.reset}  ${c.dim}│${c.reset}  ` +
+    `${c.cyan}Memory${c.reset} ${c.brightGreen}●AgentDB${c.reset}  ${c.dim}│${c.reset}  ` +
+    `${c.cyan}Integration${c.reset} ${swarm.coordinationActive ? c.brightCyan : c.dim}●${c.reset}`
+  );
+
+  return lines.join('\n');
+}
+
+// Generate JSON data
+function generateJSON() {
+  return {
+    user: getUserInfo(),
+    v3Progress: getV3Progress(),
+    security: getSecurityStatus(),
+    swarm: getSwarmStatus(),
+    system: getSystemMetrics(),
+    performance: {
+      flashAttentionTarget: '2.49x-7.47x',
+      searchImprovement: '150x-12,500x',
+      memoryReduction: '50-75%',
+    },
+    lastUpdated: new Date().toISOString(),
+  };
+}
+
+// Main
+if (process.argv.includes('--json')) {
+  console.log(JSON.stringify(generateJSON(), null, 2));
+} else if (process.argv.includes('--compact')) {
+  console.log(JSON.stringify(generateJSON()));
+} else {
+  console.log(generateStatusline());
+}

package/.claude/helpers/swarm-comms.sh

@@ -0,0 +1,353 @@
+#!/bin/bash
+# Claude Flow V3 - Optimized Swarm Communications
+# Non-blocking, batched, priority-based inter-agent messaging
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+SWARM_DIR="$PROJECT_ROOT/.claude-flow/swarm"
+QUEUE_DIR="$SWARM_DIR/queue"
+BATCH_DIR="$SWARM_DIR/batch"
+POOL_FILE="$SWARM_DIR/connection-pool.json"
+
+mkdir -p "$QUEUE_DIR" "$BATCH_DIR"
+
+# Priority levels
+PRIORITY_CRITICAL=0
+PRIORITY_HIGH=1
+PRIORITY_NORMAL=2
+PRIORITY_LOW=3
+
+# Batch settings
+BATCH_SIZE=10
+BATCH_TIMEOUT_MS=100
+
+# =============================================================================
+# NON-BLOCKING MESSAGE QUEUE
+# =============================================================================
+
+# Enqueue message (instant return, async processing)
+enqueue() {
+  local to="${1:-*}"
+  local content="${2:-}"
+  local priority="${3:-$PRIORITY_NORMAL}"
+  local msg_type="${4:-context}"
+
+  local msg_id="msg_$(date +%s%N)"
+  local timestamp=$(date +%s)
+
+  # Write to priority queue (non-blocking)
+  cat > "$QUEUE_DIR/${priority}_${msg_id}.json" << EOF
+{"id":"$msg_id","to":"$to","content":"$content","type":"$msg_type","priority":$priority,"timestamp":$timestamp}
+EOF
+
+  echo "$msg_id"
+}
+
+# Process queue in background
+process_queue() {
+  local processed=0
+
+  # Process by priority (0=critical first)
+  for priority in 0 1 2 3; do
+    shopt -s nullglob
+    for msg_file in "$QUEUE_DIR"/${priority}_*.json; do
+      [ -f "$msg_file" ] || continue
+
+      # Process message
+      local msg=$(cat "$msg_file")
+      local to=$(echo "$msg" | jq -r '.to' 2>/dev/null)
+
+      # Route to agent mailbox
+      if [ "$to" != "*" ]; then
+        mkdir -p "$SWARM_DIR/mailbox/$to"
+        mv "$msg_file" "$SWARM_DIR/mailbox/$to/"
+      else
+        # Broadcast - copy to all agent mailboxes
+        for agent_dir in "$SWARM_DIR/mailbox"/*; do
+          [ -d "$agent_dir" ] && cp "$msg_file" "$agent_dir/"
+        done
+        rm "$msg_file"
+      fi
+
+      processed=$((processed + 1))
+    done
+  done
+
+  echo "$processed"
+}
+
+# =============================================================================
+# MESSAGE BATCHING
+# =============================================================================
+
+# Add to batch (collects messages, flushes when full or timeout)
+batch_add() {
+  local agent_id="${1:-}"
+  local content="${2:-}"
+  local batch_file="$BATCH_DIR/${agent_id}.batch"
+
+  # Append to batch
+  echo "$content" >> "$batch_file"
+
+  # Check batch size
+  local count=$(wc -l < "$batch_file" 2>/dev/null || echo "0")
+
+  if [ "$count" -ge "$BATCH_SIZE" ]; then
+    batch_flush "$agent_id"
+  fi
+}
+
+# Flush batch (send all at once)
+batch_flush() {
+  local agent_id="${1:-}"
+  local batch_file="$BATCH_DIR/${agent_id}.batch"
+
+  if [ -f "$batch_file" ]; then
+    local content=$(cat "$batch_file")
+    rm "$batch_file"
+
+    # Send as single batched message
+    enqueue "$agent_id" "$content" "$PRIORITY_NORMAL" "batch"
+  fi
+}
+
+# Flush all pending batches
+batch_flush_all() {
+  shopt -s nullglob
+  for batch_file in "$BATCH_DIR"/*.batch; do
+    [ -f "$batch_file" ] || continue
+    local agent_id=$(basename "$batch_file" .batch)
+    batch_flush "$agent_id"
+  done
+}
+
+# =============================================================================
+# CONNECTION POOLING
+# =============================================================================
+
+# Initialize connection pool
+pool_init() {
+  cat > "$POOL_FILE" << EOF
+{
+  "maxConnections": 10,
+  "activeConnections": 0,
+  "available": [],
+  "inUse": [],
+  "lastUpdated": "$(date -Iseconds)"
+}
+EOF
+}
+
+# Get connection from pool (or create new)
+pool_acquire() {
+  local agent_id="${1:-}"
+
+  if [ ! -f "$POOL_FILE" ]; then
+    pool_init
+  fi
+
+  # Check for available connection
+  local available=$(jq -r '.available[0] // ""' "$POOL_FILE" 2>/dev/null)
+
+  if [ -n "$available" ]; then
+    # Reuse existing connection
+    jq ".available = .available[1:] | .inUse += [\"$available\"]" "$POOL_FILE" > "$POOL_FILE.tmp" && mv "$POOL_FILE.tmp" "$POOL_FILE"
+    echo "$available"
+  else
+    # Create new connection ID
+    local conn_id="conn_$(date +%s%N | tail -c 8)"
+    jq ".inUse += [\"$conn_id\"] | .activeConnections += 1" "$POOL_FILE" > "$POOL_FILE.tmp" && mv "$POOL_FILE.tmp" "$POOL_FILE"
+    echo "$conn_id"
+  fi
+}
+
+# Release connection back to pool
+pool_release() {
+  local conn_id="${1:-}"
+
+  if [ -f "$POOL_FILE" ]; then
+    jq ".inUse = (.inUse | map(select(. != \"$conn_id\"))) | .available += [\"$conn_id\"]" "$POOL_FILE" > "$POOL_FILE.tmp" && mv "$POOL_FILE.tmp" "$POOL_FILE"
+  fi
+}
+
+# =============================================================================
+# ASYNC PATTERN BROADCAST
+# =============================================================================
+
+# Broadcast pattern to swarm (non-blocking)
+broadcast_pattern_async() {
+  local strategy="${1:-}"
+  local domain="${2:-general}"
+  local quality="${3:-0.7}"
+
+  # Fire and forget
+  (
+    local broadcast_id="pattern_$(date +%s%N)"
+
+    # Write pattern broadcast
+    mkdir -p "$SWARM_DIR/patterns"
+    cat > "$SWARM_DIR/patterns/$broadcast_id.json" << EOF
+{"id":"$broadcast_id","strategy":"$strategy","domain":"$domain","quality":$quality,"timestamp":$(date +%s),"status":"pending"}
+EOF
+
+    # Notify all agents via queue
+    enqueue "*" "{\"type\":\"pattern_broadcast\",\"id\":\"$broadcast_id\"}" "$PRIORITY_HIGH" "event"
+
+  ) &
+
+  echo "pattern_broadcast_queued"
+}
+
+# =============================================================================
+# OPTIMIZED CONSENSUS
+# =============================================================================
+
+# Start consensus (non-blocking)
+start_consensus_async() {
+  local question="${1:-}"
+  local options="${2:-}"
+  local timeout="${3:-30}"
+
+  (
+    local consensus_id="consensus_$(date +%s%N)"
+    mkdir -p "$SWARM_DIR/consensus"
+
+    cat > "$SWARM_DIR/consensus/$consensus_id.json" << EOF
+{"id":"$consensus_id","question":"$question","options":"$options","votes":{},"timeout":$timeout,"created":$(date +%s),"status":"open"}
+EOF
+
+    # Notify agents
+    enqueue "*" "{\"type\":\"consensus_request\",\"id\":\"$consensus_id\"}" "$PRIORITY_HIGH" "event"
+
+    # Auto-resolve after timeout (background)
+    (
+      sleep "$timeout"
+      if [ -f "$SWARM_DIR/consensus/$consensus_id.json" ]; then
+        jq '.status = "resolved"' "$SWARM_DIR/consensus/$consensus_id.json" > "$SWARM_DIR/consensus/$consensus_id.json.tmp" && mv "$SWARM_DIR/consensus/$consensus_id.json.tmp" "$SWARM_DIR/consensus/$consensus_id.json"
+      fi
+    ) &
+
+    echo "$consensus_id"
+  ) &
+}
+
+# Vote on consensus (non-blocking)
+vote_async() {
+  local consensus_id="${1:-}"
+  local vote="${2:-}"
+  local agent_id="${AGENTIC_FLOW_AGENT_ID:-anonymous}"
+
+  (
+    local file="$SWARM_DIR/consensus/$consensus_id.json"
+    if [ -f "$file" ]; then
+      jq ".votes[\"$agent_id\"] = \"$vote\"" "$file" > "$file.tmp" && mv "$file.tmp" "$file"
+    fi
+  ) &
+}
+
+# =============================================================================
+# PERFORMANCE METRICS
+# =============================================================================
+
+get_comms_stats() {
+  local queued=$(ls "$QUEUE_DIR"/*.json 2>/dev/null | wc -l | tr -d '[:space:]')
+  queued=${queued:-0}
+  local batched=$(ls "$BATCH_DIR"/*.batch 2>/dev/null | wc -l | tr -d '[:space:]')
+  batched=${batched:-0}
+  local patterns=$(ls "$SWARM_DIR/patterns"/*.json 2>/dev/null | wc -l | tr -d '[:space:]')
+  patterns=${patterns:-0}
+  local consensus=$(ls "$SWARM_DIR/consensus"/*.json 2>/dev/null | wc -l | tr -d '[:space:]')
+  consensus=${consensus:-0}
+
+  local pool_active=0
+  if [ -f "$POOL_FILE" ]; then
+    pool_active=$(jq '.activeConnections // 0' "$POOL_FILE" 2>/dev/null | tr -d '[:space:]')
+    pool_active=${pool_active:-0}
+  fi
+
+  echo "{\"queue\":$queued,\"batch\":$batched,\"patterns\":$patterns,\"consensus\":$consensus,\"pool\":$pool_active}"
+}
+
+# =============================================================================
+# MAIN DISPATCHER
+# =============================================================================
+
+case "${1:-help}" in
+  # Queue operations
+  "enqueue"|"send")
+    enqueue "${2:-*}" "${3:-}" "${4:-2}" "${5:-context}"
+    ;;
+  "process")
+    process_queue
+    ;;
+
+  # Batch operations
+  "batch")
+    batch_add "${2:-}" "${3:-}"
+    ;;
+  "flush")
+    batch_flush_all
+    ;;
+
+  # Pool operations
+  "acquire")
+    pool_acquire "${2:-}"
+    ;;
+  "release")
+    pool_release "${2:-}"
+    ;;
+
+  # Async operations
+  "broadcast-pattern")
+    broadcast_pattern_async "${2:-}" "${3:-general}" "${4:-0.7}"
+    ;;
+  "consensus")
+    start_consensus_async "${2:-}" "${3:-}" "${4:-30}"
+    ;;
+  "vote")
+    vote_async "${2:-}" "${3:-}"
+    ;;
+
+  # Stats
+  "stats")
+    get_comms_stats
+    ;;
+
+  "help"|*)
+    cat << 'EOF'
+Claude Flow V3 - Optimized Swarm Communications
+
+Non-blocking, batched, priority-based inter-agent messaging.
+
+Usage: swarm-comms.sh <command> [args]
+
+Queue (Non-blocking):
+  enqueue <to> <content> [priority] [type]   Add to queue (instant return)
+  process                                     Process pending queue
+
+Batching:
+  batch <agent> <content>                     Add to batch
+  flush                                       Flush all batches
+
+Connection Pool:
+  acquire [agent]                             Get connection from pool
+  release <conn_id>                           Return connection to pool
+
+Async Operations:
+  broadcast-pattern <strategy> [domain] [quality]   Async pattern broadcast
+  consensus <question> <options> [timeout]          Start async consensus
+  vote <consensus_id> <vote>                        Vote (non-blocking)
+
+Stats:
+  stats                                       Get communication stats
+
+Priority Levels:
+  0 = Critical (processed first)
+  1 = High
+  2 = Normal (default)
+  3 = Low
+EOF
+    ;;
+esac