claude-flow 1.0.0

package/src/terminal/vscode-bridge.ts

@@ -0,0 +1,242 @@
+/**
+ * VSCode Extension Bridge for Terminal Integration
+ * 
+ * This file provides the bridge between Claude-Flow and VSCode extension API
+ * for terminal management and output capture.
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Terminal output processors registry
+ */
+const terminalOutputProcessors = new Map<string, (data: string) => void>();
+
+/**
+ * Active terminals registry
+ */
+const activeTerminals = new Map<string, vscode.Terminal>();
+
+/**
+ * Terminal write emulators for output capture
+ */
+const terminalWriteEmulators = new Map<vscode.Terminal, vscode.EventEmitter<string>>();
+
+/**
+ * Initialize the VSCode terminal bridge
+ */
+export function initializeTerminalBridge(context: vscode.ExtensionContext): void {
+  // Inject VSCode API into global scope for Claude-Flow
+  (globalThis as any).vscode = vscode;
+
+  // Register terminal output processor function
+  (globalThis as any).registerTerminalOutputProcessor = (
+    terminalId: string,
+    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) {
+    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);
+
+    // Find terminal ID from name
+    const match = options.name?.match(/Claude-Flow Terminal ([\w-]+)/);
+    if (match) {
+      const terminalId = match[1];
+      activeTerminals.set(terminalId, terminal);
+      
+      // Set up output capture
+      captureTerminalOutput(terminal, terminalId);
+    }
+
+    return terminal;
+  };
+
+  // Clean up on terminal close
+  context.subscriptions.push(
+    vscode.window.onDidCloseTerminal((terminal: vscode.Terminal) => {
+      // Find and remove from registries
+      for (const [id, term] of activeTerminals.entries()) {
+        if (term === terminal) {
+          activeTerminals.delete(id);
+          terminalOutputProcessors.delete(id);
+          break;
+        }
+      }
+      
+      // Clean up write emulator
+      const emulator = terminalWriteEmulators.get(terminal);
+      if (emulator) {
+        emulator.dispose();
+        terminalWriteEmulators.delete(terminal);
+      }
+    })
+  );
+}
+
+/**
+ * Capture terminal output using various methods
+ */
+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) {
+    // Call original method
+    originalSendText.call(terminal, text, addNewLine);
+    
+    // Process command
+    const processor = terminalOutputProcessors.get(terminalId);
+    if (processor && text) {
+      // Simulate command echo
+      processor(text + (addNewLine !== false ? '\n' : ''));
+    }
+  };
+
+  // Method 2: Use proposed API if available
+  if ('onDidWriteData' in terminal) {
+    const writeDataEvent = (terminal as any).onDidWriteData;
+    if (writeDataEvent) {
+      writeDataEvent((data: string) => {
+        const processor = terminalOutputProcessors.get(terminalId);
+        if (processor) {
+          processor(data);
+        }
+      });
+    }
+  }
+
+  // Method 3: Use terminal renderer if available
+  setupTerminalRenderer(terminal, terminalId);
+}
+
+/**
+ * Set up terminal renderer for output capture
+ */
+function setupTerminalRenderer(terminal: vscode.Terminal, terminalId: string): void {
+  // Check if terminal renderer API is available
+  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);
+      }
+    }, 100);
+  }
+}
+
+/**
+ * Create a terminal with output capture
+ */
+export async function createCapturedTerminal(
+  name: string,
+  shellPath?: string,
+  shellArgs?: string[]
+): Promise<{
+  terminal: vscode.Terminal;
+  onData: vscode.Event<string>;
+}> {
+  const writeEmulator = new vscode.EventEmitter<string>();
+  
+  const terminal = vscode.window.createTerminal({
+    name,
+    shellPath,
+    shellArgs,
+  });
+
+  terminalWriteEmulators.set(terminal, writeEmulator);
+
+  return {
+    terminal,
+    onData: writeEmulator.event,
+  };
+}
+
+/**
+ * Send command to terminal and capture output
+ */
+export async function executeTerminalCommand(
+  terminal: vscode.Terminal,
+  command: string,
+  timeout: number = 30000
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const writeEmulator = terminalWriteEmulators.get(terminal);
+    if (!writeEmulator) {
+      reject(new Error('No write emulator for terminal'));
+      return;
+    }
+
+    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();
+        const result = output.substring(0, output.indexOf(marker));
+        resolve(result);
+      }
+    });
+
+    // Set timeout
+    const timer = setTimeout(() => {
+      disposable.dispose();
+      reject(new Error('Command timeout'));
+    }, timeout);
+
+    // Execute command with marker
+    terminal.sendText(`${command} && echo "${marker}"`);
+    
+    // Clear timeout on success
+    writeEmulator.event(() => {
+      if (output.includes(marker)) {
+        clearTimeout(timer);
+      }
+    });
+  });
+}
+
+/**
+ * Get terminal by ID
+ */
+export function getTerminalById(terminalId: string): vscode.Terminal | undefined {
+  return activeTerminals.get(terminalId);
+}
+
+/**
+ * Dispose all terminal resources
+ */
+export function disposeTerminalBridge(): void {
+  // Clean up all terminals
+  for (const terminal of activeTerminals.values()) {
+    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/utils/errors.ts

@@ -0,0 +1,231 @@
+/**
+ * Custom error types for Claude-Flow
+ */
+
+/**
+ * Base error class for all Claude-Flow errors
+ */
+export class ClaudeFlowError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly details?: unknown,
+  ) {
+    super(message);
+    this.name = 'ClaudeFlowError';
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      stack: this.stack,
+    };
+  }
+}
+
+/**
+ * Terminal-related errors
+ */
+export class TerminalError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'TERMINAL_ERROR', details);
+    this.name = 'TerminalError';
+  }
+}
+
+export class TerminalSpawnError extends TerminalError {
+  override readonly code = 'TERMINAL_SPAWN_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+export class TerminalCommandError extends TerminalError {
+  override readonly code = 'TERMINAL_COMMAND_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+/**
+ * Memory-related errors
+ */
+export class MemoryError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'MEMORY_ERROR', details);
+    this.name = 'MemoryError';
+  }
+}
+
+export class MemoryBackendError extends MemoryError {
+  override readonly code = 'MEMORY_BACKEND_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+export class MemoryConflictError extends MemoryError {
+  override readonly code = 'MEMORY_CONFLICT_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+/**
+ * Coordination-related errors
+ */
+export class CoordinationError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'COORDINATION_ERROR', details);
+    this.name = 'CoordinationError';
+  }
+}
+
+export class DeadlockError extends CoordinationError {
+  override readonly code = 'DEADLOCK_ERROR';
+  
+  constructor(
+    message: string,
+    public readonly agents: string[],
+    public readonly resources: string[],
+  ) {
+    super(message, { agents, resources });
+  }
+}
+
+export class ResourceLockError extends CoordinationError {
+  override readonly code = 'RESOURCE_LOCK_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+/**
+ * MCP-related errors
+ */
+export class MCPError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'MCP_ERROR', details);
+    this.name = 'MCPError';
+  }
+}
+
+export class MCPTransportError extends MCPError {
+  override readonly code = 'MCP_TRANSPORT_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+export class MCPMethodNotFoundError extends MCPError {
+  override readonly code = 'MCP_METHOD_NOT_FOUND';
+  
+  constructor(method: string) {
+    super(`Method not found: ${method}`, { method });
+  }
+}
+
+/**
+ * Configuration errors
+ */
+export class ConfigError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'CONFIG_ERROR', details);
+    this.name = 'ConfigError';
+  }
+}
+
+export class ValidationError extends ConfigError {
+  override readonly code = 'VALIDATION_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+/**
+ * Task-related errors
+ */
+export class TaskError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'TASK_ERROR', details);
+    this.name = 'TaskError';
+  }
+}
+
+export class TaskTimeoutError extends TaskError {
+  override readonly code = 'TASK_TIMEOUT_ERROR';
+  
+  constructor(taskId: string, timeout: number) {
+    super(`Task ${taskId} timed out after ${timeout}ms`, { taskId, timeout });
+  }
+}
+
+export class TaskDependencyError extends TaskError {
+  override readonly code = 'TASK_DEPENDENCY_ERROR';
+  
+  constructor(taskId: string, dependencies: string[]) {
+    super(`Task ${taskId} has unmet dependencies`, { taskId, dependencies });
+  }
+}
+
+/**
+ * System errors
+ */
+export class SystemError extends ClaudeFlowError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'SYSTEM_ERROR', details);
+    this.name = 'SystemError';
+  }
+}
+
+export class InitializationError extends SystemError {
+  override readonly code = 'INITIALIZATION_ERROR';
+  
+  constructor(componentOrMessage: string, details?: unknown) {
+    // If the message already contains the word "initialize", use it as-is
+    const message = componentOrMessage.includes('initialize') 
+      ? componentOrMessage 
+      : `Failed to initialize ${componentOrMessage}`;
+    super(message, details ? { component: componentOrMessage, ...details } : { component: componentOrMessage });
+  }
+}
+
+export class ShutdownError extends SystemError {
+  override readonly code = 'SHUTDOWN_ERROR';
+  
+  constructor(message: string, details?: unknown) {
+    super(message, details);
+  }
+}
+
+/**
+ * Error utilities
+ */
+export function isClaudeFlowError(error: unknown): error is ClaudeFlowError {
+  return error instanceof ClaudeFlowError;
+}
+
+export function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+
+export function getErrorDetails(error: unknown): unknown {
+  if (isClaudeFlowError(error)) {
+    return error.details;
+  }
+  return undefined;
+}