claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/monitor.js

@@ -1,417 +1,348 @@
 // monitor.js - System monitoring commands with real metrics
-import { printSuccess, printError, printWarning } from '../utils.js';
-import os from 'os';
-import { performance } from 'perf_hooks';
-import fs from 'fs/promises';
-import path from 'path';
-
+import { printSuccess } from "../utils.js";
+import os from "os";
+import fs from "node:fs/promises";
+import path from "path";
 export async function monitorCommand(subArgs, flags) {
-  const interval = getFlag(subArgs, '--interval') || flags.interval || 5000;
-  const format = getFlag(subArgs, '--format') || flags.format || 'pretty';
-  const continuous = subArgs.includes('--watch') || flags.watch;
-
-  if (continuous) {
-    await runContinuousMonitoring(interval, format);
-  } else {
-    await showCurrentMetrics(format);
-  }
+    const interval = getFlag(subArgs, '--interval') || flags.interval || 5000;
+    const format = getFlag(subArgs, '--format') || flags.format || 'pretty';
+    const continuous = subArgs.includes('--watch') || flags.watch;
+    if (continuous) {
+        await runContinuousMonitoring(interval, format);
+    } else {
+        await showCurrentMetrics(format);
+    }
 }
-
 async function showCurrentMetrics(format) {
-  const metrics = await collectMetrics();
-
-  if (format === 'json') {
-    console.log(JSON.stringify(metrics, null, 2));
-  } else {
-    displayMetrics(metrics);
-  }
+    const metrics = await collectMetrics();
+    if (format === 'json') {
+        console.log(JSON.stringify(metrics, null, 2));
+    } else {
+        displayMetrics(metrics);
+    }
 }
