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

package/src/terminal/manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 import * as process from 'node:process';
 /**
  * Terminal manager interface and implementation
@@ -20,7 +19,11 @@ export interface ITerminalManager {
   spawnTerminal(profile: AgentProfile): Promise<string>;
   terminateTerminal(terminalId: string): Promise<void>;
   executeCommand(terminalId: string, command: string): Promise<string>;
-  getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;
+  getHealthStatus(): Promise<{
+    healthy: boolean;
+    error?: string;
+    metrics?: Record<string, number>;
+  }>;
   performMaintenance(): Promise<void>;
 }
 
@@ -40,7 +43,7 @@ export class TerminalManager implements ITerminalManager {
   ) {
     // Select adapter based on configuration
     this.adapter = this.createAdapter();
-    
+
     // Create terminal pool
     this.pool = new TerminalPool(
       this.config.poolSize,
@@ -82,9 +85,7 @@ export class TerminalManager implements ITerminalManager {
     try {
       // Terminate all sessions
       const sessionIds = Array.from(this.sessions.keys());
-      await Promise.all(
-        sessionIds.map((id) => this.terminateTerminal(id)),
-      );
+      await Promise.all(sessionIds.map((id) => this.terminateTerminal(id)));
 
       // Shutdown pool
       await this.pool.shutdown();
@@ -125,8 +126,8 @@ export class TerminalManager implements ITerminalManager {
       // Store session
       this.sessions.set(session.id, session);
 
-      this.logger.info('Terminal spawned', { 
-        terminalId: session.id, 
+      this.logger.info('Terminal spawned', {
+        terminalId: session.id,
         agentId: profile.id,
       });
 
@@ -171,16 +172,17 @@ export class TerminalManager implements ITerminalManager {
     return await session.executeCommand(command);
   }
 
-  async getHealthStatus(): Promise<{ 
-    healthy: boolean; 
-    error?: string; 
+  async getHealthStatus(): Promise<{
+    healthy: boolean;
+    error?: string;
     metrics?: Record<string, number>;
   }> {
     try {
       const poolHealth = await this.pool.getHealthStatus();
       const activeSessions = this.sessions.size;
-      const healthySessions = Array.from(this.sessions.values())
-        .filter((session) => session.isHealthy()).length;
+      const healthySessions = Array.from(this.sessions.values()).filter((session) =>
+        session.isHealthy(),
+      ).length;
 
       const metrics = {
         activeSessions,
@@ -221,13 +223,14 @@ export class TerminalManager implements ITerminalManager {
 
     try {
       // Clean up dead sessions
-      const deadSessions = Array.from(this.sessions.entries())
-        .filter(([_, session]) => !session.isHealthy());
+      const deadSessions = Array.from(this.sessions.entries()).filter(
+        ([_, session]) => !session.isHealthy(),
+      );
 
       for (const [terminalId, _] of deadSessions) {
         this.logger.warn('Cleaning up dead terminal session', { terminalId });
-        await this.terminateTerminal(terminalId).catch(error => 
-          this.logger.error('Failed to clean up terminal', { terminalId, error })
+        await this.terminateTerminal(terminalId).catch((error) =>
+          this.logger.error('Failed to clean up terminal', { terminalId, error }),
         );
       }
 
@@ -251,7 +254,7 @@ export class TerminalManager implements ITerminalManager {
    * Get all active sessions
    */
   getActiveSessions(): AgentSession[] {
-    return Array.from(this.sessions.values()).map(session => ({
+    return Array.from(this.sessions.values()).map((session) => ({
       id: session.id,
       agentId: session.profile.id,
       terminalId: session.terminal.id,
@@ -303,8 +306,10 @@ export class TerminalManager implements ITerminalManager {
 
   private isVSCodeEnvironment(): boolean {
     // Check for VSCode-specific environment variables
-    return process.env.TERM_PROGRAM === 'vscode' ||
-           process.env.VSCODE_PID !== undefined ||
-           process.env.VSCODE_IPC_HOOK !== undefined;
+    return (
+      process.env.TERM_PROGRAM === 'vscode' ||
+      process.env.VSCODE_PID !== undefined ||
+      process.env.VSCODE_IPC_HOOK !== undefined
+    );
   }
-}
+}

package/src/terminal/pool.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Terminal pool management
  */
@@ -40,7 +39,7 @@ export class TerminalPool {
   }
 
   private async doInitialize(): Promise<void> {
-    this.logger.info('Initializing terminal pool', { 
+    this.logger.info('Initializing terminal pool', {
       maxSize: this.maxSize,
       recycleAfter: this.recycleAfter,
     });
@@ -54,8 +53,8 @@ export class TerminalPool {
     }
 
     await Promise.all(promises);
-    
-    this.logger.info('Terminal pool initialized', { 
+
+    this.logger.info('Terminal pool initialized', {
       created: preCreateCount,
     });
   }
@@ -65,9 +64,7 @@ export class TerminalPool {
 
     // Destroy all terminals
     const terminals = Array.from(this.terminals.values());
-    await Promise.all(
-      terminals.map(({ terminal }) => this.adapter.destroyTerminal(terminal)),
-    );
+    await Promise.all(terminals.map(({ terminal }) => this.adapter.destroyTerminal(terminal)));
 
     this.terminals.clear();
     this.availableQueue = [];
@@ -82,8 +79,8 @@ export class TerminalPool {
       if (pooled && pooled.terminal.isAlive()) {
         pooled.inUse = true;
         pooled.lastUsed = new Date();
-        
-        this.logger.debug('Terminal acquired from pool', { 
+
+        this.logger.debug('Terminal acquired from pool', {
           terminalId,
           useCount: pooled.useCount,
         });
@@ -105,7 +102,7 @@ export class TerminalPool {
 
     // Pool is full, wait for a terminal to become available
     this.logger.info('Terminal pool full, waiting for available terminal');
-    
+
     const startTime = Date.now();
     const timeout = 30000; // 30 seconds
 
@@ -130,7 +127,7 @@ export class TerminalPool {
   async release(terminal: Terminal): Promise<void> {
     const pooled = this.terminals.get(terminal.id);
     if (!pooled) {
-      this.logger.warn('Attempted to release unknown terminal', { 
+      this.logger.warn('Attempted to release unknown terminal', {
         terminalId: terminal.id,
       });
       return;
@@ -141,7 +138,7 @@ export class TerminalPool {
 
     // Check if terminal should be recycled
     if (pooled.useCount >= this.recycleAfter || !terminal.isAlive()) {
-      this.logger.info('Recycling terminal', { 
+      this.logger.info('Recycling terminal', {
         terminalId: terminal.id,
         useCount: pooled.useCount,
       });
@@ -157,8 +154,8 @@ export class TerminalPool {
     } else {
       // Return to available queue
       this.availableQueue.push(terminal.id);
-      
-      this.logger.debug('Terminal returned to pool', { 
+
+      this.logger.debug('Terminal returned to pool', {
         terminalId: terminal.id,
         useCount: pooled.useCount,
       });
@@ -171,8 +168,8 @@ export class TerminalPool {
     available: number;
     recycled: number;
   }> {
-    const aliveTerminals = Array.from(this.terminals.values()).filter(
-      (pooled) => pooled.terminal.isAlive(),
+    const aliveTerminals = Array.from(this.terminals.values()).filter((pooled) =>
+      pooled.terminal.isAlive(),
     );
 
     const available = aliveTerminals.filter((pooled) => !pooled.inUse).length;
@@ -212,12 +209,12 @@ export class TerminalPool {
     // Ensure minimum pool size
     const currentSize = this.terminals.size;
     const minSize = Math.min(2, this.maxSize);
-    
+
     if (currentSize < minSize) {
       const toCreate = minSize - currentSize;
-      this.logger.info('Replenishing terminal pool', { 
-        currentSize, 
-        minSize, 
+      this.logger.info('Replenishing terminal pool', {
+        currentSize,
+        minSize,
         creating: toCreate,
       });
 
@@ -225,23 +222,23 @@ export class TerminalPool {
       for (let i = 0; i < toCreate; i++) {
         promises.push(this.createPooledTerminal());
       }
-      
+
       await Promise.all(promises);
     }
 
     // Check for stale terminals that should be recycled
     const now = Date.now();
     const staleTimeout = 300000; // 5 minutes
-    
+
     for (const [id, pooled] of this.terminals.entries()) {
       if (!pooled.inUse && pooled.terminal.isAlive()) {
         const idleTime = now - pooled.lastUsed.getTime();
         if (idleTime > staleTimeout) {
-          this.logger.info('Recycling stale terminal', { 
-            terminalId: id, 
+          this.logger.info('Recycling stale terminal', {
+            terminalId: id,
             idleTime,
           });
-          
+
           // Mark for recycling
           pooled.useCount = this.recycleAfter;
         }
@@ -252,7 +249,7 @@ export class TerminalPool {
   private async createPooledTerminal(): Promise<void> {
     try {
       const terminal = await this.adapter.createTerminal();
-      
+
       const pooled: PooledTerminal = {
         terminal,
         useCount: 0,
@@ -269,4 +266,4 @@ export class TerminalPool {
       throw error;
     }
   }
-}
+}

package/src/terminal/session.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Terminal session management
  */
@@ -39,7 +38,7 @@ export class TerminalSession {
       return;
     }
 
-    this.logger.debug('Initializing terminal session', { 
+    this.logger.debug('Initializing terminal session', {
       sessionId: this.id,
       agentId: this.profile.id,
     });
@@ -52,8 +51,8 @@ export class TerminalSession {
       await this.runInitializationCommands();
 
       this.initialized = true;
-      
-      this.logger.info('Terminal session initialized', { 
+
+      this.logger.info('Terminal session initialized', {
         sessionId: this.id,
         agentId: this.profile.id,
       });
@@ -72,7 +71,7 @@ export class TerminalSession {
       throw new TerminalCommandError('Terminal is not alive');
     }
 
-    this.logger.debug('Executing command', { 
+    this.logger.debug('Executing command', {
       sessionId: this.id,
       command: command.substring(0, 100),
     });
@@ -95,19 +94,19 @@ export class TerminalSession {
       this.commandHistory.push(command);
       this.lastCommandTime = new Date();
 
-      this.logger.debug('Command executed successfully', { 
+      this.logger.debug('Command executed successfully', {
         sessionId: this.id,
         outputLength: result.length,
       });
 
       return result;
     } catch (error) {
-      this.logger.error('Command execution failed', { 
+      this.logger.error('Command execution failed', {
         sessionId: this.id,
         command,
         error,
       });
-      throw new TerminalCommandError('Command execution failed', { 
+      throw new TerminalCommandError('Command execution failed', {
         command,
         error,
       });
@@ -121,7 +120,7 @@ export class TerminalSession {
       // Run cleanup commands
       await this.runCleanupCommands();
     } catch (error) {
-      this.logger.warn('Error during session cleanup', { 
+      this.logger.warn('Error during session cleanup', {
         sessionId: this.id,
         error,
       });
@@ -136,7 +135,8 @@ export class TerminalSession {
     // Check if terminal is responsive
     if (this.lastCommandTime) {
       const timeSinceLastCommand = Date.now() - this.lastCommandTime.getTime();
-      if (timeSinceLastCommand > 300000) { // 5 minutes
+      if (timeSinceLastCommand > 300000) {
+        // 5 minutes
         // Terminal might be stale, do a health check
         this.performHealthCheck().catch((error) => {
           this.logger.warn('Health check failed', { sessionId: this.id, error });
@@ -165,9 +165,7 @@ export class TerminalSession {
 
     // Set working directory if specified
     if (this.profile.metadata?.workingDirectory) {
-      await this.terminal.executeCommand(
-        `cd "${this.profile.metadata.workingDirectory}"`,
-      );
+      await this.terminal.executeCommand(`cd "${this.profile.metadata.workingDirectory}"`);
     }
   }
 
@@ -212,7 +210,9 @@ export class TerminalSession {
 
       this.lastCommandTime = new Date();
     } catch (error) {
-      throw new Error(`Health check failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `Health check failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
     }
   }
 
@@ -221,12 +221,12 @@ export class TerminalSession {
    */
   streamOutput(callback: (output: string) => void): () => void {
     this.outputListeners.add(callback);
-    
+
     // Set up terminal output listener if supported
     if (this.terminal.addOutputListener) {
       this.terminal.addOutputListener(callback);
     }
-    
+
     // Return unsubscribe function
     return () => {
       this.outputListeners.delete(callback);
@@ -240,7 +240,7 @@ export class TerminalSession {
    * Notify output listeners
    */
   private notifyOutputListeners(output: string): void {
-    this.outputListeners.forEach(listener => {
+    this.outputListeners.forEach((listener) => {
       try {
         listener(output);
       } catch (error) {
@@ -248,4 +248,4 @@ export class TerminalSession {
       }
     });
   }
-}
+}

package/src/terminal/vscode-bridge.ts

@@ -1,10 +1,10 @@
 import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * VSCode Extension Bridge for Terminal Integration
- * 
+ *
  * This file provides the bridge between Claude-Flow and VSCode extension API
  * for terminal management and output capture.
- * 
+ *
  * NOTE: This file is only used when Claude-Flow is packaged as a VS Code extension.
  * It is excluded from the main CLI build. If you need to use this in a VS Code
  * extension context, install @types/vscode as a devDependency.
@@ -37,16 +37,16 @@ export function initializeTerminalBridge(context: vscode.ExtensionContext): void
   // Register terminal output processor function
   (globalThis as any).registerTerminalOutputProcessor = (
     terminalId: string,
-    processor: (data: string) => void
+    processor: (data: string) => void,
   ) => {
     terminalOutputProcessors.set(terminalId, processor);
   };
 
   // Override terminal creation to capture output
   const originalCreateTerminal = vscode.window.createTerminal;
-  (vscode.window as any).createTerminal = function(options: vscode.TerminalOptions) {
+  (vscode.window as any).createTerminal = function (options: vscode.TerminalOptions) {
     const terminal = originalCreateTerminal.call(vscode.window, options) as vscode.Terminal;
-    
+
     // Create write emulator for this terminal
     const writeEmulator = new vscode.EventEmitter<string>();
     terminalWriteEmulators.set(terminal, writeEmulator);
@@ -56,7 +56,7 @@ export function initializeTerminalBridge(context: vscode.ExtensionContext): void
     if (match) {
       const terminalId = match[1];
       activeTerminals.set(terminalId, terminal);
-      
+
       // Set up output capture
       captureTerminalOutput(terminal, terminalId);
     }
@@ -75,14 +75,14 @@ export function initializeTerminalBridge(context: vscode.ExtensionContext): void
           break;
         }
       }
-      
+
       // Clean up write emulator
       const emulator = terminalWriteEmulators.get(terminal);
       if (emulator) {
         emulator.dispose();
         terminalWriteEmulators.delete(terminal);
       }
-    })
+    }),
   );
 }
 
@@ -92,10 +92,10 @@ export function initializeTerminalBridge(context: vscode.ExtensionContext): void
 function captureTerminalOutput(terminal: vscode.Terminal, terminalId: string): void {
   // Method 1: Use terminal.sendText override to capture commands
   const originalSendText = terminal.sendText;
-  (terminal as any).sendText = function(text: string, addNewLine?: boolean) {
+  (terminal as any).sendText = function (text: string, addNewLine?: boolean) {
     // Call original method
     originalSendText.call(terminal, text, addNewLine);
-    
+
     // Process command
     const processor = terminalOutputProcessors.get(terminalId);
     if (processor && text) {
@@ -129,13 +129,13 @@ function setupTerminalRenderer(terminal: vscode.Terminal, terminalId: string): v
   if (vscode.window.registerTerminalProfileProvider) {
     // This is a more advanced method that requires additional setup
     // It would involve creating a custom terminal profile that captures output
-    
+
     // For now, we'll use a simpler approach with periodic output checking
     let lastOutput = '';
     const checkOutput = setInterval(() => {
       // This is a placeholder - actual implementation would depend on
       // available VSCode APIs for reading terminal content
-      
+
       // Check if terminal is still active
       if (!activeTerminals.has(terminalId)) {
         clearInterval(checkOutput);
@@ -150,13 +150,13 @@ function setupTerminalRenderer(terminal: vscode.Terminal, terminalId: string): v
 export async function createCapturedTerminal(
   name: string,
   shellPath?: string,
-  shellArgs?: string[]
+  shellArgs?: string[],
 ): Promise<{
   terminal: vscode.Terminal;
   onData: vscode.Event<string>;
 }> {
   const writeEmulator = new vscode.EventEmitter<string>();
-  
+
   const terminal = vscode.window.createTerminal({
     name,
     shellPath,
@@ -177,7 +177,7 @@ export async function createCapturedTerminal(
 export async function executeTerminalCommand(
   terminal: vscode.Terminal,
   command: string,
-  timeout: number = 30000
+  timeout: number = 30000,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     const writeEmulator = terminalWriteEmulators.get(terminal);
@@ -188,11 +188,11 @@ export async function executeTerminalCommand(
 
     let output = '';
     const marker = `__COMMAND_COMPLETE_${Date.now()}__`;
-    
+
     // Set up output listener
     const disposable = writeEmulator.event((data: string) => {
       output += data;
-      
+
       if (output.includes(marker)) {
         // Command completed
         disposable.dispose();
@@ -209,7 +209,7 @@ export async function executeTerminalCommand(
 
     // Execute command with marker
     terminal.sendText(`${command} && echo "${marker}"`);
-    
+
     // Clear timeout on success
     writeEmulator.event(() => {
       if (output.includes(marker)) {
@@ -235,13 +235,13 @@ export function disposeTerminalBridge(): void {
     terminal.dispose();
   }
   activeTerminals.clear();
-  
+
   // Clean up processors
   terminalOutputProcessors.clear();
-  
+
   // Clean up write emulators
   for (const emulator of terminalWriteEmulators.values()) {
     emulator.dispose();
   }
   terminalWriteEmulators.clear();
-}
+}

package/src/tests/validation-consistency.test.ts

@@ -18,21 +18,21 @@ describe('Agent Type Validation Consistency', () => {
 
   test('Claude Flow tools use consistent agent types', () => {
     const tools = getClaudeFlowTools({} as any);
-    const spawnTool = tools.find(t => t.name === 'spawn_agent');
+    const spawnTool = tools.find((t) => t.name === 'spawn_agent');
     const enumValues = spawnTool?.inputSchema.properties.type.enum;
     expect(enumValues?.sort()).toEqual(expectedTypes);
   });
 
   test('Ruv Swarm tools use consistent agent types', () => {
     const tools = getRuvSwarmTools({} as any);
-    const spawnTool = tools.find(t => t.name === 'spawn_agent');
+    const spawnTool = tools.find((t) => t.name === 'spawn_agent');
     const enumValues = spawnTool?.inputSchema.properties.type.enum;
     expect(enumValues?.sort()).toEqual(expectedTypes);
   });
 
   test('Swarm tools use consistent agent types', () => {
     const tools = getSwarmTools({} as any);
-    const spawnTool = tools.find(t => t.name === 'spawn_agent');
+    const spawnTool = tools.find((t) => t.name === 'spawn_agent');
     const enumValues = spawnTool?.inputSchema.properties.type.enum;
     expect(enumValues?.sort()).toEqual(expectedTypes);
   });
@@ -50,4 +50,4 @@ describe('Strategy Validation Consistency', () => {
     const strategies = taskOrchestrateTool.inputSchema.properties.strategy.enum;
     expect(strategies).toEqual(['parallel', 'sequential', 'adaptive', 'balanced']);
   });
-});
+});

package/src/types/cliffy.d.ts

@@ -5,11 +5,11 @@
 // - @cliffy/table -> cli-table3
 // - @cliffy/ansi/colors -> chalk
 // This file is kept for reference only and should be removed once migration is complete.
-declare module "@cliffy/ansi/colors" {
+declare module '@cliffy/ansi/colors' {
   export interface ColorFunction {
     (text: string): string;
   }
-  
+
   export interface Colors {
     green: ColorFunction;
     red: ColorFunction;
@@ -30,35 +30,32 @@ declare module "@cliffy/ansi/colors" {
     bgBlue: ColorFunction;
     // Add more as needed
   }
-  
+
   export const colors: Colors;
 }
 
-declare module "@cliffy/prompt" {
+declare module '@cliffy/prompt' {
   export function select<T>(options: {
     message: string;
     options: Array<{ name: string; value: T }>;
     default?: T;
   }): Promise<T>;
-  
+
   export function input(options: {
     message: string;
     default?: string;
     validate?: (value: string) => boolean | string;
   }): Promise<string>;
-  
-  export function confirm(options: {
-    message: string;
-    default?: boolean;
-  }): Promise<boolean>;
-  
+
+  export function confirm(options: { message: string; default?: boolean }): Promise<boolean>;
+
   export function number(options: {
     message: string;
     default?: number;
     min?: number;
     max?: number;
   }): Promise<number>;
-  
+
   // Legacy capitalized exports for backward compatibility
   export const Select: typeof select;
   export const Input: typeof input;
@@ -66,7 +63,7 @@ declare module "@cliffy/prompt" {
   export const Number: typeof number;
 }
 
-declare module "@cliffy/command" {
+declare module '@cliffy/command' {
   export class Command {
     name(name: string): this;
     version(version: string): this;
@@ -77,4 +74,4 @@ declare module "@cliffy/command" {
     parse(argv?: string[]): Promise<any>;
     showHelp(): void;
   }
-}
+}

package/src/types/global.d.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 // Global type definitions and environment compatibility
 
 // Node.js global augmentations
@@ -34,4 +33,4 @@ declare module 'cli-table3' {
   }
 }
 
-export {};
+export {};

package/src/types/index.ts

@@ -27,7 +27,7 @@ export enum ComponentStatus {
   HEALTHY = 'healthy',
   WARNING = 'warning',
   ERROR = 'error',
-  UNKNOWN = 'unknown'
+  UNKNOWN = 'unknown',
 }
 
 // Alert types for monitoring
@@ -38,4 +38,4 @@ export interface AlertData {
   timestamp: Date;
   component?: string;
   metadata?: Record<string, any>;
-}
+}