claude-flow-novice 1.6.1 → 1.6.3

package/scripts/check-routing-stats.cjs

@@ -0,0 +1,122 @@
+/**
+ * Check Provider Routing Statistics
+ *
+ * Queries telemetry to show routing breakdown from recent swarm execution
+ */
+
+const { TelemetrySystem, getGlobalTelemetry } = require('../.claude-flow-novice/dist/src/observability/telemetry.js');
+
+async function checkRoutingStats() {
+  console.log('📊 Provider Routing Statistics\n');
+  console.log('=' .repeat(60));
+
+  try {
+    // Get global telemetry instance
+    const telemetry = getGlobalTelemetry();
+
+    // Query provider request metrics
+    const providerMetrics = telemetry.getMetrics('provider.request', 300000); // Last 5 minutes
+
+    if (providerMetrics.length === 0) {
+      console.log('\n⚠️  No routing metrics found in the last 5 minutes.');
+      console.log('   This may be because:');
+      console.log('   - Telemetry was initialized in a different process');
+      console.log('   - No tiered routing requests were made');
+      console.log('   - Metrics have expired (5 min window)');
+      console.log('\nTo test routing, run: node scripts/test-routing-telemetry.cjs\n');
+      return;
+    }
+
+    console.log(`\n✅ Found ${providerMetrics.length} routing metrics\n`);
+
+    // Aggregate by provider
+    const providerBreakdown = {};
+    const tierBreakdown = {};
+    const agentTypeBreakdown = {};
+    const sourceBreakdown = {};
+
+    providerMetrics.forEach(metric => {
+      const provider = metric.tags.provider || 'unknown';
+      const tier = metric.tags.tier || 'unknown';
+      const agentType = metric.tags.agentType || 'unknown';
+      const source = metric.tags.source || 'unknown';
+
+      providerBreakdown[provider] = (providerBreakdown[provider] || 0) + metric.value;
+      tierBreakdown[tier] = (tierBreakdown[tier] || 0) + metric.value;
+      agentTypeBreakdown[agentType] = (agentTypeBreakdown[agentType] || 0) + metric.value;
+      sourceBreakdown[source] = (sourceBreakdown[source] || 0) + metric.value;
+    });
+
+    // Display results
+    console.log('📍 BY PROVIDER:');
+    console.log('-'.repeat(60));
+    Object.entries(providerBreakdown)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([provider, count]) => {
+        const percentage = ((count / providerMetrics.length) * 100).toFixed(1);
+        const providerName = provider === 'custom' ? 'Z.ai (free tier)' :
+                           provider === 'anthropic' ? 'Anthropic API' : provider;
+        console.log(`  ${providerName.padEnd(30)} ${count.toString().padStart(3)} requests (${percentage}%)`);
+      });
+
+    console.log('\n🎯 BY TIER:');
+    console.log('-'.repeat(60));
+    Object.entries(tierBreakdown)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([tier, count]) => {
+        const percentage = ((count / providerMetrics.length) * 100).toFixed(1);
+        console.log(`  ${tier.padEnd(30)} ${count.toString().padStart(3)} requests (${percentage}%)`);
+      });
+
+    console.log('\n🤖 BY AGENT TYPE:');
+    console.log('-'.repeat(60));
+    Object.entries(agentTypeBreakdown)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([agentType, count]) => {
+        const percentage = ((count / providerMetrics.length) * 100).toFixed(1);
+        console.log(`  ${agentType.padEnd(30)} ${count.toString().padStart(3)} requests (${percentage}%)`);
+      });
+
+    console.log('\n🔀 BY ROUTING SOURCE:');
+    console.log('-'.repeat(60));
+    Object.entries(sourceBreakdown)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([source, count]) => {
+        const percentage = ((count / providerMetrics.length) * 100).toFixed(1);
+        console.log(`  ${source.padEnd(30)} ${count.toString().padStart(3)} requests (${percentage}%)`);
+      });
+
+    // Check for subscription metrics
+    const subMetrics = telemetry.getMetrics('subscription.usage', 300000);
+    if (subMetrics.length > 0) {
+      const latestSub = subMetrics[subMetrics.length - 1];
+      console.log('\n📈 SUBSCRIPTION USAGE:');
+      console.log('-'.repeat(60));
+      console.log(`  Used:      ${latestSub.value}/${latestSub.tags.limit}`);
+      console.log(`  Remaining: ${latestSub.tags.remaining}`);
+      console.log(`  Status:    ${latestSub.value >= parseInt(latestSub.tags.limit) ? '⚠️  LIMIT REACHED' : '✅ Available'}`);
+    }
+
+    // Throughput analysis
+    const throughput = telemetry.getThroughputMetrics('provider.request', 300000);
+    console.log('\n⚡ THROUGHPUT ANALYSIS:');
+    console.log('-'.repeat(60));
+    console.log(`  Total requests:    ${throughput.totalRequests}`);
+    console.log(`  Requests/sec:      ${throughput.requestsPerSecond.toFixed(2)}`);
+    console.log(`  Time window:       Last 5 minutes`);
+
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ Routing statistics retrieved successfully\n');
+
+  } catch (error) {
+    console.error('❌ Error retrieving routing statistics:', error.message);
+    console.error('\nThis may happen if telemetry is not initialized.');
+    console.error('Try running a routing test first: node scripts/test-routing-telemetry.cjs\n');
+  }
+}
+
+// Run stats check
+checkRoutingStats().catch(err => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/scripts/monitor-loop.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Monitor memory every 30 seconds, 20 iterations
+
+LOG_FILE="memory-monitor-$(date +%Y%m%d-%H%M%S).log"
+ITERATIONS=20
+INTERVAL=30
+
+echo "=== Memory Monitor Started ===" | tee "$LOG_FILE"
+echo "Monitoring for $((ITERATIONS * INTERVAL)) seconds ($ITERATIONS checks)" | tee -a "$LOG_FILE"
+echo "Timestamp: $(date)" | tee -a "$LOG_FILE"
+echo "" | tee -a "$LOG_FILE"
+
+for i in $(seq 1 $ITERATIONS); 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 {printf "%.1f", 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 (memory bombs)
+    FIND_COUNT=$(ps aux | grep "find /mnt/c" | grep -v grep | wc -l)
+
+    # Hook processes
+    HOOK_COUNT=$(ps aux | grep "npx claude-flow-novice hooks" | grep -v grep | wc -l)
+
+    echo "[$i/$ITERATIONS] [$TIMESTAMP] MEM: ${TOTAL_MEM}MB | Node: $NODE_COUNT | Claude: $CLAUDE_COUNT | Zombies: $ZOMBIE_COUNT | Find: $FIND_COUNT | Hooks: $HOOK_COUNT" | tee -a "$LOG_FILE"
+
+    # Alerts
+    if (( $(echo "$TOTAL_MEM > 10000" | bc -l 2>/dev/null || echo 0) )); then
+        echo "  ⚠️  WARNING: Memory usage exceeds 10GB!" | tee -a "$LOG_FILE"
+    fi
+
+    if [ "$NODE_COUNT" -gt 20 ]; then
+        echo "  ⚠️  WARNING: $NODE_COUNT node processes (orphaned agents?)" | tee -a "$LOG_FILE"
+    fi
+
+    if [ "$FIND_COUNT" -gt 0 ]; then
+        echo "  🔴 CRITICAL: $FIND_COUNT find commands on /mnt/c (MEMORY BOMB!)" | tee -a "$LOG_FILE"
+    fi
+
+    if [ "$ZOMBIE_COUNT" -gt 0 ]; then
+        echo "  💀 ZOMBIE: $ZOMBIE_COUNT zombie processes detected" | tee -a "$LOG_FILE"
+    fi
+
+    if [ "$HOOK_COUNT" -gt 5 ]; then
+        echo "  🔁 RECURSION: $HOOK_COUNT hook processes (possible recursion!)" | tee -a "$LOG_FILE"
+    fi
+
+    # Don't sleep on last iteration
+    if [ $i -lt $ITERATIONS ]; then
+        sleep $INTERVAL
+    fi
+done
+
+echo "" | tee -a "$LOG_FILE"
+echo "=== Monitoring Complete ===" | tee -a "$LOG_FILE"
+echo "Log saved to: $LOG_FILE" | tee -a "$LOG_FILE"

package/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/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/scripts/pre-publish-validation.cjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Publish Validation Suite
+ * Validates all critical functionality before npm package publication
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const TIMEOUT = 60000; // 60 seconds per test suite
+
+const TEST_SUITES = [
+  {
+    name: '1. Post-Edit Pipeline Functionality',
+    type: 'manual',
+    validate: () => {
+      const pipelinePath = 'config/hooks/post-edit-pipeline.js';
+      if (!fs.existsSync(pipelinePath)) {
+        throw new Error(`Post-edit pipeline not found at ${pipelinePath}`);
+      }
+
+      // Test basic execution (create test file first)
+      const testFile = 'test-validation-temp.js';
+      fs.writeFileSync(testFile, 'console.log("test");');
+
+      try {
+        execSync(`node ${pipelinePath} ${testFile}`, {
+          timeout: 30000,
+          stdio: 'pipe'
+        });
+        fs.unlinkSync(testFile);
+        return { status: 'PASS', message: 'Pipeline executable and functional' };
+      } catch (error) {
+        if (fs.existsSync(testFile)) fs.unlinkSync(testFile);
+        return { status: 'WARN', message: `Pipeline execution failed: ${error.message.substring(0, 100)}` };
+      }
+    }
+  },
+  {
+    name: '2. Full-Stack Swarm Tests',
+    type: 'jest',
+    tests: [
+      'tests/swarm-fullstack/backend-integration.test.ts',
+      'tests/swarm-fullstack/frontend-integration.test.ts',
+      'tests/swarm-fullstack/workflows/iterative-workflow.test.ts'
+    ]
+  },
+  {
+    name: '3. CFN Loop Core Tests',
+    type: 'jest',
+    tests: [
+      'tests/unit/cfn-loop/epic-iteration-limits.test.ts',
+      'tests/unit/cfn-loop/retry-todo-manager.test.ts',
+      'tests/integration/cfn-loop/cfn-loop-orchestrator.test.ts'
+    ]
+  },
+  {
+    name: '4. CFN Loop Slash Commands',
+    type: 'jest',
+    tests: [
+      'tests/integration/slash-commands/cfn-loop-commands.test.ts',
+      'tests/integration/slash-commands/cfn-loop-integration.test.js'
+    ]
+  },
+  {
+    name: '5. Tiered Structure with z.ai',
+    type: 'manual',
+    validate: () => {
+      const required = [
+        'src/providers/tiered-router.ts',
+        'src/providers/zai-provider.ts'
+      ];
+
+      const missing = required.filter(file => !fs.existsSync(file));
+      if (missing.length > 0) {
+        return { status: 'FAIL', message: `Missing files: ${missing.join(', ')}` };
+      }
+
+      // Check test file exists
+      const testFile = 'tests/providers/tiered-routing.test.ts';
+      if (!fs.existsSync(testFile)) {
+        return { status: 'WARN', message: `Test file not found: ${testFile}` };
+      }
+
+      return { status: 'PASS', message: 'Tiered routing files present' };
+    }
+  },
+  {
+    name: '6. SDK Process with Agents',
+    type: 'manual',
+    validate: () => {
+      const sdkTests = 'tests/coordination/v2/unit/sdk';
+      if (!fs.existsSync(sdkTests)) {
+        return { status: 'WARN', message: 'SDK tests directory not found (still in development)' };
+      }
+
+      const testFiles = fs.readdirSync(sdkTests, { recursive: true })
+        .filter(file => file.endsWith('.test.ts') || file.endsWith('.test.js'));
+
+      return {
+        status: 'INFO',
+        message: `SDK in development - ${testFiles.length} test files found`
+      };
+    }
+  }
+];
+
+function runJestTest(testPath) {
+  if (!fs.existsSync(testPath)) {
+    return { status: 'SKIP', message: 'Test file not found' };
+  }
+
+  try {
+    execSync(
+      `NODE_OPTIONS='--experimental-vm-modules' npm test -- ${testPath} --bail --maxWorkers=1 --forceExit --testTimeout=30000`,
+      {
+        timeout: TIMEOUT,
+        stdio: 'pipe'
+      }
+    );
+    return { status: 'PASS', message: 'All tests passed' };
+  } catch (error) {
+    const output = error.stdout?.toString() || error.stderr?.toString() || error.message;
+    const hasTests = output.includes('Test Suites:') || output.includes('Tests:');
+
+    if (!hasTests) {
+      return { status: 'SKIP', message: 'No executable tests found' };
+    }
+
+    return { status: 'FAIL', message: output.substring(0, 200) };
+  }
+}
+
+function formatResult(status) {
+  const colors = {
+    PASS: '\x1b[32m✓\x1b[0m',
+    FAIL: '\x1b[31m✗\x1b[0m',
+    WARN: '\x1b[33m⚠\x1b[0m',
+    INFO: '\x1b[36mℹ\x1b[0m',
+    SKIP: '\x1b[90m−\x1b[0m'
+  };
+  return colors[status] || status;
+}
+
+async function main() {
+  console.log('\n🚀 Pre-Publish Validation Suite\n');
+  console.log('=' .repeat(80) + '\n');
+
+  const results = [];
+
+  for (const suite of TEST_SUITES) {
+    console.log(`\n${suite.name}`);
+    console.log('-'.repeat(80));
+
+    if (suite.type === 'manual') {
+      const result = suite.validate();
+      console.log(`${formatResult(result.status)} ${result.message}`);
+      results.push({ suite: suite.name, ...result });
+    } else if (suite.type === 'jest') {
+      for (const testPath of suite.tests) {
+        const filename = path.basename(testPath);
+        const result = runJestTest(testPath);
+        console.log(`  ${formatResult(result.status)} ${filename}`);
+        if (result.message && result.status !== 'PASS') {
+          console.log(`     ${result.message.split('\n')[0]}`);
+        }
+        results.push({ suite: suite.name, test: filename, ...result });
+      }
+    }
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(80));
+  console.log('\n📊 SUMMARY\n');
+
+  const summary = {
+    PASS: results.filter(r => r.status === 'PASS').length,
+    FAIL: results.filter(r => r.status === 'FAIL').length,
+    WARN: results.filter(r => r.status === 'WARN').length,
+    INFO: results.filter(r => r.status === 'INFO').length,
+    SKIP: results.filter(r => r.status === 'SKIP').length
+  };
+
+  console.log(`${formatResult('PASS')} Passed:  ${summary.PASS}`);
+  console.log(`${formatResult('FAIL')} Failed:  ${summary.FAIL}`);
+  console.log(`${formatResult('WARN')} Warnings: ${summary.WARN}`);
+  console.log(`${formatResult('INFO')} Info:     ${summary.INFO}`);
+  console.log(`${formatResult('SKIP')} Skipped:  ${summary.SKIP}`);
+
+  console.log('\n' + '='.repeat(80));
+
+  // Critical failures block publication
+  if (summary.FAIL > 0) {
+    console.log('\n❌ CRITICAL: Tests failed. Fix before publishing.\n');
+    process.exit(1);
+  }
+
+  if (summary.PASS === 0 && summary.WARN > 0) {
+    console.log('\n⚠️  WARNING: No tests passed, only warnings. Review before publishing.\n');
+    process.exit(1);
+  }
+
+  console.log('\n✅ Validation complete. Ready for publication.\n');
+  process.exit(0);
+}
+
+main().catch(error => {
+  console.error('\n❌ Validation suite failed:', error.message);
+  process.exit(1);
+});