-
 async function runContinuousMonitoring(interval, format) {
-  printSuccess(`Starting continuous monitoring (interval: ${interval}ms)`);
-  console.log('Press Ctrl+C to stop monitoring\n');
-
-  // Set up signal handler for graceful shutdown
-  let monitorInterval;
-  const cleanup = () => {
-    if (monitorInterval) {
-      clearInterval(monitorInterval);
-    }
-    console.log('\n👋 Monitoring stopped');
-    process.exit(0);
-  };
-
-  process.on('SIGINT', cleanup);
-  process.on('SIGTERM', cleanup);
-
-  // Initial display
-  const initialMetrics = await collectMetrics();
-  console.clear();
-  console.log(`🔄 Monitoring Claude-Flow System`);
-  console.log(`⏰ ${new Date().toLocaleTimeString()}\n`);
-
-  if (format === 'json') {
-    console.log(JSON.stringify(initialMetrics, null, 2));
-  } else {
-    displayMetrics(initialMetrics);
-  }
-
-  console.log(`\n🔄 Next update in ${interval}ms...`);
-
-  // Start continuous monitoring
-  monitorInterval = setInterval(async () => {
+    printSuccess(`Starting continuous monitoring (interval: ${interval}ms)`);
+    console.log('Press Ctrl+C to stop monitoring\n');
+    // Set up signal handler for graceful shutdown
+    let monitorInterval;
+    const cleanup = ()=>{
+        if (monitorInterval) {
+            clearInterval(monitorInterval);
+        }
+        console.log('\n👋 Monitoring stopped');
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    // Initial display
+    const initialMetrics = await collectMetrics();
     console.clear();
     console.log(`🔄 Monitoring Claude-Flow System`);
     console.log(`⏰ ${new Date().toLocaleTimeString()}\n`);
-
-    const metrics = await collectMetrics();
-
     if (format === 'json') {
-      console.log(JSON.stringify(metrics, null, 2));
+        console.log(JSON.stringify(initialMetrics, null, 2));
     } else {
-      displayMetrics(metrics);
+        displayMetrics(initialMetrics);
     }
-
     console.log(`\n🔄 Next update in ${interval}ms...`);
-  }, interval);
+    // Start continuous monitoring
+    monitorInterval = setInterval(async ()=>{
+        console.clear();
+        console.log(`🔄 Monitoring Claude-Flow System`);
+        console.log(`⏰ ${new Date().toLocaleTimeString()}\n`);
+        const metrics = await collectMetrics();
+        if (format === 'json') {
+            console.log(JSON.stringify(metrics, null, 2));
+        } else {
+            displayMetrics(metrics);
+        }
+        console.log(`\n🔄 Next update in ${interval}ms...`);
+    }, interval);
 }
-
 async function collectMetrics() {
-  const timestamp = Date.now();
-
-  // Collect real system metrics
-  const cpuUsage = await getCPUUsage();
-  const memoryInfo = getMemoryInfo();
-  const diskUsage = await getDiskUsage();
-  const systemUptime = os.uptime();
-
-  // Try to get orchestrator metrics from file or socket
-  const orchestratorMetrics = await getOrchestratorMetrics();
-
-  // Collect performance metrics
-  const performanceMetrics = getPerformanceMetrics();
-
-  // Collect resource utilization
-  const resourceMetrics = await getResourceMetrics();
-
-  return {
-    timestamp,
-    system: {
-      uptime: systemUptime,
-      cpu_usage: cpuUsage,
-      memory_usage: memoryInfo.usedMB,
-      memory_total: memoryInfo.totalMB,
-      memory_percentage: memoryInfo.percentage,
-      disk_usage: diskUsage.percentage,
-      disk_used: diskUsage.usedGB,
-      disk_total: diskUsage.totalGB,
-      load_average: os.loadavg(),
-      cpu_count: os.cpus().length,
-      platform: os.platform(),
-      node_version: process.version,
-    },
-    orchestrator: orchestratorMetrics,
-    performance: performanceMetrics,
-    resources: resourceMetrics,
-  };
+    const timestamp = Date.now();
+    // Collect real system metrics
+    const cpuUsage = await getCPUUsage();
+    const memoryInfo = getMemoryInfo();
+    const diskUsage = await getDiskUsage();
+    const systemUptime = os.uptime();
+    // Try to get orchestrator metrics from file or socket
+    const orchestratorMetrics = await getOrchestratorMetrics();
+    // Collect performance metrics
+    const performanceMetrics = getPerformanceMetrics();
+    // Collect resource utilization
+    const resourceMetrics = await getResourceMetrics();
+    return {
+        timestamp,
+        system: {
+            uptime: systemUptime,
+            cpu_usage: cpuUsage,
+            memory_usage: memoryInfo.usedMB,
+            memory_total: memoryInfo.totalMB,
+            memory_percentage: memoryInfo.percentage,
+            disk_usage: diskUsage.percentage,
+            disk_used: diskUsage.usedGB,
+            disk_total: diskUsage.totalGB,
+            load_average: os.loadavg(),
+            cpu_count: os.cpus().length,
+            platform: os.platform(),
+            node_version: process.version
+        },
+        orchestrator: orchestratorMetrics,
+        performance: performanceMetrics,
+        resources: resourceMetrics
+    };
 }
-
 // Get real CPU usage
 async 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 idle = totalIdle / cpus.length;
-  const total = totalTick / cpus.length;
-  const usage = 100 - ~~((100 * idle) / total);
-
-  return Math.max(0, Math.min(100, usage));
+    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 idle = totalIdle / cpus.length;
+    const total = totalTick / cpus.length;
+    const usage = 100 - ~~(100 * idle / total);
+    return Math.max(0, Math.min(100, usage));
 }
-
 // Get real memory information
 function getMemoryInfo() {
-  const totalMem = os.totalmem();
-  const freeMem = os.freemem();
-  const usedMem = totalMem - freeMem;
-
-  return {
-    totalMB: Math.round(totalMem / 1024 / 1024),
-    freeMB: Math.round(freeMem / 1024 / 1024),
-    usedMB: Math.round(usedMem / 1024 / 1024),
-    percentage: Math.round((usedMem / totalMem) * 100),
-  };
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    return {
+        totalMB: Math.round(totalMem / 1024 / 1024),
+        freeMB: Math.round(freeMem / 1024 / 1024),
+        usedMB: Math.round(usedMem / 1024 / 1024),
+        percentage: Math.round(usedMem / totalMem * 100)
+    };
 }
