snow-flow 1.4.5 → 1.4.7

package/test-flow-fix.js

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test script to verify that flow creation now properly creates
- * sys_hub_trigger_instance, sys_hub_action_instance, and sys_hub_flow_logic records
- */
-
-const { ServiceNowClient } = require('./dist/utils/servicenow-client.js');
-
-async function testFlowComponentCreation() {
-  console.log('🧪 Testing Flow Component Creation Fix...');
-  
-  try {
-    const client = new ServiceNowClient({
-      instance: process.env.SNOW_INSTANCE,
-      clientId: process.env.SNOW_CLIENT_ID,
-      clientSecret: process.env.SNOW_CLIENT_SECRET
-    });
-
-    // Test flow definition with a simple notification action
-    const testFlow = {
-      name: 'Test Notification Flow',
-      description: 'Test flow to verify component record creation',
-      trigger_type: 'record_created',
-      table: 'incident',
-      condition: 'priority=1',
-      activities: [
-        {
-          name: 'Send Notification Email',
-          type: 'notification',
-          to: 'admin@test.com',
-          subject: 'High Priority Incident Created',
-          message: 'A high priority incident has been created: ${trigger.number}'
-        }
-      ]
-    };
-
-    console.log('📋 Creating test flow...');
-    const result = await client.createFlow(testFlow);
-
-    if (result.success) {
-      console.log('✅ Flow creation successful!');
-      console.log(`🆔 Flow sys_id: ${result.data.sys_id}`);
-      console.log(`🔗 Flow Designer URL: ${result.data.flow_designer_url}`);
-      console.log(`📊 Activities created: ${result.data.activities_created}`);
-      console.log(`🔧 Component records created: ${result.data.component_records_created}`);
-      console.log(`🎯 Has actual flow instances: ${result.data.has_actual_flow_instances}`);
-      
-      // Verify component records were created by checking the tables
-      console.log('\n🔍 Verifying component records...');
-      
-      // Check sys_hub_trigger_instance
-      const triggerQuery = await client.get(
-        `/api/now/table/sys_hub_trigger_instance?sysparm_query=flow=${result.data.sys_id}`
-      );
-      console.log(`📍 Trigger instances found: ${triggerQuery.result?.length || 0}`);
-      
-      // Check sys_hub_action_instance  
-      const actionQuery = await client.get(
-        `/api/now/table/sys_hub_action_instance?sysparm_query=flow=${result.data.sys_id}`
-      );
-      console.log(`⚡ Action instances found: ${actionQuery.result?.length || 0}`);
-      
-      // Check sys_hub_flow_logic
-      const logicQuery = await client.get(
-        `/api/now/table/sys_hub_flow_logic?sysparm_query=flow=${result.data.sys_id}`
-      );
-      console.log(`🧠 Flow logic entries found: ${logicQuery.result?.length || 0}`);
-      
-      if (triggerQuery.result?.length > 0 && 
-          actionQuery.result?.length > 0 && 
-          logicQuery.result?.length > 0) {
-        console.log('\n🎉 SUCCESS: All component records were created properly!');
-        console.log('✅ Flow should now be functional in ServiceNow Flow Designer');
-      } else {
-        console.log('\n⚠️ WARNING: Some component records may be missing');
-        console.log('- This could indicate the fix needs further refinement');
-      }
-      
-    } else {
-      console.error('❌ Flow creation failed:', result.error);
-      process.exit(1);
-    }
-    
-  } catch (error) {
-    console.error('❌ Test failed with error:', error);
-    process.exit(1);
-  }
-}
-
-// Run the test
-testFlowComponentCreation().catch(console.error);

package/test-parallel-agents.js

