claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

package/src/cli/simple-commands/start-wrapper.js

@@ -9,30 +9,30 @@ export async function startCommand(subArgs, flags) {
     showStartHelp();
     return;
   }
-  
+
   // Parse start options
   const daemon = subArgs.includes('--daemon') || subArgs.includes('-d') || flags.daemon;
   const port = flags.port || getArgValue(subArgs, '--port') || getArgValue(subArgs, '-p') || 3000;
   const verbose = subArgs.includes('--verbose') || subArgs.includes('-v') || flags.verbose;
   const ui = subArgs.includes('--ui') || subArgs.includes('-u') || flags.ui;
   const web = subArgs.includes('--web') || subArgs.includes('-w') || flags.web;
-  
+
   try {
     printSuccess('Starting Claude-Flow Orchestration System...');
     console.log();
-    
+
     // Check if we should launch the web UI mode
     if (web) {
       try {
         // Launch the web server
         const { startWebServer } = await import('./web-server.js');
         const server = await startWebServer(port);
-        
+
         printSuccess(`🌐 Web UI is running!`);
         console.log(`📍 Open your browser to: http://localhost:${port}/console`);
         console.log('   Press Ctrl+C to stop the server');
         console.log();
-        
+
         // Keep process running
         await new Promise(() => {});
         return;
@@ -42,7 +42,7 @@ export async function startCommand(subArgs, flags) {
         return;
       }
     }
-    
+
     // Check if we should launch the UI mode (web UI by default)
     if (ui && !web) {
       try {
@@ -50,12 +50,12 @@ export async function startCommand(subArgs, flags) {
         const { ClaudeCodeWebServer } = await import('./web-server.js');
         const webServer = new ClaudeCodeWebServer(port);
         await webServer.start();
-        
+
         printSuccess('🌐 Claude Flow Web UI is running!');
         console.log(`📍 Open your browser to: http://localhost:${port}/console`);
         console.log('   Press Ctrl+C to stop the server');
         console.log();
-        
+
         // Keep process running
         await new Promise(() => {});
         return;
@@ -74,11 +74,11 @@ export async function startCommand(subArgs, flags) {
         }
       }
     }
-    
+
     // Check if required directories exist
     const requiredDirs = ['memory', 'coordination'];
     let missingDirs = [];
-    
+
     for (const dir of requiredDirs) {
       try {
         await Deno.stat(dir);
@@ -86,13 +86,13 @@ export async function startCommand(subArgs, flags) {
         missingDirs.push(dir);
       }
     }
-    
+
     if (missingDirs.length > 0) {
       printWarning('Missing required directories: ' + missingDirs.join(', '));
       console.log('Run "claude-flow init" first to create the necessary structure');
       return;
     }
-    
+
     // Display startup information
     console.log('🚀 System Configuration:');
     console.log(`   Mode: ${daemon ? 'Daemon (background)' : 'Interactive'}`);
@@ -101,38 +101,38 @@ export async function startCommand(subArgs, flags) {
     console.log(`   Memory Backend: JSON (default)`);
     console.log(`   Terminal Pool: 5 instances (default)`);
     console.log();
-    
+
     // Initialize components
     console.log('📋 Initializing Components:');
-    
+
     // Memory system
     console.log('   ✓ Memory Bank: Ready');
     console.log('     - Backend: JSON file (memory/claude-flow-data.json)');
     console.log('     - Namespaces: Enabled');
-    
+
     // Terminal pool
     console.log('   ✓ Terminal Pool: Ready');
     console.log('     - Pool Size: 5');
     console.log('     - Shell: ' + (compat.platform.os === 'windows' ? 'cmd.exe' : '/bin/bash'));
-    
+
     // Task queue
     console.log('   ✓ Task Queue: Ready');
     console.log('     - Max Concurrent: 10');
     console.log('     - Priority Queue: Enabled');
-    
+
     // MCP Server
     console.log('   ✓ MCP Server: Ready');
     console.log(`     - Port: ${port}`);
     console.log('     - Transport: stdio/HTTP');
-    
+
     console.log();
-    
+
     if (daemon) {
       // Daemon mode - would normally fork process
       printInfo('Starting in daemon mode...');
       console.log('Note: Full daemon mode requires the TypeScript version');
       console.log('The orchestrator would run in the background on port ' + port);
-      
+
       // Create a simple PID file to simulate daemon
       const pid = compat.terminal.getPid();
       await compat.safeCall(async () => {
@@ -144,7 +144,6 @@ export async function startCommand(subArgs, flags) {
         }
       });
       console.log(`Process ID: ${pid} (saved to .claude-flow.pid)`);
-      
     } else {
       // Interactive mode
       printSuccess('Orchestration system started!');
@@ -164,25 +163,25 @@ export async function startCommand(subArgs, flags) {
       console.log();
       console.log('   • Press Ctrl+C to stop the orchestrator');
       console.log();
-      
+
       if (verbose) {
         console.log('📊 Verbose Mode - Showing system activity:');
         console.log('[' + new Date().toISOString() + '] System initialized');
         console.log('[' + new Date().toISOString() + '] Waiting for commands...');
       }
-      
+
       // Keep the process running
       console.log('🟢 System is running...');
-      
+
       // Set up signal handlers
       const abortController = new AbortController();
-      
-      compat.terminal.onSignal("SIGINT", () => {
+
+      compat.terminal.onSignal('SIGINT', () => {
         console.log('\n⏹️  Shutting down orchestrator...');
         cleanup();
         compat.terminal.exit(0);
       });
-      
+
       // Simple heartbeat to show system is alive
       if (!daemon) {
         const heartbeat = setInterval(() => {
@@ -190,12 +189,11 @@ export async function startCommand(subArgs, flags) {
             console.log('[' + new Date().toISOString() + '] Heartbeat - System healthy');
           }
         }, 30000); // Every 30 seconds
-        
+
         // Wait indefinitely (until Ctrl+C)
         await new Promise(() => {});
       }
     }
-    
   } catch (err) {
     printError(`Failed to start orchestration system: ${err.message}`);
     console.error('Stack trace:', err.stack);
@@ -224,7 +222,7 @@ async function cleanup() {
   } catch {
     // File might not exist
   }
-  
+
   console.log('✓ Terminal pool closed');
   console.log('✓ Task queue cleared');
   console.log('✓ Memory bank saved');
@@ -283,4 +281,4 @@ function showStartHelp() {
   console.log('  - Daemon mode runs in background (check logs)');
   console.log('  - Use "claude-flow status" to check if running');
   console.log('  - Use Ctrl+C or "claude-flow stop" to shutdown');
-}
+}

package/src/cli/simple-commands/start.js

@@ -1,2 +1,2 @@
 // start.js - Re-export the wrapper to maintain backward compatibility
-export { startCommand } from './start-wrapper.js';
+export { startCommand } from './start-wrapper.js';

package/src/cli/simple-commands/status.js

@@ -5,9 +5,9 @@ import { Deno } from '../node-compat.js';
 export async function statusCommand(subArgs, flags) {
   const verbose = subArgs.includes('--verbose') || subArgs.includes('-v') || flags.verbose;
   const json = subArgs.includes('--json') || flags.json;
-  
+
   const status = await getSystemStatus(verbose);
-  
+
   if (json) {
     console.log(JSON.stringify(status, null, 2));
   } else {
@@ -22,37 +22,37 @@ async function getSystemStatus(verbose = false) {
     orchestrator: {
       running: false,
       uptime: 0,
-      status: 'Not Running'
+      status: 'Not Running',
     },
     agents: {
       active: 0,
       total: 0,
-      types: {}
+      types: {},
     },
     tasks: {
       queued: 0,
       running: 0,
       completed: 0,
-      failed: 0
+      failed: 0,
     },
     memory: {
       status: 'Ready',
       entries: await getMemoryStats(),
-      size: '0.37 KB'
+      size: '0.37 KB',
     },
     terminal: {
       status: 'Ready',
       poolSize: 10,
-      active: 0
+      active: 0,
     },
     mcp: {
       status: 'Stopped',
       port: null,
-      connections: 0
+      connections: 0,
     },
-    resources: verbose ? await getResourceUsage() : null
+    resources: verbose ? await getResourceUsage() : null,
   };
-  
+
   return status;
 }
 
@@ -61,12 +61,12 @@ async function getMemoryStats() {
     const memoryStore = './memory/memory-store.json';
     const content = await Deno.readTextFile(memoryStore);
     const data = JSON.parse(content);
-    
+
     let totalEntries = 0;
     for (const entries of Object.values(data)) {
       totalEntries += entries.length;
     }
-    
+
     return totalEntries;
   } catch {
     return 0;
@@ -88,11 +88,11 @@ async function getResourceUsage() {
         return {
           memory: { usage: 'N/A (os module unavailable)' },
           cpu: { cores: 'Unknown', load: 'Unknown' },
-          platform: { type: 'Unknown', error: 'os module not available' }
+          platform: { type: 'Unknown', error: 'os module not available' },
         };
       }
     }
-    
+
     // Node.js doesn't have systemMemoryInfo, use os module instead
     const totalMem = os.totalmem();
     const freeMem = os.freemem();
@@ -103,70 +103,72 @@ async function getResourceUsage() {
       buffers: 0,
       cached: 0,
       swapTotal: 0,
-      swapFree: 0
+      swapFree: 0,
     };
-    
+
     // Get CPU info
     let cpuCores = os.cpus().length;
     let loadAvg = 'N/A';
-    
+
     try {
       const loadAvgData = os.loadavg();
       loadAvg = `${loadAvgData[0].toFixed(2)}, ${loadAvgData[1].toFixed(2)}, ${loadAvgData[2].toFixed(2)}`;
     } catch (e) {
       // Load average not available on all platforms
     }
-    
+
     return {
       memory: {
         total: formatBytes(memInfo.total),
         free: formatBytes(memInfo.free),
         available: formatBytes(memInfo.available),
-        usage: `${Math.round(((memInfo.total - memInfo.available) / memInfo.total) * 100)}%`
+        usage: `${Math.round(((memInfo.total - memInfo.available) / memInfo.total) * 100)}%`,
       },
       cpu: {
         cores: cpuCores,
         load: loadAvg,
-        model: os.cpus()[0]?.model || 'Unknown'
+        model: os.cpus()[0]?.model || 'Unknown',
       },
       platform: {
         type: os.type(),
         release: os.release(),
         arch: os.arch(),
-        uptime: formatUptime(os.uptime() * 1000)
-      }
+        uptime: formatUptime(os.uptime() * 1000),
+      },
     };
   } catch (error) {
     return {
       memory: { usage: 'Unknown' },
       cpu: { cores: 'Unknown', load: 'Unknown' },
-      platform: { type: 'Unknown', error: error.message }
+      platform: { type: 'Unknown', error: error.message },
     };
   }
 }
 
 function displayStatus(status, verbose) {
   printSuccess('Claude-Flow System Status:');
-  
+
   // Overall status
   const overallStatus = status.orchestrator.running ? '🟢 Running' : '🟡 Not Running';
-  console.log(`${overallStatus} (orchestrator ${status.orchestrator.running ? 'active' : 'not started'})`);
-  
+  console.log(
+    `${overallStatus} (orchestrator ${status.orchestrator.running ? 'active' : 'not started'})`,
+  );
+
   // Core components
   console.log(`🤖 Agents: ${status.agents.active} active`);
   console.log(`📋 Tasks: ${status.tasks.queued} in queue`);
   console.log(`💾 Memory: ${status.memory.status} (${status.memory.entries} entries)`);
   console.log(`🖥️  Terminal Pool: ${status.terminal.status}`);
   console.log(`🌐 MCP Server: ${status.mcp.status}`);
-  
+
   if (verbose) {
     console.log('\n📊 Detailed Information:');
-    
+
     // Orchestrator details
     console.log('\n🎭 Orchestrator:');
     console.log(`   Status: ${status.orchestrator.status}`);
     console.log(`   Uptime: ${formatUptime(status.orchestrator.uptime)}`);
-    
+
     // Agent details
     console.log('\n🤖 Agent Details:');
     console.log(`   Total Registered: ${status.agents.total}`);
@@ -179,54 +181,58 @@ function displayStatus(status, verbose) {
     } else {
       console.log('   No agents currently registered');
     }
-    
+
     // Task details
     console.log('\n📋 Task Queue:');
     console.log(`   Queued: ${status.tasks.queued}`);
     console.log(`   Running: ${status.tasks.running}`);
     console.log(`   Completed: ${status.tasks.completed}`);
     console.log(`   Failed: ${status.tasks.failed}`);
-    
+
     // Memory details
     console.log('\n💾 Memory System:');
     console.log(`   Total Entries: ${status.memory.entries}`);
     console.log(`   Database Size: ${status.memory.size}`);
     console.log(`   Status: ${status.memory.status}`);
-    
+
     // Terminal details
     console.log('\n🖥️  Terminal Pool:');
     console.log(`   Pool Size: ${status.terminal.poolSize}`);
     console.log(`   Active Sessions: ${status.terminal.active}`);
     console.log(`   Status: ${status.terminal.status}`);
-    
+
     // MCP details
     console.log('\n🌐 MCP Server:');
     console.log(`   Status: ${status.mcp.status}`);
     console.log(`   Port: ${status.mcp.port || 'Not configured'}`);
     console.log(`   Active Connections: ${status.mcp.connections}`);
-    
+
     // Resource usage
     if (status.resources) {
       console.log('\n📈 Resource Usage:');
-      console.log(`   Memory: ${status.resources.memory.usage} of ${status.resources.memory.total}`);
+      console.log(
+        `   Memory: ${status.resources.memory.usage} of ${status.resources.memory.total}`,
+      );
       console.log(`   Available: ${status.resources.memory.available}`);
       console.log(`   CPU Cores: ${status.resources.cpu.cores}`);
       console.log(`   CPU Load: ${status.resources.cpu.load}`);
       if (status.resources.cpu.model) {
         console.log(`   CPU Model: ${status.resources.cpu.model}`);
       }
-      
+
       if (status.resources.platform) {
         console.log('\n💻 Platform:');
-        console.log(`   OS: ${status.resources.platform.type} ${status.resources.platform.release}`);
+        console.log(
+          `   OS: ${status.resources.platform.type} ${status.resources.platform.release}`,
+        );
         console.log(`   Architecture: ${status.resources.platform.arch}`);
         console.log(`   System Uptime: ${status.resources.platform.uptime}`);
       }
     }
-    
+
     console.log('\n🕐 Status captured at:', new Date(status.timestamp).toLocaleString());
   }
-  
+
   // Recommendations
   console.log('\n💡 Quick Actions:');
   if (!status.orchestrator.running) {
@@ -244,23 +250,23 @@ function formatBytes(bytes) {
   const units = ['B', 'KB', 'MB', 'GB', 'TB'];
   let size = bytes;
   let unitIndex = 0;
-  
+
   while (size >= 1024 && unitIndex < units.length - 1) {
     size /= 1024;
     unitIndex++;
   }
-  
+
   return `${size.toFixed(2)} ${units[unitIndex]}`;
 }
 
 function formatUptime(milliseconds) {
   if (milliseconds === 0) return '0s';
-  
+
   const seconds = Math.floor(milliseconds / 1000);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
   const days = Math.floor(hours / 24);
-  
+
   if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
   if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
   if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
@@ -271,7 +277,7 @@ function formatUptime(milliseconds) {
 if (import.meta.main) {
   const args = [];
   const flags = {};
-  
+
   // Parse arguments and flags from Deno.args if available
   if (typeof Deno !== 'undefined' && Deno.args) {
     for (let i = 0; i < Deno.args.length; i++) {
@@ -279,7 +285,7 @@ if (import.meta.main) {
       if (arg.startsWith('--')) {
         const flagName = arg.substring(2);
         const nextArg = Deno.args[i + 1];
-        
+
         if (nextArg && !nextArg.startsWith('--')) {
           flags[flagName] = nextArg;
           i++; // Skip the next argument
@@ -291,6 +297,6 @@ if (import.meta.main) {
       }
     }
   }
-  
+
   await statusCommand(args, flags);
-}
+}