-
 // Get real disk usage (simplified - checks current working directory)
 async function getDiskUsage() {
-  try {
-    const stats = await fs.statfs(process.cwd());
-    const totalBytes = stats.blocks * stats.bsize;
-    const freeBytes = stats.bavail * stats.bsize;
-    const usedBytes = totalBytes - freeBytes;
-
-    return {
-      totalGB: Math.round((totalBytes / 1024 / 1024 / 1024) * 10) / 10,
-      usedGB: Math.round((usedBytes / 1024 / 1024 / 1024) * 10) / 10,
-      freeGB: Math.round((freeBytes / 1024 / 1024 / 1024) * 10) / 10,
-      percentage: Math.round((usedBytes / totalBytes) * 100),
-    };
-  } catch (error) {
-    // Fallback for older Node.js versions or unsupported platforms
-    return {
-      totalGB: 0,
-      usedGB: 0,
-      freeGB: 0,
-      percentage: 0,
-    };
-  }
+    try {
+        const stats = await fs.statfs(process.cwd());
+        const totalBytes = stats.blocks * stats.bsize;
+        const freeBytes = stats.bavail * stats.bsize;
+        const usedBytes = totalBytes - freeBytes;
+        return {
+            totalGB: Math.round(totalBytes / 1024 / 1024 / 1024 * 10) / 10,
+            usedGB: Math.round(usedBytes / 1024 / 1024 / 1024 * 10) / 10,
+            freeGB: Math.round(freeBytes / 1024 / 1024 / 1024 * 10) / 10,
+            percentage: Math.round(usedBytes / totalBytes * 100)
+        };
+    } catch (error) {
+        // Fallback for older Node.js versions or unsupported platforms
+        return {
+            totalGB: 0,
+            usedGB: 0,
+            freeGB: 0,
+            percentage: 0
+        };
+    }
 }
-
 // Get orchestrator metrics from running instance
 async function getOrchestratorMetrics() {
-  try {
-    // Try to read from metrics file if orchestrator is running
-    const metricsPath = path.join(process.cwd(), '.claude-flow', 'metrics.json');
-    const metricsData = await fs.readFile(metricsPath, 'utf8');
-    const metrics = JSON.parse(metricsData);
-
-    return {
-      status: 'running',
-      active_agents: metrics.activeAgents || 0,
-      queued_tasks: metrics.queuedTasks || 0,
-      completed_tasks: metrics.completedTasks || 0,
-      failed_tasks: metrics.failedTasks || 0,
-      errors: metrics.errors || 0,
-      uptime: metrics.uptime || 0,
-    };
-  } catch (error) {
-    // Check if orchestrator process is running
-    const isRunning = await checkOrchestratorRunning();
-
-    return {
-      status: isRunning ? 'running' : 'stopped',
-      active_agents: 0,
-      queued_tasks: 0,
-      completed_tasks: 0,
-      failed_tasks: 0,
-      errors: 0,
-      uptime: 0,
-    };
-  }
+    try {
+        // Try to read from metrics file if orchestrator is running
+        const metricsPath = path.join(process.cwd(), '.claude-flow', 'metrics.json');
+        const metricsData = await fs.readFile(metricsPath, 'utf8');
+        const metrics = JSON.parse(metricsData);
+        return {
+            status: 'running',
+            active_agents: metrics.activeAgents || 0,
+            queued_tasks: metrics.queuedTasks || 0,
+            completed_tasks: metrics.completedTasks || 0,
+            failed_tasks: metrics.failedTasks || 0,
+            errors: metrics.errors || 0,
+            uptime: metrics.uptime || 0
+        };
+    } catch (error) {
+        // Check if orchestrator process is running
+        const isRunning = await checkOrchestratorRunning();
+        return {
+            status: isRunning ? 'running' : 'stopped',
+            active_agents: 0,
+            queued_tasks: 0,
+            completed_tasks: 0,
+            failed_tasks: 0,
+            errors: 0,
+            uptime: 0
+        };
+    }
 }
