claude-flow-novice 2.2.3 → 2.2.4

package/dist/scripts/monitor-memory.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# Memory monitoring script for agent swarms
+
+LOG_FILE="memory-monitor.log"
+INTERVAL=5  # seconds
+
+echo "=== Memory Monitor Started ===" | tee -a "$LOG_FILE"
+echo "Timestamp: $(date)" | tee -a "$LOG_FILE"
+echo "" | tee -a "$LOG_FILE"
+
+while true; do
+    TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+
+    # Total memory usage
+    TOTAL_MEM=$(ps aux | grep -E "(claude|node)" | grep -v grep | awk '{sum+=$6} END {print sum/1024}')
+
+    # Node process count
+    NODE_COUNT=$(ps aux | grep node | grep -v grep | grep -v snapfuse | wc -l)
+
+    # Claude process count
+    CLAUDE_COUNT=$(ps aux | grep claude | grep -v grep | wc -l)
+
+    # Zombie processes
+    ZOMBIE_COUNT=$(ps aux | grep "<defunct>" | grep -v grep | wc -l)
+
+    # Find processes (stuck)
+    FIND_COUNT=$(ps aux | grep "find /mnt/c" | grep -v grep | wc -l)
+
+    echo "[$TIMESTAMP] MEM: ${TOTAL_MEM}MB | Node: $NODE_COUNT | Claude: $CLAUDE_COUNT | Zombies: $ZOMBIE_COUNT | Find: $FIND_COUNT" | tee -a "$LOG_FILE"
+
+    # Alert if memory exceeds 10GB
+    if (( $(echo "$TOTAL_MEM > 10000" | bc -l) )); then
+        echo "⚠️  WARNING: Memory usage exceeds 10GB!" | tee -a "$LOG_FILE"
+    fi
+
+    # Alert if too many node processes
+    if [ "$NODE_COUNT" -gt 20 ]; then
+        echo "⚠️  WARNING: $NODE_COUNT node processes detected (orphaned agents?)" | tee -a "$LOG_FILE"
+    fi
+
+    # Alert if find commands stuck
+    if [ "$FIND_COUNT" -gt 0 ]; then
+        echo "🔴 CRITICAL: $FIND_COUNT find commands running on /mnt/c (memory bomb!)" | tee -a "$LOG_FILE"
+    fi
+
+    sleep $INTERVAL
+done