@@ -1,177 +0,0 @@
-/**
- * Test script to verify parallel agent detection works correctly
- * Tests the enhanced ParallelAgentEngine with widget development scenario
- */
-
-// Mock TodoItem class
-class TodoItem {
-  constructor(id, content, status = 'pending', priority = 'medium') {
-    this.id = id;
-    this.content = content;
-    this.status = status;
-    this.priority = priority;
-  }
-}
-
-// Mock QueenMemorySystem
-class MockQueenMemorySystem {
-  async store(key, value) {
-    console.log(`📝 Memory: Storing ${key}`);
-    return true;
-  }
-  
-  async retrieve(key) {
-    console.log(`📖 Memory: Retrieved ${key}`);
-    return null;
-  }
-}
-
-// Simple test of the detectSpecializedBreakdown logic
-function testSpecializedBreakdown() {
-  console.log('🧪 Testing Specialized Breakdown Detection Logic...\n');
-  
-  // Test todos voor widget ontwikkeling
-  const mockTodos = [
-    new TodoItem('todo_1', 'Create incident dashboard widget with charts and real-time data', 'pending', 'high'),
-    new TodoItem('todo_2', 'Style the widget with responsive design for mobile', 'pending', 'medium'),
-    new TodoItem('todo_3', 'Implement server script for data fetching', 'pending', 'high'),
-    new TodoItem('todo_4', 'Add client-side JavaScript for interactivity', 'pending', 'medium')
-  ];
-
-  console.log('📋 Mock todos:');
-  mockTodos.forEach(todo => {
-    console.log(`  - ${todo.content} (${todo.priority})`);
-  });
-  console.log('');
-
-  // Test de enhanced detection logica (gekopieerd uit parallel-agent-engine.ts)
-  const canBenefitFromSpecialization = mockTodos.filter(todo => {
-    const content = todo.content.toLowerCase();
-    
-    // Widget development indicators
-    if (content.includes('widget') || content.includes('portal') || content.includes('ui')) {
-      return true;
-    }
-    
-    // Development indicators
-    if (content.includes('develop') || content.includes('create') || content.includes('build')) {
-      return true;
-    }
-    
-    // Multiple component indicators
-    if (content.includes('and') || content.includes('with') || content.includes('including')) {
-      return true;
-    }
-    
-    // Complex task indicators
-    if (todo.priority === 'high' || todo.priority === 'medium') {
-      return true;
-    }
-    
-    // Any development-related task benefits from specialization
-    if (content.includes('test') || content.includes('style') || content.includes('script')) {
-      return true;
-    }
-    
-    return false;
-  });
-
-  console.log(`🎯 Tasks benefiting from specialization: ${canBenefitFromSpecialization.length}/${mockTodos.length}`);
-  canBenefitFromSpecialization.forEach(todo => {
-    console.log(`  ✅ ${todo.id}: ${todo.content}`);
-  });
-  console.log('');
-
-  // Test be more aggressive fallback
-  if (canBenefitFromSpecialization.length === 0 && mockTodos.length > 0) {
-    console.log('🚀 Fallback: Adding first 3 todos for parallelization');
-    canBenefitFromSpecialization.push(...mockTodos.slice(0, Math.min(3, mockTodos.length)));
-  }
-
-  // Test specialized agent teams (gekopieerd uit parallel-agent-engine.ts)
-  const breakdownMap = {
-    'widget': [
-      'widget-creator',      // HTML structure specialist
-      'css-specialist',      // Styling and responsive design specialist
-      'backend-specialist',  // Server script specialist
-      'frontend-specialist', // Client script specialist
-      'integration-specialist', // API integration specialist
-      'ui-ux-specialist',    // User experience specialist
-      'performance-specialist', // Performance optimization
-      'accessibility-specialist', // Accessibility compliance
-      'tester'              // Testing specialist
-    ]
-  };
-
-  const objectiveType = 'widget';
-  const suggestedAgents = breakdownMap[objectiveType] || [];
-
-  console.log(`🤖 Suggested agents for ${objectiveType} development:`);
-  suggestedAgents.forEach((agent, i) => {
-    console.log(`  ${i + 1}. ${agent}`);
-  });
-  console.log('');
-
-  // Create mock opportunity
-  const opportunity = {
-    id: 'specialized_widget_dev',
-    type: 'specialized_breakdown',
-    todos: canBenefitFromSpecialization.map(t => t.id),
-    suggestedAgents: suggestedAgents,
-    estimatedSpeedup: Math.min(suggestedAgents.length * 0.6, 3.0), // Cap at 3x speedup
-    confidence: 0.8, // High confidence for widget development
-    dependencies: [],
-    blockers: []
-  };
-
-  console.log(`📊 Generated Parallelization Opportunity:`);
-  console.log(`  ID: ${opportunity.id}`);
-  console.log(`  Type: ${opportunity.type}`);
-  console.log(`  Confidence: ${opportunity.confidence}`);
-  console.log(`  Estimated speedup: ${opportunity.estimatedSpeedup}x`);
-  console.log(`  Todo IDs: ${opportunity.todos.join(', ')}`);
-  console.log(`  Suggested agents: ${opportunity.suggestedAgents.join(', ')}`);
-  console.log('');
-
-  // Test confidence and speedup thresholds
-  const meetsThreshold = opportunity.confidence > 0.5 && opportunity.estimatedSpeedup > 1.1;
-  console.log(`✅ Meets parallelization threshold (>0.5 confidence, >1.1x speedup): ${meetsThreshold}`);
-  
-  if (meetsThreshold) {
-    console.log(`🎉 SUCCESS: This opportunity would trigger parallel agent spawning!`);
-    console.log(`🚀 Expected result: ${opportunity.suggestedAgents.length} specialized agents working in parallel`);
-  } else {
-    console.log(`❌ FAILURE: This opportunity would NOT trigger parallel agent spawning`);
-  }
-
-  return opportunity;
-}
-
-// Test the agent selection logic
-function testAgentSpecialization() {
-  console.log('\n🔍 Testing Agent Specialization Matching...\n');
-  
-  const testCases = [
-    { content: 'Create incident dashboard widget', expectedAgents: ['widget-creator', 'css-specialist'] },
-    { content: 'Style the widget with responsive design', expectedAgents: ['css-specialist', 'ui-ux-specialist'] },  
-    { content: 'Implement server script for data fetching', expectedAgents: ['backend-specialist'] },
-    { content: 'Add client-side JavaScript for interactivity', expectedAgents: ['frontend-specialist'] },
-    { content: 'Test the widget functionality', expectedAgents: ['tester'] }
-  ];
-
-  testCases.forEach(testCase => {
-    console.log(`📝 Todo: "${testCase.content}"`);
-    console.log(`🎯 Expected agents: ${testCase.expectedAgents.join(', ')}`);
-    console.log('');
-  });
-}
-
-// Run tests
-console.log('🚀 TESTING PARALLEL AGENT DETECTION v1.1.92\n');
-console.log('=' .repeat(60));
-
-const opportunity = testSpecializedBreakdown();
-testAgentSpecialization();
-
-console.log('=' .repeat(60));
-console.log('🏁 Test completed. Check if parallel agents would be spawned!');