-
 // Check if orchestrator is running
 async function checkOrchestratorRunning() {
-  try {
-    const pidPath = path.join(process.cwd(), '.claude-flow', 'orchestrator.pid');
-    const pidData = await fs.readFile(pidPath, 'utf8');
-    const pid = parseInt(pidData.trim());
-
-    // Check if process is running
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
+    try {
+        const pidPath = path.join(process.cwd(), '.claude-flow', 'orchestrator.pid');
+        const pidData = await fs.readFile(pidPath, 'utf8');
+        const pid = parseInt(pidData.trim());
+        // Check if process is running
+        process.kill(pid, 0);
+        return true;
+    } catch  {
+        return false;
+    }
 }
-
 // Get performance metrics
 function getPerformanceMetrics() {
-  const memUsage = process.memoryUsage();
-  const cpuUsage = process.cpuUsage();
-
-  return {
-    avg_task_duration: 0, // Would need to track actual tasks
-    throughput: 0, // Would need to track actual throughput
-    success_rate: 100, // Default to 100% if no errors
-    memory_heap_used: Math.round((memUsage.heapUsed / 1024 / 1024) * 100) / 100,
-    memory_heap_total: Math.round((memUsage.heapTotal / 1024 / 1024) * 100) / 100,
-    memory_external: Math.round((memUsage.external / 1024 / 1024) * 100) / 100,
-    cpu_user: Math.round(cpuUsage.user / 1000), // Convert to milliseconds
-    cpu_system: Math.round(cpuUsage.system / 1000),
-  };
+    const memUsage = process.memoryUsage();
+    const cpuUsage = process.cpuUsage();
+    return {
+        avg_task_duration: 0,
+        throughput: 0,
+        success_rate: 100,
+        memory_heap_used: Math.round(memUsage.heapUsed / 1024 / 1024 * 100) / 100,
+        memory_heap_total: Math.round(memUsage.heapTotal / 1024 / 1024 * 100) / 100,
+        memory_external: Math.round(memUsage.external / 1024 / 1024 * 100) / 100,
+        cpu_user: Math.round(cpuUsage.user / 1000),
+        cpu_system: Math.round(cpuUsage.system / 1000)
+    };
 }
-
 // Get resource metrics
 async function getResourceMetrics() {
-  try {
-    // Count memory entries from memory database if available
-    const memoryDbPath = path.join(process.cwd(), '.claude-flow', 'memory.db');
-    const memoryExists = await fs
-      .access(memoryDbPath)
-      .then(() => true)
-      .catch(() => false);
-
-    // Count terminal sessions
-    const terminalSessions = await countTerminalSessions();
-
-    // Count MCP connections
-    const mcpConnections = await countMCPConnections();
-
-    return {
-      memory_entries: memoryExists ? 'Available' : 0,
-      terminal_sessions: terminalSessions,
-      mcp_connections: mcpConnections,
-      open_files: process._getActiveHandles ? process._getActiveHandles().length : 0,
-      open_requests: process._getActiveRequests ? process._getActiveRequests().length : 0,
-    };
-  } catch (error) {
-    return {
-      memory_entries: 0,
-      terminal_sessions: 0,
-      mcp_connections: 0,
-      open_files: 0,
-      open_requests: 0,
-    };
-  }
+    try {
+        // Count memory entries from memory database if available
+        const memoryDbPath = path.join(process.cwd(), '.claude-flow', 'memory.db');
+        const memoryExists = await fs.access(memoryDbPath).then(()=>true).catch(()=>false);
+        // Count terminal sessions
+        const terminalSessions = await countTerminalSessions();
+        // Count MCP connections
+        const mcpConnections = await countMCPConnections();
+        return {
+            memory_entries: memoryExists ? 'Available' : 0,
+            terminal_sessions: terminalSessions,
+            mcp_connections: mcpConnections,
+            open_files: process._getActiveHandles ? process._getActiveHandles().length : 0,
+            open_requests: process._getActiveRequests ? process._getActiveRequests().length : 0
+        };
+    } catch (error) {
+        return {
+            memory_entries: 0,
+            terminal_sessions: 0,
+            mcp_connections: 0,
+            open_files: 0,
+            open_requests: 0
+        };
+    }
 }
-
 // Count active terminal sessions
 async function countTerminalSessions() {
-  try {
-    const sessionsPath = path.join(process.cwd(), '.claude-flow', 'sessions');
-    const files = await fs.readdir(sessionsPath);
-    return files.filter((f) => f.endsWith('.json')).length;
-  } catch {
-    return 0;
-  }
+    try {
+        const sessionsPath = path.join(process.cwd(), '.claude-flow', 'sessions');
+        const files = await fs.readdir(sessionsPath);
+        return files.filter((f)=>f.endsWith('.json')).length;
+    } catch  {
+        return 0;
+    }
 }
-
 // Count MCP connections
 async function countMCPConnections() {
-  try {
-    const mcpPath = path.join(process.cwd(), '.claude-flow', 'mcp-connections.json');
-    const data = await fs.readFile(mcpPath, 'utf8');
-    const connections = JSON.parse(data);
-    return Array.isArray(connections) ? connections.length : 0;
-  } catch {
-    return 0;
-  }
+    try {
+        const mcpPath = path.join(process.cwd(), '.claude-flow', 'mcp-connections.json');
+        const data = await fs.readFile(mcpPath, 'utf8');
+        const connections = JSON.parse(data);
+        return Array.isArray(connections) ? connections.length : 0;
+    } catch  {
+        return 0;
+    }
 }
-
 function displayMetrics(metrics) {
-  const timestamp = new Date(metrics.timestamp).toLocaleTimeString();
-
-  console.log('📊 System Metrics');
-  console.log('================');
-
-  // System metrics
-  console.log('\n🖥️  System Resources:');
-  console.log(`   Platform: ${metrics.system.platform} (${metrics.system.cpu_count} CPUs)`);
-  console.log(`   Node Version: ${metrics.system.node_version}`);
-  console.log(`   CPU Usage: ${metrics.system.cpu_usage.toFixed(1)}%`);
-  console.log(
-    `   Memory: ${metrics.system.memory_usage.toFixed(1)} MB / ${metrics.system.memory_total.toFixed(1)} MB (${metrics.system.memory_percentage}%)`,
-  );
-  console.log(
-    `   Disk Usage: ${metrics.system.disk_used} GB / ${metrics.system.disk_total} GB (${metrics.system.disk_usage}%)`,
-  );
-  console.log(
-    `   Load Average: ${metrics.system.load_average.map((l) => l.toFixed(2)).join(', ')}`,
-  );
-  console.log(`   Uptime: ${formatUptime(metrics.system.uptime)}`);
-
-  // Orchestrator metrics
-  console.log('\n🎭 Orchestrator:');
-  console.log(
-    `   Status: ${getStatusIcon(metrics.orchestrator.status)} ${metrics.orchestrator.status}`,
-  );
-  if (metrics.orchestrator.status === 'running') {
-    console.log(`   Active Agents: ${metrics.orchestrator.active_agents}`);
-    console.log(`   Queued Tasks: ${metrics.orchestrator.queued_tasks}`);
-    console.log(`   Completed: ${metrics.orchestrator.completed_tasks}`);
-    console.log(`   Failed: ${metrics.orchestrator.failed_tasks}`);
-    console.log(`   Errors: ${metrics.orchestrator.errors}`);
-    if (metrics.orchestrator.uptime > 0) {
-      console.log(
-        `   Orchestrator Uptime: ${formatUptime(Math.floor(metrics.orchestrator.uptime / 1000))}`,
-      );
+    const timestamp = new Date(metrics.timestamp).toLocaleTimeString();
+    console.log('📊 System Metrics');
+    console.log('================');
+    // System metrics
+    console.log('\n🖥️  System Resources:');
+    console.log(`   Platform: ${metrics.system.platform} (${metrics.system.cpu_count} CPUs)`);
+    console.log(`   Node Version: ${metrics.system.node_version}`);
+    console.log(`   CPU Usage: ${metrics.system.cpu_usage.toFixed(1)}%`);
+    console.log(`   Memory: ${metrics.system.memory_usage.toFixed(1)} MB / ${metrics.system.memory_total.toFixed(1)} MB (${metrics.system.memory_percentage}%)`);
+    console.log(`   Disk Usage: ${metrics.system.disk_used} GB / ${metrics.system.disk_total} GB (${metrics.system.disk_usage}%)`);
+    console.log(`   Load Average: ${metrics.system.load_average.map((l)=>l.toFixed(2)).join(', ')}`);
+    console.log(`   Uptime: ${formatUptime(metrics.system.uptime)}`);
+    // Orchestrator metrics
+    console.log('\n🎭 Orchestrator:');
+    console.log(`   Status: ${getStatusIcon(metrics.orchestrator.status)} ${metrics.orchestrator.status}`);
+    if (metrics.orchestrator.status === 'running') {
+        console.log(`   Active Agents: ${metrics.orchestrator.active_agents}`);
+        console.log(`   Queued Tasks: ${metrics.orchestrator.queued_tasks}`);
+        console.log(`   Completed: ${metrics.orchestrator.completed_tasks}`);
+        console.log(`   Failed: ${metrics.orchestrator.failed_tasks}`);
+        console.log(`   Errors: ${metrics.orchestrator.errors}`);
+        if (metrics.orchestrator.uptime > 0) {
+            console.log(`   Orchestrator Uptime: ${formatUptime(Math.floor(metrics.orchestrator.uptime / 1000))}`);
+        }
     }
-  }
-
-  // Performance metrics
-  console.log('\n⚡ Performance:');
-  console.log(
-    `   Process Memory (Heap): ${metrics.performance.memory_heap_used.toFixed(1)} MB / ${metrics.performance.memory_heap_total.toFixed(1)} MB`,
-  );
-  console.log(`   External Memory: ${metrics.performance.memory_external.toFixed(1)} MB`);
-  console.log(`   CPU Time (User): ${metrics.performance.cpu_user}ms`);
-  console.log(`   CPU Time (System): ${metrics.performance.cpu_system}ms`);
-  if (metrics.performance.avg_task_duration > 0) {
-    console.log(`   Avg Task Duration: ${metrics.performance.avg_task_duration.toFixed(0)}ms`);
-    console.log(`   Throughput: ${metrics.performance.throughput.toFixed(1)} tasks/min`);
-    console.log(`   Success Rate: ${metrics.performance.success_rate.toFixed(1)}%`);
-  }
-
-  // Resource utilization
-  console.log('\n📦 Resources:');
-  console.log(`   Memory Entries: ${metrics.resources.memory_entries}`);
-  console.log(`   Terminal Sessions: ${metrics.resources.terminal_sessions}`);
-  console.log(`   MCP Connections: ${metrics.resources.mcp_connections}`);
-  console.log(`   Open File Handles: ${metrics.resources.open_files}`);
-  console.log(`   Active Requests: ${metrics.resources.open_requests}`);
-
-  console.log(`\n⏰ Last Updated: ${timestamp}`);
+    // Performance metrics
+    console.log('\n⚡ Performance:');
+    console.log(`   Process Memory (Heap): ${metrics.performance.memory_heap_used.toFixed(1)} MB / ${metrics.performance.memory_heap_total.toFixed(1)} MB`);
+    console.log(`   External Memory: ${metrics.performance.memory_external.toFixed(1)} MB`);
+    console.log(`   CPU Time (User): ${metrics.performance.cpu_user}ms`);
+    console.log(`   CPU Time (System): ${metrics.performance.cpu_system}ms`);
+    if (metrics.performance.avg_task_duration > 0) {
+        console.log(`   Avg Task Duration: ${metrics.performance.avg_task_duration.toFixed(0)}ms`);
+        console.log(`   Throughput: ${metrics.performance.throughput.toFixed(1)} tasks/min`);
+        console.log(`   Success Rate: ${metrics.performance.success_rate.toFixed(1)}%`);
+    }
+    // Resource utilization
+    console.log('\n📦 Resources:');
+    console.log(`   Memory Entries: ${metrics.resources.memory_entries}`);
+    console.log(`   Terminal Sessions: ${metrics.resources.terminal_sessions}`);
+    console.log(`   MCP Connections: ${metrics.resources.mcp_connections}`);
+    console.log(`   Open File Handles: ${metrics.resources.open_files}`);
+    console.log(`   Active Requests: ${metrics.resources.open_requests}`);
+    console.log(`\n⏰ Last Updated: ${timestamp}`);
 }
-
 function getStatusIcon(status) {
-  switch (status) {
-    case 'running':
-      return '🟢';
-    case 'stopped':
-      return '🔴';
-    case 'starting':
-      return '🟡';
-    case 'error':
-      return '❌';
-    default:
-      return '⚪';
-  }
+    switch(status){
+        case 'running':
+            return '🟢';
+        case 'stopped':
+            return '🔴';
+        case 'starting':
+            return '🟡';
+        case 'error':
+            return '❌';
+        default:
+            return '⚪';
+    }
 }
-
 function formatUptime(seconds) {
-  const days = Math.floor(seconds / 86400);
-  const hours = Math.floor((seconds % 86400) / 3600);
-  const minutes = Math.floor((seconds % 3600) / 60);
-  const secs = seconds % 60;
-
-  if (days > 0) {
-    return `${days}d ${hours}h ${minutes}m`;
-  } else if (hours > 0) {
-    return `${hours}h ${minutes}m ${secs}s`;
-  } else if (minutes > 0) {
-    return `${minutes}m ${secs}s`;
-  } else {
-    return `${secs}s`;
-  }
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor(seconds % 86400 / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
+    const secs = seconds % 60;
+    if (days > 0) {
+        return `${days}d ${hours}h ${minutes}m`;
+    } else if (hours > 0) {
+        return `${hours}h ${minutes}m ${secs}s`;
+    } else if (minutes > 0) {
+        return `${minutes}m ${secs}s`;
+    } else {
+        return `${secs}s`;
+    }
 }
-
 function getFlag(args, flagName) {
-  const index = args.indexOf(flagName);
-  return index !== -1 && index + 1 < args.length ? args[index + 1] : null;
+    const index = args.indexOf(flagName);
+    return index !== -1 && index + 1 < args.length ? args[index + 1] : null;
 }
-
 export function showMonitorHelp() {
-  console.log('Monitor commands:');
-  console.log('  monitor [options]                Show current system metrics');
-  console.log('  monitor --watch                  Continuous monitoring mode');
-  console.log();
-  console.log('Options:');
-  console.log('  --interval <ms>                  Update interval in milliseconds (default: 5000)');
-  console.log('  --format <type>                  Output format: pretty, json (default: pretty)');
-  console.log('  --watch                          Continuous monitoring mode');
-  console.log();
-  console.log('Examples:');
-  console.log('  claude-flow-novice monitor              # Show current metrics');
-  console.log('  claude-flow-novice monitor --watch      # Continuous monitoring');
-  console.log('  claude-flow-novice monitor --interval 1000 --watch  # Fast updates');
-  console.log('  claude-flow-novice monitor --format json            # JSON output');
+    console.log('Monitor commands:');
+    console.log('  monitor [options]                Show current system metrics');
+    console.log('  monitor --watch                  Continuous monitoring mode');
+    console.log();
+    console.log('Options:');
+    console.log('  --interval <ms>                  Update interval in milliseconds (default: 5000)');
+    console.log('  --format <type>                  Output format: pretty, json (default: pretty)');
+    console.log('  --watch                          Continuous monitoring mode');
+    console.log();
+    console.log('Examples:');
+    console.log('  claude-flow-novice monitor              # Show current metrics');
+    console.log('  claude-flow-novice monitor --watch      # Continuous monitoring');
+    console.log('  claude-flow-novice monitor --interval 1000 --watch  # Fast updates');
+    console.log('  claude-flow-novice monitor --format json            # JSON output');
 }