package/dist/scripts/monitor-migration.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+
+/**
+ * SDK Migration Monitoring Script
+ * Provides real-time monitoring and alerting during migration
+ */
+
+const { MetricsCollector, SDKDashboard } = require('../src/sdk/dashboard');
+const { defaultConfig } = require('../src/sdk/performance-config');
+const fs = require('fs').promises;
+const path = require('path');
+
+class MigrationMonitor {
+  constructor(config = {}) {
+    this.config = {
+      checkInterval: config.checkInterval || 60000, // 1 minute
+      alertThresholds: {
+        errorRate: 0.05,
+        validationFailureRate: 0.2,
+        responseTimeP95: 10000,
+        cacheHitRate: 0.3
+      },
+      ...config
+    };
+
+    this.collector = new MetricsCollector();
+    this.dashboard = new SDKDashboard(this.collector, {
+      port: config.dashboardPort || 3000,
+      updateInterval: 5000,
+      authentication: false
+    });
+
+    this.alerts = [];
+    this.metricsHistory = [];
+    this.isMonitoring = false;
+  }
+
+  async start() {
+    console.log('🚀 Starting SDK Migration Monitor...\n');
+
+    // Start dashboard
+    this.dashboard.start(() => {
+      console.log('✅ Dashboard started successfully\n');
+    });
+
+    // Start metrics collection
+    this.isMonitoring = true;
+    this.startMetricsCollection();
+
+    // Set up graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+  }
+
+  async stop() {
+    console.log('\n🛑 Stopping migration monitor...');
+    this.isMonitoring = false;
+
+    // Save final metrics
+    await this.saveMetricsSnapshot();
+
+    // Stop dashboard
+    this.dashboard.stop();
+
+    console.log('✅ Monitor stopped');
+    process.exit(0);
+  }
+
+  startMetricsCollection() {
+    // Simulate metrics collection (replace with actual implementation)
+    const collectMetrics = async () => {
+      if (!this.isMonitoring) return;
+
+      try {
+        // Collect system metrics
+        const systemMetrics = await this.collectSystemMetrics();
+        this.recordSystemMetrics(systemMetrics);
+
+        // Collect application metrics
+        const appMetrics = await this.collectApplicationMetrics();
+        this.recordApplicationMetrics(appMetrics);
+
+        // Check thresholds and trigger alerts
+        await this.checkThresholds();
+
+        // Store metrics history
+        this.metricsHistory.push({
+          timestamp: Date.now(),
+          system: systemMetrics,
+          application: appMetrics
+        });
+
+        // Keep only last 1000 entries
+        if (this.metricsHistory.length > 1000) {
+          this.metricsHistory = this.metricsHistory.slice(-1000);
+        }
+
+        // Save snapshot periodically
+        if (this.metricsHistory.length % 10 === 0) {
+          await this.saveMetricsSnapshot();
+        }
+      } catch (error) {
+        console.error('Error collecting metrics:', error);
+      }
+
+      // Schedule next collection
+      setTimeout(collectMetrics, this.config.checkInterval);
+    };
+
+    collectMetrics();
+  }
+
+  async collectSystemMetrics() {
+    const os = require('os');
+
+    return {
+      cpu: this.getCPUUsage(),
+      memory: (1 - os.freemem() / os.totalmem()) * 100,
+      loadAverage: os.loadavg()[0],
+      uptime: os.uptime()
+    };
+  }
+
+  getCPUUsage() {
+    const cpus = require('os').cpus();
+    const totalIdle = cpus.reduce((acc, cpu) => acc + cpu.times.idle, 0);
+    const totalTick = cpus.reduce(
+      (acc, cpu) => acc + Object.values(cpu.times).reduce((a, b) => a + b, 0),
+      0
+    );
+    return ((1 - totalIdle / totalTick) * 100);
+  }
+
+  async collectApplicationMetrics() {
+    // In real implementation, collect from actual application
+    // For now, generate simulated metrics
+    return {
+      responseTime: Math.random() * 1000 + 200,
+      throughput: Math.floor(Math.random() * 100) + 50,
+      errorRate: Math.random() * 0.02,
+      cacheHitRate: 0.6 + Math.random() * 0.3,
+      validationSuccess: 0.9 + Math.random() * 0.09,
+      testPassRate: 0.95 + Math.random() * 0.04,
+      coverage: 80 + Math.random() * 15,
+      activeAgents: Math.floor(Math.random() * 5) + 2,
+      queuedTasks: Math.floor(Math.random() * 10)
+    };
+  }
+
+  recordSystemMetrics(metrics) {
+    this.collector.recordMetric('system', 'cpuUsage', metrics.cpu);
+    this.collector.recordMetric('system', 'memoryUsage', metrics.memory);
+    this.collector.recordMetric('system', 'activeAgents', metrics.activeAgents || 0);
+    this.collector.recordMetric('system', 'queuedTasks', metrics.queuedTasks || 0);
+  }
+
+  recordApplicationMetrics(metrics) {
+    this.collector.recordMetric('performance', 'responseTime', metrics.responseTime);
+    this.collector.recordMetric('performance', 'throughput', metrics.throughput);
+    this.collector.recordMetric('performance', 'errorRate', metrics.errorRate);
+    this.collector.recordMetric('performance', 'cacheHitRate', metrics.cacheHitRate);
+
+    this.collector.recordMetric('quality', 'validationSuccess', metrics.validationSuccess);
+    this.collector.recordMetric('quality', 'testPassRate', metrics.testPassRate);
+    this.collector.recordMetric('quality', 'coverageMetrics', metrics.coverage);
+
+    // Estimate token usage and cost
+    const estimatedTokens = metrics.throughput * 1000; // ~1k tokens per request
+    this.collector.recordMetric('cost', 'tokenUsage', estimatedTokens);
+    this.collector.metrics.cost.estimatedCost += estimatedTokens * 0.000003; // $3 per 1M tokens
+  }
+
+  async checkThresholds() {
+    const summary = this.collector.getSummary();
+
+    // Check error rate
+    if (summary.performance.errorRate > this.config.alertThresholds.errorRate) {
+      this.triggerAlert({
+        id: `error-rate-${Date.now()}`,
+        name: 'high-error-rate',
+        severity: 'critical',
+        message: `Error rate ${(summary.performance.errorRate * 100).toFixed(2)}% exceeds threshold ${(this.config.alertThresholds.errorRate * 100).toFixed(2)}%`,
+        metric: 'errorRate',
+        currentValue: summary.performance.errorRate,
+        threshold: this.config.alertThresholds.errorRate,
+        recommendation: 'Consider rolling back migration'
+      });
+    }
+
+    // Check validation failure rate
+    const validationFailureRate = 1 - summary.quality.validationSuccessRate;
+    if (validationFailureRate > this.config.alertThresholds.validationFailureRate) {
+      this.triggerAlert({
+        id: `validation-failure-${Date.now()}`,
+        name: 'validation-failure-spike',
+        severity: 'high',
+        message: `Validation failure rate ${(validationFailureRate * 100).toFixed(2)}% exceeds threshold`,
+        metric: 'validationFailureRate',
+        currentValue: validationFailureRate,
+        threshold: this.config.alertThresholds.validationFailureRate,
+        recommendation: 'Review validation configuration'
+      });
+    }
+
+    // Check response time
+    if (summary.performance.responseTime.p95 > this.config.alertThresholds.responseTimeP95) {
+      this.triggerAlert({
+        id: `slow-response-${Date.now()}`,
+        name: 'slow-response-time',
+        severity: 'warning',
+        message: `P95 response time ${summary.performance.responseTime.p95.toFixed(0)}ms exceeds threshold`,
+        metric: 'responseTimeP95',
+        currentValue: summary.performance.responseTime.p95,
+        threshold: this.config.alertThresholds.responseTimeP95,
+        recommendation: 'Check for performance bottlenecks'
+      });
+    }
+
+    // Check cache hit rate
+    if (summary.performance.cacheHitRate < this.config.alertThresholds.cacheHitRate) {
+      this.triggerAlert({
+        id: `low-cache-${Date.now()}`,
+        name: 'low-cache-hit-rate',
+        severity: 'warning',
+        message: `Cache hit rate ${(summary.performance.cacheHitRate * 100).toFixed(1)}% below threshold`,
+        metric: 'cacheHitRate',
+        currentValue: summary.performance.cacheHitRate,
+        threshold: this.config.alertThresholds.cacheHitRate,
+        recommendation: 'Review cache configuration'
+      });
+    }
+  }
+
+  triggerAlert(alert) {
+    // Deduplicate alerts (don't trigger same alert multiple times)
+    const existingAlert = this.alerts.find(
+      a => a.name === alert.name && !a.resolved && Date.now() - a.timestamp < 300000
+    );
+
+    if (existingAlert) return;
+
+    // Add to collector
+    this.collector.addAlert(alert);
+    this.alerts.push(alert);
+
+    // Print to console
+    const icon = alert.severity === 'critical' ? '🚨' : alert.severity === 'high' ? '⚠️' : '⚡';
+    console.log(`\n${icon} ALERT: ${alert.name}`);
+    console.log(`   ${alert.message}`);
+    console.log(`   Recommendation: ${alert.recommendation}\n`);
+
+    // Write to file
+    this.saveAlert(alert);
+  }
+
+  async saveAlert(alert) {
+    const alertsFile = path.join(__dirname, '../logs/alerts.json');
+
+    try {
+      let alerts = [];
+      try {
+        const content = await fs.readFile(alertsFile, 'utf8');
+        alerts = JSON.parse(content);
+      } catch (err) {
+        // File doesn't exist yet
+      }
+
+      alerts.push(alert);
+
+      await fs.writeFile(alertsFile, JSON.stringify(alerts, null, 2));
+    } catch (error) {
+      console.error('Error saving alert:', error);
+    }
+  }
+
+  async saveMetricsSnapshot() {
+    const summary = this.collector.getSummary();
+    const snapshotFile = path.join(__dirname, '../.metrics-snapshot');
+
+    try {
+      await fs.writeFile(snapshotFile, JSON.stringify(summary, null, 2));
+    } catch (error) {
+      console.error('Error saving metrics snapshot:', error);
+    }
+  }
+
+  generateReport() {
+    const summary = this.collector.getSummary();
+
+    console.log('\n' + '='.repeat(80));
+    console.log('SDK MIGRATION MONITORING REPORT');
+    console.log('='.repeat(80));
+
+    console.log('\n📊 Performance Metrics:');
+    console.log(`   Response Time (Avg): ${summary.performance.responseTime.avg.toFixed(0)}ms`);
+    console.log(`   Response Time (P95): ${summary.performance.responseTime.p95.toFixed(0)}ms`);
+    console.log(`   Error Rate: ${(summary.performance.errorRate * 100).toFixed(2)}%`);
+    console.log(`   Cache Hit Rate: ${(summary.performance.cacheHitRate * 100).toFixed(1)}%`);
+
+    console.log('\n💰 Cost Metrics:');
+    console.log(`   Total Tokens: ${summary.cost.totalTokens.toLocaleString()}`);
+    console.log(`   Estimated Cost: $${summary.cost.estimatedCost.toFixed(2)}`);
+    console.log(`   Cache Savings: $${summary.cost.savingsFromCache.toFixed(2)}`);
+
+    console.log('\n✅ Quality Metrics:');
+    console.log(`   Validation Success: ${(summary.quality.validationSuccessRate * 100).toFixed(1)}%`);
+    console.log(`   Test Pass Rate: ${summary.quality.averageTestPassRate.toFixed(1)}%`);
+    console.log(`   Coverage: ${summary.quality.averageCoverage.toFixed(1)}%`);
+
+    console.log('\n🔔 Alerts:');
+    console.log(`   Active: ${summary.alerts.active}`);
+    console.log(`   Total: ${summary.alerts.total}`);
+
+    console.log('\n' + '='.repeat(80));
+    console.log(`Uptime: ${summary.uptime.formatted}`);
+    console.log(`Dashboard: http://localhost:${this.dashboard.config.port}`);
+    console.log('='.repeat(80) + '\n');
+  }
+}
+
+// CLI
+if (require.main === module) {
+  const monitor = new MigrationMonitor({
+    checkInterval: process.env.CHECK_INTERVAL || 60000,
+    dashboardPort: process.env.DASHBOARD_PORT || 3000
+  });
+
+  monitor.start().catch(err => {
+    console.error('Failed to start monitor:', err);
+    process.exit(1);
+  });
+
+  // Generate report every 5 minutes
+  setInterval(() => {
+    monitor.generateReport();
+  }, 300000);
+}
+
+module.exports = MigrationMonitor;

package/dist/scripts/monitor.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+import subprocess
+import time
+from datetime import datetime
+
+ITERATIONS = 20
+INTERVAL = 30
+
+print("=== Memory Monitor Started ===")
+print(f"Monitoring for {ITERATIONS * INTERVAL} seconds ({ITERATIONS} checks)")
+print(f"Timestamp: {datetime.now()}")
+print()
+
+for i in range(1, ITERATIONS + 1):
+    timestamp = datetime.now().strftime('%H:%M:%S')
+
+    # Total memory
+    mem_cmd = "ps aux | grep -E '(claude|node)' | grep -v grep | awk '{sum+=$6} END {printf \"%.1f\", sum/1024}'"
+    total_mem = subprocess.getoutput(mem_cmd)
+
+    # Process counts
+    node_count = subprocess.getoutput("ps aux | grep node | grep -v grep | grep -v snapfuse | wc -l").strip()
+    claude_count = subprocess.getoutput("ps aux | grep claude | grep -v grep | wc -l").strip()
+    zombie_count = subprocess.getoutput("ps aux | grep '<defunct>' | grep -v grep | wc -l").strip()
+    find_count = subprocess.getoutput("ps aux | grep 'find /mnt/c' | grep -v grep | wc -l").strip()
+
+    print(f"[{i}/{ITERATIONS}] [{timestamp}] MEM: {total_mem}MB | Node: {node_count} | Claude: {claude_count} | Zombies: {zombie_count} | Find: {find_count}")
+
+    # Alerts
+    if total_mem and float(total_mem) > 10000:
+        print("  ⚠️  WARNING: Memory usage exceeds 10GB!")
+
+    if find_count and int(find_count) > 0:
+        print(f"  🔴 CRITICAL: {find_count} find commands on /mnt/c (MEMORY BOMB!)")
+
+    if zombie_count and int(zombie_count) > 0:
+        print(f"  💀 ZOMBIE: {zombie_count} zombie processes detected")
+
+    if i < ITERATIONS:
+        time.sleep(INTERVAL)
+
+print()
+print("=== Monitoring Complete ===")

package/dist/scripts/monitoring/README.md

@@ -0,0 +1,178 @@
+# Resource Monitoring Scripts
+
+Real-time system resource monitoring for agent coordination tests.
+
+## Scripts
+
+### resource-monitor.sh
+Collects system metrics every 1 second during test execution.
+
+**Metrics Tracked:**
+- Memory: RSS, VSZ, shared memory (tmpfs)
+- CPU: Total usage across all node processes
+- File Descriptors: Count of open FDs
+- Processes: Total node/npm process count
+- Disk I/O: Read/write operations (if available)
+
+**Output:** CSV file with timestamped metrics
+
+**Usage:**
+```bash
+./resource-monitor.sh [output_dir]
+
+# Example
+./resource-monitor.sh ./reports/monitoring
+```
+
+**CSV Format:**
+```
+timestamp,elapsed_sec,memory_rss_mb,memory_vsz_mb,memory_shm_mb,cpu_percent,fd_count,process_count,node_processes,io_read_mb,io_write_mb
+```
+
+### analyze-resources.sh
+Analyzes monitoring CSV and detects anomalies.
+
+**Analysis:**
+- Peak resource usage
+- Growth rates and trends
+- Memory leak detection (>1 MB/sec growth)
+- CPU spike detection (>80% sustained)
+- FD leak detection (unclosed descriptors)
+- Process leak detection (orphaned processes)
+
+**Usage:**
+```bash
+./analyze-resources.sh <csv_file>
+
+# Example
+./analyze-resources.sh ./reports/monitoring/resource-usage-20250106_120000.csv
+```
+
+**Output:** Text report with anomaly summary
+
+### monitor-test.sh
+Wrapper script that monitors a test command.
+
+**Features:**
+- Starts monitor before test
+- Runs test command
+- Stops monitor after test
+- Auto-analyzes results
+
+**Usage:**
+```bash
+./monitor-test.sh "<test_command>"
+
+# Example - Monitor 100-agent coordination test
+./monitor-test.sh "bash tests/integration/100-agent-coordination.test.sh"
+
+# Example - Monitor with npm
+./monitor-test.sh "npm test -- tests/integration/100-agent-coordination.test.sh"
+```
+
+## Leak Detection Thresholds
+
+### Memory Leak
+- **Critical**: Growth rate >1.0 MB/sec
+- **Warning**: Growth rate >0.1 MB/sec
+- **OK**: Growth rate ≤0.1 MB/sec
+
+### CPU Spike
+- **Critical**: >5 samples above 80% CPU
+- **OK**: ≤5 samples above 80%
+
+### File Descriptor Leak
+- **Critical**: Growth >100 FDs
+- **Warning**: Growth >20 FDs
+- **OK**: Growth ≤20 FDs
+
+### Process Leak
+- **Critical**: Growth >50 processes
+- **Warning**: Growth >10 processes
+- **OK**: Growth ≤10 processes
+
+## Example Workflow
+
+```bash
+# 1. Monitor the 100-agent coordination test
+cd /mnt/c/Users/masha/Documents/claude-flow-novice
+./scripts/monitoring/monitor-test.sh "bash tests/integration/100-agent-coordination.test.sh"
+
+# 2. Review results
+ls -lh reports/monitoring/
+
+# Output files:
+# - resource-usage-20250106_120000.csv (raw metrics)
+# - analysis-report-20250106_120500.txt (anomaly report)
+# - monitor-20250106_120000.log (event log)
+
+# 3. Review analysis report
+cat reports/monitoring/analysis-report-*.txt
+```
+
+## Interpreting Results
+
+### Healthy System
+```
+Memory Growth: 0.05 MB/sec
+CPU Spikes: 2 samples above 80%
+FD Growth: 5
+Process Growth: 2
+Anomalies: 0
+```
+
+### Memory Leak Detected
+```
+Memory Growth: 2.3 MB/sec ⚠️
+CPU Spikes: 1 sample above 80%
+FD Growth: 8
+Process Growth: 3
+Anomalies: 1
+```
+
+### Multiple Issues
+```
+Memory Growth: 1.5 MB/sec ⚠️
+CPU Spikes: 12 samples above 80% ⚠️
+FD Growth: 150 ⚠️
+Process Growth: 75 ⚠️
+Anomalies: 4
+```
+
+## Troubleshooting
+
+### Monitor doesn't start
+```bash
+# Check permissions
+chmod +x scripts/monitoring/*.sh
+
+# Check dependencies
+which bc ps awk
+```
+
+### No data in CSV
+```bash
+# Check if node processes exist
+pgrep -f node
+
+# Verify output directory
+ls -la reports/monitoring/
+```
+
+### Analysis fails
+```bash
+# Verify CSV format
+head -5 reports/monitoring/resource-usage-*.csv
+
+# Check for bc utility
+which bc || sudo apt-get install bc
+```
+
+## Integration with Tests
+
+The monitoring scripts are designed to work with:
+- `tests/integration/100-agent-coordination.test.sh`
+- `tests/performance/phase1-overhead-benchmark.sh`
+- Any long-running agent coordination tests
+
+Monitor results should be reviewed for each major test run to ensure system stability.