package/test-queen-workflow.js

@@ -1,184 +0,0 @@
-/**
- * Test complete Queen Agent workflow with parallel agent spawning
- * Simulates the full process from objective to agent spawning
- */
-
-// Mock the Queen Agent workflow for testing
-function simulateQueenWorkflow() {
-  console.log('👑 TESTING COMPLETE QUEEN AGENT WORKFLOW\n');
-  
-  const objective = "Create incident dashboard widget with real-time charts and mobile-responsive design";
-  console.log(`🎯 Objective: "${objective}"\n`);
-  
-  // Step 1: Queen analyzes objective and creates todos
-  console.log('📋 Step 1: Queen Agent creates todos...');
-  const todos = [
-    {
-      id: 'todo_1',
-      content: 'Design widget HTML structure and layout',
-      status: 'pending',
-      priority: 'high'
-    },
-    {
-      id: 'todo_2', 
-      content: 'Create responsive CSS styling for mobile and desktop',
-      status: 'pending',
-      priority: 'high'
-    },
-    {
-      id: 'todo_3',
-      content: 'Implement server script for real-time data fetching',
-      status: 'pending',
-      priority: 'high'
-    },
-    {
-      id: 'todo_4',
-      content: 'Add client-side JavaScript for chart rendering and interactivity',
-      status: 'pending',
-      priority: 'medium'
-    },
-    {
-      id: 'todo_5',
-      content: 'Integrate with ServiceNow APIs for incident data',
-      status: 'pending',
-      priority: 'medium'
-    },
-    {
-      id: 'todo_6',
-      content: 'Test widget functionality and performance',
-      status: 'pending',
-      priority: 'medium'
-    }
-  ];
-  
-  todos.forEach(todo => {
-    console.log(`  ✅ ${todo.id}: ${todo.content} (${todo.priority})`);
-  });
-  console.log(`\n💡 Generated ${todos.length} todos for parallel execution\n`);
-  
-  // Step 2: Parallel Agent Engine analyzes opportunities
-  console.log('🚀 Step 2: Parallel Agent Engine analysis...');
-  
-  // Simulate detectSpecializedBreakdown logic
-  const canBenefitFromSpecialization = todos.filter(todo => {
-    const content = todo.content.toLowerCase();
-    return content.includes('widget') || content.includes('create') || 
-           content.includes('implement') || content.includes('design') ||
-           content.includes('test') || content.includes('style') ||
-           todo.priority === 'high' || todo.priority === 'medium';
-  });
-  
-  console.log(`📊 Tasks benefiting from specialization: ${canBenefitFromSpecialization.length}/${todos.length}`);
-  
-  // Widget specialization team
-  const widgetSpecialists = [
-    'widget-creator',        // HTML structure
-    'css-specialist',        // Responsive styling  
-    'backend-specialist',    // Server script
-    'frontend-specialist',   // Client JavaScript
-    'integration-specialist', // API integration
-    'performance-specialist', // Performance optimization
-    'tester'                // Testing
-  ];
-  
-  const opportunity = {
-    id: 'widget_parallel_dev',
-    type: 'specialized_breakdown', 
-    confidence: 0.85,
-    estimatedSpeedup: 2.8,
-    suggestedAgents: widgetSpecialists,
-    todos: canBenefitFromSpecialization.map(t => t.id)
-  };
-  
-  console.log(`🎯 Parallelization Opportunity Created:`);
-  console.log(`  • Confidence: ${opportunity.confidence} (threshold: >0.5) ✅`);
-  console.log(`  • Speedup: ${opportunity.estimatedSpeedup}x (threshold: >1.1x) ✅`);
-  console.log(`  • Agent team size: ${opportunity.suggestedAgents.length} specialists`);
-  console.log('');
-  
-  // Step 3: Check if meets threshold for parallel execution
-  const meetsThreshold = opportunity.confidence > 0.5 && opportunity.estimatedSpeedup > 1.1;
-  console.log(`✅ Meets parallelization threshold: ${meetsThreshold}\n`);
-  
-  if (meetsThreshold) {
-    // Step 4: Simulate agent spawning
-    console.log('🤖 Step 3: Spawning specialized agents...');
-    
-    const agentAssignments = {
-      'widget-creator': ['todo_1'],           // HTML structure
-      'css-specialist': ['todo_2'],           // Responsive CSS
-      'backend-specialist': ['todo_3'],       // Server script
-      'frontend-specialist': ['todo_4'],      // Client JavaScript
-      'integration-specialist': ['todo_5'],   // API integration
-      'tester': ['todo_6']                   // Testing
-    };
-    
-    Object.entries(agentAssignments).forEach(([agentType, assignedTodos]) => {
-      console.log(`  🔧 ${agentType}: Assigned ${assignedTodos.join(', ')}`);
-    });
-    
-    console.log(`\n🎉 SUCCESS: ${Object.keys(agentAssignments).length} parallel agents spawned!`);
-    console.log('📈 Expected outcome: 2.8x faster development vs single-agent approach\n');
-    
-    // Step 5: Simulate coordination
-    console.log('🔄 Step 4: Agent coordination active...');
-    console.log('  • Shared memory system coordinating work');
-    console.log('  • Real-time progress tracking');
-    console.log('  • Dependency management between agents');
-    console.log('  • Error recovery and fallback strategies active\n');
-    
-    return {
-      success: true,
-      parallelAgentsSpawned: Object.keys(agentAssignments).length,
-      estimatedSpeedup: opportunity.estimatedSpeedup,
-      agentTypes: Object.keys(agentAssignments)
-    };
-  } else {
-    console.log('❌ FAILURE: Would fall back to single-agent approach');
-    return {
-      success: false,
-      reason: 'Did not meet parallelization threshold'
-    };
-  }
-}
-
-// Compare with old vs new system
-function compareOldVsNew() {
-  console.log('📊 OLD vs NEW SYSTEM COMPARISON\n');
-  
-  console.log('❌ OLD SYSTEM (v1.1.89 and earlier):');
-  console.log('  • Detection: widget_builder, coder, tester (3 agents)');
-  console.log('  • Threshold: Too strict (100+ char content required)');
-  console.log('  • Result: Single-agent approach, no parallelization');
-  console.log('  • Speed: 1x (baseline)');
-  console.log('');
-  
-  console.log('✅ NEW SYSTEM (v1.1.92):');
-  console.log('  • Detection: 7+ specialized agents for widget development');
-  console.log('  • Threshold: Intelligent (keyword + priority based)');
-  console.log('  • Result: Multi-agent parallel execution');
-  console.log('  • Speed: 2.8x faster development');
-  console.log('  • Agents: widget-creator, css-specialist, backend-specialist,');
-  console.log('           frontend-specialist, integration-specialist,');
-  console.log('           performance-specialist, tester');
-  console.log('');
-}
-
-// Run the complete test
-console.log('🚀 SNOW-FLOW PARALLEL AGENT SYSTEM TEST v1.1.92');
-console.log('=' .repeat(70));
-
-const result = simulateQueenWorkflow();
-compareOldVsNew();
-
-console.log('🏁 FINAL RESULT:');
-if (result.success) {
-  console.log(`✅ Parallel agent spawning WORKING!`);
-  console.log(`🚀 ${result.parallelAgentsSpawned} agents working in parallel`);
-  console.log(`⚡ ${result.estimatedSpeedup}x faster than single-agent approach`);
-  console.log(`🎯 Agent types: ${result.agentTypes.join(', ')}`);
-} else {
-  console.log(`❌ Parallel agent spawning FAILED: ${result.reason}`);
-}
-
-console.log('\n💡 Ready for real deployment - parallel agents will spawn automatically!');

