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

package/src/cli/ui/compatible-ui.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Compatible Terminal UI - Works without raw mode
  * Designed for environments that don't support stdin raw mode
@@ -37,16 +36,16 @@ export class CompatibleUI {
     this.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
-      terminal: false // Don't require raw mode
+      terminal: false, // Don't require raw mode
     });
   }
 
   async start(): Promise<void> {
     this.running = true;
-    
+
     // Initial render
     this.render();
-    
+
     // Setup command loop
     while (this.running) {
       const command = await this.promptCommand();
@@ -82,28 +81,28 @@ export class CompatibleUI {
       case 'exit':
         await this.handleExit();
         break;
-        
+
       case 'r':
       case 'refresh':
         this.render();
         break;
-        
+
       case 'h':
       case 'help':
       case '?':
         this.outputHelp();
         break;
-        
+
       case 's':
       case 'status':
         this.showStatus();
         break;
-        
+
       case 'l':
       case 'list':
         this.showProcessList();
         break;
-        
+
       default:
         // Check if it's a number (process selection)
         const num = parseInt(input);
@@ -123,21 +122,23 @@ export class CompatibleUI {
     // Header
     console.log(chalk.cyan.bold('🧠 Claude-Flow System Monitor'));
     console.log(chalk.gray('─'.repeat(60)));
-    
+
     // System stats
-    console.log(chalk.white('System Status:'), 
-      chalk.green(`${stats.runningProcesses}/${stats.totalProcesses} running`));
-    
+    console.log(
+      chalk.white('System Status:'),
+      chalk.green(`${stats.runningProcesses}/${stats.totalProcesses} running`),
+    );
+
     if (stats.errorProcesses > 0) {
       console.log(chalk.red(`⚠️  ${stats.errorProcesses} processes with errors`));
     }
-    
+
     console.log();
 
     // Process list
     console.log(chalk.white.bold('Processes:'));
     console.log(chalk.gray('─'.repeat(60)));
-    
+
     if (this.processes.length === 0) {
       console.log(chalk.gray('No processes configured'));
     } else {
@@ -145,9 +146,9 @@ export class CompatibleUI {
         const num = `[${index + 1}]`.padEnd(4);
         const status = this.getStatusDisplay(process.status);
         const name = process.name.padEnd(25);
-        
+
         console.log(`${chalk.gray(num)} ${status} ${chalk.white(name)}`);
-        
+
         if (process.metrics?.lastError) {
           console.log(chalk.red(`       Error: ${process.metrics.lastError}`));
         }
@@ -156,18 +157,25 @@ export class CompatibleUI {
 
     // Footer
     console.log(chalk.gray('─'.repeat(60)));
-    console.log(chalk.gray('Commands: [1-9] Process details [s] Status [l] List [r] Refresh [h] Help [q] Quit'));
+    console.log(
+      chalk.gray(
+        'Commands: [1-9] Process details [s] Status [l] List [r] Refresh [h] Help [q] Quit',
+      ),
+    );
   }
 
   private showStatus(): void {
     const stats = this.getSystemStats();
-    
+
     console.log();
     console.log(chalk.cyan.bold('📊 System Status Details'));
     console.log(chalk.gray('─'.repeat(40)));
     console.log(chalk.white('Total Processes:'), stats.totalProcesses);
     console.log(chalk.white('Running:'), chalk.green(stats.runningProcesses));
-    console.log(chalk.white('Stopped:'), chalk.gray(stats.totalProcesses - stats.runningProcesses - stats.errorProcesses));
+    console.log(
+      chalk.white('Stopped:'),
+      chalk.gray(stats.totalProcesses - stats.runningProcesses - stats.errorProcesses),
+    );
     console.log(chalk.white('Errors:'), chalk.red(stats.errorProcesses));
     console.log(chalk.white('System Load:'), this.getSystemLoad());
     console.log(chalk.white('Uptime:'), this.getSystemUptime());
@@ -177,25 +185,27 @@ export class CompatibleUI {
     console.log();
     console.log(chalk.cyan.bold('📋 Process List'));
     console.log(chalk.gray('─'.repeat(60)));
-    
+
     if (this.processes.length === 0) {
       console.log(chalk.gray('No processes configured'));
       return;
     }
 
     this.processes.forEach((process, index) => {
-      console.log(`${chalk.gray(`[${index + 1}]`)} ${this.getStatusDisplay(process.status)} ${chalk.white.bold(process.name)}`);
+      console.log(
+        `${chalk.gray(`[${index + 1}]`)} ${this.getStatusDisplay(process.status)} ${chalk.white.bold(process.name)}`,
+      );
       console.log(chalk.gray(`    Type: ${process.type}`));
-      
+
       if (process.pid) {
         console.log(chalk.gray(`    PID: ${process.pid}`));
       }
-      
+
       if (process.startTime) {
         const uptime = Date.now() - process.startTime;
         console.log(chalk.gray(`    Uptime: ${this.formatUptime(uptime)}`));
       }
-      
+
       if (process.metrics) {
         if (process.metrics.cpu !== undefined) {
           console.log(chalk.gray(`    CPU: ${process.metrics.cpu.toFixed(1)}%`));
@@ -204,7 +214,7 @@ export class CompatibleUI {
           console.log(chalk.gray(`    Memory: ${process.metrics.memory.toFixed(0)} MB`));
         }
       }
-      
+
       console.log();
     });
   }
@@ -213,20 +223,20 @@ export class CompatibleUI {
     console.log();
     console.log(chalk.cyan.bold(`📋 Process Details: ${process.name}`));
     console.log(chalk.gray('─'.repeat(60)));
-    
+
     console.log(chalk.white('ID:'), process.id);
     console.log(chalk.white('Type:'), process.type);
     console.log(chalk.white('Status:'), this.getStatusDisplay(process.status), process.status);
-    
+
     if (process.pid) {
       console.log(chalk.white('PID:'), process.pid);
     }
-    
+
     if (process.startTime) {
       const uptime = Date.now() - process.startTime;
       console.log(chalk.white('Uptime:'), this.formatUptime(uptime));
     }
-    
+
     if (process.metrics) {
       console.log();
       console.log(chalk.white.bold('Metrics:'));
@@ -267,8 +277,9 @@ export class CompatibleUI {
   private getSystemStats(): UISystemStats {
     return {
       totalProcesses: this.processes.length,
-      runningProcesses: this.processes.filter(p => p.status === 'running').length,
-      errorProcesses: this.processes.filter(p => p.status === 'error' || p.status === 'crashed').length
+      runningProcesses: this.processes.filter((p) => p.status === 'running').length,
+      errorProcesses: this.processes.filter((p) => p.status === 'error' || p.status === 'crashed')
+        .length,
     };
   }
 
@@ -320,15 +331,15 @@ export class CompatibleUI {
   }
 
   private async handleExit(): Promise<void> {
-    const runningProcesses = this.processes.filter(p => p.status === 'running');
-    
+    const runningProcesses = this.processes.filter((p) => p.status === 'running');
+
     if (runningProcesses.length > 0) {
       console.log();
       console.log(chalk.yellow(`⚠️  ${runningProcesses.length} processes are still running.`));
       console.log('These processes will continue running in the background.');
       console.log('Use the main CLI to stop them if needed.');
     }
-    
+
     this.stop();
   }
 }
@@ -350,7 +361,7 @@ export function isRawModeSupported(): boolean {
 // Fallback UI launcher that chooses the best available UI
 export async function launchUI(): Promise<void> {
   const ui = createCompatibleUI();
-  
+
   // Mock some example processes for demonstration
   const mockProcesses: UIProcess[] = [
     {
@@ -360,7 +371,7 @@ export async function launchUI(): Promise<void> {
       type: 'core',
       pid: 12345,
       startTime: Date.now() - 30000,
-      metrics: { cpu: 2.1, memory: 45.2, restarts: 0 }
+      metrics: { cpu: 2.1, memory: 45.2, restarts: 0 },
     },
     {
       id: 'memory-manager',
@@ -369,22 +380,22 @@ export async function launchUI(): Promise<void> {
       type: 'service',
       pid: 12346,
       startTime: Date.now() - 25000,
-      metrics: { cpu: 0.8, memory: 12.5, restarts: 0 }
+      metrics: { cpu: 0.8, memory: 12.5, restarts: 0 },
     },
     {
       id: 'mcp-server',
       name: 'MCP Server',
       status: 'stopped',
       type: 'server',
-      metrics: { restarts: 1 }
-    }
+      metrics: { restarts: 1 },
+    },
   ];
-  
+
   ui.updateProcesses(mockProcesses);
-  
+
   console.log(chalk.green('✅ Starting Claude-Flow UI (compatible mode)'));
   console.log(chalk.gray('Note: Using compatible UI mode for broader terminal support'));
   console.log();
-  
+
   await ui.start();
-}
+}

package/src/cli/ui/fallback-handler.ts

@@ -17,12 +17,15 @@ export interface FallbackOptions {
  * Handles raw mode errors and provides fallback UI
  */
 export async function handleRawModeError(
-  error: Error, 
-  options: FallbackOptions = {}
+  error: Error,
+  options: FallbackOptions = {},
 ): Promise<void> {
-  const isRawModeError = (error instanceof Error ? error.message : String(error)).includes('Raw mode is not supported') || 
-                        (error instanceof Error ? error.message : String(error)).includes('stdin') ||
-                        (error instanceof Error ? error.message : String(error)).includes('Ink');
+  const isRawModeError =
+    (error instanceof Error ? error.message : String(error)).includes(
+      'Raw mode is not supported',
+    ) ||
+    (error instanceof Error ? error.message : String(error)).includes('stdin') ||
+    (error instanceof Error ? error.message : String(error)).includes('Ink');
 
   if (!isRawModeError) {
     throw error; // Re-throw if it's not a raw mode error
@@ -51,7 +54,7 @@ export async function handleRawModeError(
   if (options.enableUI) {
     console.log(chalk.green('✅ Launching compatible UI mode...'));
     console.log();
-    
+
     try {
       const ui = createCompatibleUI();
       await ui.start();
@@ -91,7 +94,7 @@ async function showBasicInterface(options: FallbackOptions): Promise<void> {
   }
 
   console.log(chalk.gray('Press Ctrl+C to exit'));
-  
+
   // Wait for user to exit
   await new Promise(() => {
     process.on('SIGINT', () => {
@@ -106,7 +109,7 @@ async function showBasicInterface(options: FallbackOptions): Promise<void> {
  */
 export function withRawModeFallback<T extends any[], R>(
   fn: (...args: T) => Promise<R>,
-  fallbackOptions: FallbackOptions = {}
+  fallbackOptions: FallbackOptions = {},
 ) {
   return async (...args: T): Promise<R | void> => {
     try {
@@ -134,7 +137,7 @@ export function checkUISupport(): {
     return {
       supported: false,
       reason: 'Not running in a TTY environment',
-      recommendation: 'Use a proper terminal application'
+      recommendation: 'Use a proper terminal application',
     };
   }
 
@@ -143,7 +146,7 @@ export function checkUISupport(): {
     return {
       supported: false,
       reason: 'Raw mode not available',
-      recommendation: 'Use --no-ui flag or run in external terminal'
+      recommendation: 'Use --no-ui flag or run in external terminal',
     };
   }
 
@@ -152,7 +155,7 @@ export function checkUISupport(): {
     return {
       supported: false,
       reason: 'Running in VS Code integrated terminal',
-      recommendation: 'Use VS Code external terminal or standalone terminal'
+      recommendation: 'Use VS Code external terminal or standalone terminal',
     };
   }
 
@@ -161,7 +164,7 @@ export function checkUISupport(): {
     return {
       supported: false,
       reason: 'Running in CI/CD environment',
-      recommendation: 'Use non-interactive mode'
+      recommendation: 'Use non-interactive mode',
     };
   }
 
@@ -173,10 +176,10 @@ export function checkUISupport(): {
  */
 export function showUISupport(): void {
   const support = checkUISupport();
-  
+
   console.log(chalk.cyan.bold('🖥️  UI Support Information'));
   console.log(chalk.gray('─'.repeat(40)));
-  
+
   if (support.supported) {
     console.log(chalk.green('✅ Interactive UI supported'));
     console.log(chalk.gray('Your terminal supports all UI features'));
@@ -187,11 +190,11 @@ export function showUISupport(): void {
       console.log(chalk.blue(`Recommendation: ${support.recommendation}`));
     }
   }
-  
+
   console.log();
   console.log(chalk.white('Environment details:'));
   console.log(chalk.gray(`• Terminal: ${process.env.TERM || 'unknown'}`));
   console.log(chalk.gray(`• TTY: ${process.stdin.isTTY ? 'yes' : 'no'}`));
   console.log(chalk.gray(`• Program: ${process.env.TERM_PROGRAM || 'unknown'}`));
   console.log(chalk.gray(`• Platform: ${process.platform}`));
-}
+}

package/src/cli/ui/index.ts

@@ -1,24 +1,23 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Claude-Flow UI Module
  * Provides compatible UI solutions for different terminal environments
  */
 
-export { 
-  CompatibleUI, 
-  createCompatibleUI, 
-  isRawModeSupported, 
+export {
+  CompatibleUI,
+  createCompatibleUI,
+  isRawModeSupported,
   launchUI,
   type UIProcess,
-  type UISystemStats 
+  type UISystemStats,
 } from './compatible-ui.js';
 
-export { 
-  handleRawModeError, 
-  withRawModeFallback, 
-  checkUISupport, 
+export {
+  handleRawModeError,
+  withRawModeFallback,
+  checkUISupport,
   showUISupport,
-  type FallbackOptions 
+  type FallbackOptions,
 } from './fallback-handler.js';
 
 /**
@@ -27,16 +26,16 @@ export {
 export async function launchBestUI(): Promise<void> {
   const { checkUISupport, launchUI, handleRawModeError } = await import('./fallback-handler.js');
   const support = checkUISupport();
-  
+
   if (support.supported) {
     try {
       await launchUI();
     } catch (error) {
       if (error instanceof Error) {
-        await handleRawModeError(error, { 
+        await handleRawModeError(error, {
           enableUI: true,
           fallbackMessage: 'Falling back to compatible UI mode',
-          showHelp: true 
+          showHelp: true,
         });
       }
     }
@@ -45,4 +44,4 @@ export async function launchBestUI(): Promise<void> {
     console.log('🔄 Using compatible UI mode for this environment');
     await launchCompatibleUI();
   }
-}
+}