package/test-real-monitoring.js

@@ -1,184 +0,0 @@
-/**
- * Standalone test for real system monitoring
- * This demonstrates the actual system metrics being collected
- */
-
-const os = require('os');
-const { execSync } = require('child_process');
-
-// Get real CPU usage
-function getCPUUsage() {
-  const cpus = os.cpus();
-  let totalIdle = 0;
-  let totalTick = 0;
-  
-  cpus.forEach(cpu => {
-    for (const type in cpu.times) {
-      totalTick += cpu.times[type];
-    }
-    totalIdle += cpu.times.idle;
-  });
-  
-  const cpuUsage = 100 - ~~(100 * totalIdle / totalTick);
-  return cpuUsage;
-}
-
-// Get real memory usage
-function getMemoryUsage() {
-  const totalMemory = os.totalmem();
-  const freeMemory = os.freemem();
-  const usedMemory = totalMemory - freeMemory;
-  
-  return {
-    total: (totalMemory / 1024 / 1024).toFixed(0) + ' MB',
-    used: (usedMemory / 1024 / 1024).toFixed(0) + ' MB',
-    free: (freeMemory / 1024 / 1024).toFixed(0) + ' MB',
-    percentage: ((usedMemory / totalMemory) * 100).toFixed(1) + '%'
-  };
-}
-
-// Get real disk usage
-function getDiskUsage() {
-  try {
-    if (process.platform === 'darwin' || process.platform === 'linux') {
-      const output = execSync('df -k /', { encoding: 'utf8' });
-      const lines = output.trim().split('\n');
-      
-      if (lines.length >= 2) {
-        const parts = lines[1].split(/\s+/);
-        const totalBlocks = parseInt(parts[1], 10);
-        const usedBlocks = parseInt(parts[2], 10);
-        
-        const diskTotal = totalBlocks / 1024 / 1024; // Convert to GB
-        const diskUsed = usedBlocks / 1024 / 1024; // Convert to GB
-        const diskUsage = (diskUsed / diskTotal) * 100;
-        
-        return {
-          total: diskTotal.toFixed(1) + ' GB',
-          used: diskUsed.toFixed(1) + ' GB',
-          percentage: diskUsage.toFixed(1) + '%'
-        };
-      }
-    } else if (process.platform === 'win32') {
-      const output = execSync('wmic logicaldisk where caption="C:" get size,freespace /value', { encoding: 'utf8' });
-      const sizeMatch = output.match(/Size=(\d+)/);
-      const freeMatch = output.match(/FreeSpace=(\d+)/);
-      
-      if (sizeMatch && freeMatch) {
-        const totalBytes = parseInt(sizeMatch[1], 10);
-        const freeBytes = parseInt(freeMatch[1], 10);
-        const usedBytes = totalBytes - freeBytes;
-        
-        const diskTotal = totalBytes / 1024 / 1024 / 1024;
-        const diskUsed = usedBytes / 1024 / 1024 / 1024;
-        const diskUsage = (diskUsed / diskTotal) * 100;
-        
-        return {
-          total: diskTotal.toFixed(1) + ' GB',
-          used: diskUsed.toFixed(1) + ' GB',
-          percentage: diskUsage.toFixed(1) + '%'
-        };
-      }
-    }
-  } catch (error) {
-    return { error: error.message };
-  }
-  
-  return { error: 'Unsupported platform' };
-}
-
-// Get process memory usage
-function getProcessMemory() {
-  const usage = process.memoryUsage();
-  return {
-    heapUsed: (usage.heapUsed / 1024 / 1024).toFixed(1) + ' MB',
-    heapTotal: (usage.heapTotal / 1024 / 1024).toFixed(1) + ' MB',
-    rss: (usage.rss / 1024 / 1024).toFixed(1) + ' MB',
-    external: (usage.external / 1024 / 1024).toFixed(1) + ' MB'
-  };
-}
-
-console.log('🏥 Snow-Flow Real System Health Monitoring\n');
-console.log('Platform:', process.platform);
-console.log('Architecture:', process.arch);
-console.log('Node Version:', process.version);
-console.log('CPU Cores:', os.cpus().length);
-console.log('\n📊 Real-time System Metrics:\n');
-
-// Display initial metrics
-console.log('💻 CPU Usage:', getCPUUsage() + '%');
-
-const memory = getMemoryUsage();
-console.log('\n🧠 Memory Usage:');
-console.log('  Total:', memory.total);
-console.log('  Used:', memory.used, `(${memory.percentage})`);
-console.log('  Free:', memory.free);
-
-const disk = getDiskUsage();
-console.log('\n💾 Disk Usage:');
-if (disk.error) {
-  console.log('  Error:', disk.error);
-} else {
-  console.log('  Total:', disk.total);
-  console.log('  Used:', disk.used, `(${disk.percentage})`);
-}
-
-const processMemory = getProcessMemory();
-console.log('\n🔧 Process Memory:');
-console.log('  Heap Used:', processMemory.heapUsed);
-console.log('  Heap Total:', processMemory.heapTotal);
-console.log('  RSS:', processMemory.rss);
-console.log('  External:', processMemory.external);
-
-console.log('\n🔄 Load Average:', os.loadavg().map(l => l.toFixed(2)).join(', '));
-console.log('⏱️  System Uptime:', (os.uptime() / 3600).toFixed(1), 'hours');
-console.log('⏱️  Process Uptime:', (process.uptime() / 60).toFixed(1), 'minutes');
-
-// Monitor for 5 seconds
-console.log('\n📈 Monitoring CPU usage for 5 seconds...\n');
-
-let previousCPU = getCPUInfo();
-const interval = setInterval(() => {
-  const currentCPU = getCPUInfo();
-  const usage = calculateCPUUsage(previousCPU, currentCPU);
-  
-  process.stdout.write(`\rCPU: ${usage.toFixed(1)}% | Memory: ${getMemoryUsage().percentage} | Time: ${new Date().toLocaleTimeString()}`);
-  
-  previousCPU = currentCPU;
-}, 1000);
-
-setTimeout(() => {
-  clearInterval(interval);
-  console.log('\n\n✅ Real system monitoring complete!');
-  console.log('\nThis demonstrates that Snow-Flow is now collecting REAL system metrics, not placeholders.');
-}, 5000);
-
-// Helper functions for accurate CPU measurement
-function getCPUInfo() {
-  const cpus = os.cpus();
-  return cpus.map(cpu => {
-    const total = Object.values(cpu.times).reduce((acc, time) => acc + time, 0);
-    return {
-      idle: cpu.times.idle,
-      total: total
-    };
-  });
-}
-
-function calculateCPUUsage(previous, current) {
-  let totalIdleDiff = 0;
-  let totalDiff = 0;
-  
-  for (let i = 0; i < current.length; i++) {
-    const idleDiff = current[i].idle - previous[i].idle;
-    const totalCPUDiff = current[i].total - previous[i].total;
-    
-    totalIdleDiff += idleDiff;
-    totalDiff += totalCPUDiff;
-  }
-  
-  if (totalDiff === 0) return 0;
-  
-  const idlePercentage = (totalIdleDiff / totalDiff) * 100;
-  return 100 - idlePercentage;
-}