0xray 2.0.0

package/src/mcps/orchestrator/handlers/status-handler.ts

@@ -0,0 +1,295 @@
+/**
+ * Status Handler
+ * 
+ * Handles orchestration status requests
+ */
+
+import { frameworkLogger } from '../../../core/framework-logger.js';
+import type { OrchestrationStatus, OrchestrationResult } from '../types.js';
+
+interface HistoryItem {
+  sessionId: string;
+  description: string;
+  tasks: number;
+  result: OrchestrationResult;
+  timestamp: string;
+}
+
+interface StatusHandlerDeps {
+  activeTasks: Map<string, unknown>;
+  taskHistory: HistoryItem[];
+}
+
+/**
+ * Status Handler
+ * Processes get-orchestration-status requests
+ */
+export class StatusHandler {
+  /**
+   * Handle get-orchestration-status request
+   */
+  async handleGetOrchestrationStatus(
+    args: { sessionId?: string; detailed?: boolean },
+    deps: StatusHandlerDeps
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
+    const { sessionId, detailed = false } = args;
+
+    await frameworkLogger.log(
+      'orchestrator.server',
+      'get-status-start',
+      'info',
+      { sessionId, detailed }
+    );
+
+    try {
+      let status: unknown;
+
+      if (sessionId) {
+        status = deps.activeTasks.get(sessionId);
+        
+        if (!status) {
+          // Check history
+          const historyItem = deps.taskHistory.find((h) => h.sessionId === sessionId);
+          if (historyItem) {
+            status = { completed: true, ...historyItem.result };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `❌ Session not found: ${sessionId}`,
+                },
+              ],
+            };
+          }
+        }
+      } else {
+        // Overall status
+        status = this.getOverallStatus(deps);
+      }
+
+      const response = this.formatStatusResponse(status, detailed);
+
+      return { content: [{ type: 'text', text: response }] };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `❌ Status check failed: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
+      };
+    }
+  }
+
+  /**
+   * Handle cancel-orchestration request
+   */
+  async handleCancelOrchestration(
+    args: { sessionId?: string; taskId?: string; force?: boolean },
+    deps: StatusHandlerDeps
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
+    const { sessionId, taskId, force = false } = args;
+
+    await frameworkLogger.log(
+      'orchestrator.server',
+      'cancel-orchestration-start',
+      'info',
+      { sessionId, taskId, force }
+    );
+
+    try {
+      if (!sessionId) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: '❌ sessionId is required for cancellation',
+            },
+          ],
+        };
+      }
+
+      // Check if session exists
+      const existingTask = deps.activeTasks.get(sessionId);
+      if (!existingTask) {
+        // Check history
+        const historyItem = deps.taskHistory.find((h) => h.sessionId === sessionId);
+        if (historyItem) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `❌ Session already completed: ${sessionId}`,
+              },
+            ],
+          };
+        }
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `❌ Session not found: ${sessionId}`,
+            },
+          ],
+        };
+      }
+
+      // Cancel the session
+      deps.activeTasks.delete(sessionId);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `✅ Orchestration cancelled: ${sessionId}${taskId ? ` (task: ${taskId})` : ''}`,
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `❌ Cancellation failed: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
+      };
+    }
+  }
+
+  /**
+   * Handle optimize-orchestration request
+   */
+  async handleOptimizeOrchestration(
+    args: { history?: boolean; recommendations?: boolean }
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
+    const { history = true, recommendations = true } = args;
+
+    await frameworkLogger.log(
+      'orchestrator.server',
+      'optimize-orchestration-start',
+      'info',
+      { history, recommendations }
+    );
+
+    try {
+      const optimizations: string[] = [];
+
+      if (recommendations) {
+        optimizations.push('Consider using "optimized" execution mode for most workflows');
+        optimizations.push('Batch similar tasks together for better agent utilization');
+        optimizations.push('Monitor agent utilization and adjust concurrent task limits');
+      }
+
+      if (history) {
+        optimizations.push('Review historical data to identify recurring patterns');
+        optimizations.push('Use complexity analysis to pre-plan task distribution');
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `🔧 Orchestration Optimization Results
+
+**Optimizations Available:**
+${optimizations.map((o) => `• ${o}`).join('\n')}
+
+**Current Best Practices:**
+• Use "optimized" mode for mixed task types
+• Set appropriate timeouts based on task complexity
+• Monitor bottleneck agents and redistribute load
+• Leverage task dependencies for correct execution order`,
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `❌ Optimization failed: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
+      };
+    }
+  }
+
+  /**
+   * Get overall orchestration status
+   */
+  private getOverallStatus(deps: StatusHandlerDeps): OrchestrationStatus {
+    const agentUtilization: Record<string, number> = {};
+    
+    // Aggregate from active tasks
+    for (const [, task] of deps.activeTasks) {
+      const taskAny = task as Record<string, unknown>;
+      if (taskAny.agentUtilization) {
+        const util = taskAny.agentUtilization as Record<string, number>;
+        for (const [agent, count] of Object.entries(util)) {
+          agentUtilization[agent] = (agentUtilization[agent] || 0) + count;
+        }
+      }
+    }
+
+    // Get recent sessions from history
+    const recentSessions = deps.taskHistory
+      .slice(-10)
+      .map((h) => ({
+        sessionId: h.sessionId,
+        status: 'completed',
+        tasks: h.tasks,
+        duration: h.result.duration,
+      }));
+
+    return {
+      activeSessions: deps.activeTasks.size,
+      totalTasks: deps.taskHistory.reduce((sum, h) => sum + h.tasks, 0),
+      agentUtilization,
+      recentSessions,
+    };
+  }
+
+  /**
+   * Format status response
+   */
+  private formatStatusResponse(status: unknown, detailed: boolean): string {
+    const statusAny = status as Record<string, unknown>;
+
+    // Check if it's a completed session
+    if (statusAny.completed) {
+      const result = statusAny as { success: boolean; duration: number; completedTasks: number; failedTasks: number };
+      return `📊 Session Status: COMPLETED
+
+**Success:** ${result.success ? '✅ Yes' : '❌ No'}
+**Duration:** ${result.duration}ms
+**Tasks:** ${result.completedTasks + result.failedTasks} (${result.completedTasks} ✅, ${result.failedTasks} ❌)`;
+    }
+
+    // Overall status
+    const orchStatus = status as OrchestrationStatus;
+    
+    let response = `📊 Orchestration Status
+
+**Active Sessions:** ${orchStatus.activeSessions}
+**Total Tasks Executed:** ${orchStatus.totalTasks}`;
+
+    if (Object.keys(orchStatus.agentUtilization).length > 0) {
+      response += `\n\n**Agent Utilization:**`;
+      for (const [agent, count] of Object.entries(orchStatus.agentUtilization)) {
+        response += `\n• ${agent}: ${count} tasks`;
+      }
+    }
+
+    if (detailed && orchStatus.recentSessions.length > 0) {
+      response += `\n\n**Recent Sessions:**`;
+      for (const session of orchStatus.recentSessions) {
+        response += `\n• ${session.sessionId}: ${session.tasks} tasks, ${session.duration}ms`;
+      }
+    }
+
+    return response;
+  }
+}

package/src/mcps/orchestrator/handlers/task-handler.ts

@@ -0,0 +1,268 @@
+/**
+ * Task Handler
+ * 
+ * Handles task orchestration requests
+ */
+
+import { frameworkLogger } from '../../../core/framework-logger.js';
+import { getExecutionPlanner } from '../execution/execution-planner.js';
+import { mcpClientManager } from '../../../mcps/mcp-client.js';
+import type { OrchestrationResult, OrchestrationTask, TaskExecutionResult } from '../types.js';
+
+export interface TaskHandlerDeps {
+  taskHistory: OrchestrationHistoryItem[];
+  activeTasks: Map<string, unknown>;
+}
+
+interface OrchestrationHistoryItem {
+  sessionId: string;
+  description: string;
+  tasks: number;
+  result: OrchestrationResult;
+  timestamp: string;
+}
+
+/**
+ * Task Handler
+ * Processes orchestrate-task requests
+ */
+export class TaskHandler {
+  private planner = getExecutionPlanner();
+
+  /**
+   * Handle orchestrate-task request
+   */
+  async handleOrchestrateTask(
+    args: {
+      description: string;
+      tasks?: OrchestrationTask[];
+      sessionId?: string;
+      executionMode?: string;
+      timeout?: number;
+    },
+    deps: TaskHandlerDeps
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
+    const { description, tasks = [], sessionId = `session_${Date.now()}`, executionMode = 'optimized', timeout = 300000 } = args;
+
+    await frameworkLogger.log(
+      'orchestrator.server',
+      'orchestrate-task-start',
+      'info',
+      { description, taskCount: tasks.length, sessionId, executionMode }
+    );
+
+    const orchestrationResult: OrchestrationResult = {
+      sessionId,
+      success: false,
+      completedTasks: 0,
+      failedTasks: 0,
+      duration: 0,
+      agentUtilization: {},
+      bottlenecks: [],
+      recommendations: [],
+    };
+
+    const startTime = Date.now();
+
+    try {
+      // Validate tasks
+      const validation = this.planner.validateTasks(tasks);
+      if (!validation.valid) {
+        throw new Error(`Task validation failed: ${validation.errors.join(', ')}`);
+      }
+
+      // Analyze complexity and create execution plan
+      const executionPlan = await this.planner.createExecutionPlan(tasks, executionMode);
+
+      // Execute orchestration (simulated for MCP server)
+      const results = await this.executePlan(executionPlan, sessionId, timeout);
+
+      // Update result
+      orchestrationResult.success = results.success;
+      orchestrationResult.completedTasks = results.completedTasks;
+      orchestrationResult.failedTasks = results.failedTasks;
+      orchestrationResult.agentUtilization = results.agentUtilization;
+      orchestrationResult.bottlenecks = results.bottlenecks;
+      orchestrationResult.recommendations = results.recommendations;
+      if (results.agentOutputs) {
+        orchestrationResult.agentOutputs = results.agentOutputs;
+      }
+
+      // Store in history
+      deps.taskHistory.push({
+        sessionId,
+        description,
+        tasks: tasks.length,
+        result: orchestrationResult,
+        timestamp: new Date().toISOString(),
+      });
+
+      // Store in active tasks
+      deps.activeTasks.set(sessionId, { status: 'completed', ...orchestrationResult });
+    } catch (error) {
+      orchestrationResult.recommendations.push(
+        `Orchestration error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+
+    orchestrationResult.duration = Date.now() - startTime;
+
+    const response = this.formatOrchestrationResponse(description, orchestrationResult, executionMode);
+
+    return { content: [{ type: 'text', text: response }] };
+  }
+
+  /**
+   * Execute the orchestration plan.
+   * For known MCP skill servers (code-review, security-audit, researcher, etc.),
+   * we actually call the target tool. For other agents we record the assignment.
+   */
+  private async executePlan(
+    plan: { agentAssignments: Map<string, OrchestrationTask[]> },
+    sessionId: string,
+    _timeout: number
+  ): Promise<{
+    success: boolean;
+    completedTasks: number;
+    failedTasks: number;
+    agentUtilization: Record<string, number>;
+    bottlenecks: string[];
+    recommendations: string[];
+    agentOutputs?: Record<string, string>;
+  }> {
+    const agentUtilization: Record<string, number> = {};
+    let completedTasks = 0;
+    let failedTasks = 0;
+    const agentOutputs: Record<string, string> = {};
+
+    const skillServers = new Set([
+      'code-review', 'code-reviewer',
+      'security-audit', 'security-auditor',
+      'researcher',
+      'performance-optimization',
+      'testing-strategy', 'testing-lead',
+      'bug-triage-specialist',
+      'refactorer', 'refactoring-strategies',
+      'architect', 'architecture-patterns'
+    ]);
+
+    for (const [agent, tasks] of plan.agentAssignments) {
+      agentUtilization[agent] = tasks.length;
+
+      if (skillServers.has(agent)) {
+        for (const task of tasks) {
+          try {
+            const toolName = this.mapAgentToTool(agent);
+            const result = await mcpClientManager.callServerTool(agent, toolName, {
+              description: task.description,
+              type: task.type,
+              priority: task.priority,
+            });
+
+            const outputText = this.extractTextFromMcpResult(result);
+            agentOutputs[`${agent}:${task.id}`] = outputText;
+            completedTasks++;
+          } catch (err) {
+            failedTasks++;
+            agentOutputs[`${agent}:${task.id}`] = `Error: ${err instanceof Error ? err.message : String(err)}`;
+            frameworkLogger.log('orchestrator.task-handler', 'task-execution-failed', 'warning', {
+              agent,
+              taskId: task.id,
+              error: String(err),
+            });
+          }
+        }
+      } else {
+        // For non-MCP agents we still count them as "assigned" (they will be handled by the caller or legacy path)
+        completedTasks += tasks.length;
+      }
+    }
+
+    const recommendations: string[] = [];
+    const bottlenecks: string[] = [];
+
+    if (plan.agentAssignments.size > 5) {
+      recommendations.push('Consider reducing the number of agents for better coordination');
+    }
+    for (const [agent, tasks] of plan.agentAssignments) {
+      if (tasks.length > 3) {
+        bottlenecks.push(`${agent} is handling ${tasks.length} tasks - may be overloaded`);
+      }
+    }
+
+    return {
+      success: failedTasks === 0,
+      completedTasks,
+      failedTasks,
+      agentUtilization,
+      bottlenecks,
+      recommendations,
+      agentOutputs,
+    };
+  }
+
+  private mapAgentToTool(agent: string): string {
+    const map: Record<string, string> = {
+      // Servers that have analyze_proposal
+      'code-review': 'analyze_proposal',
+      'security-audit': 'analyze_proposal',
+      'researcher': 'analyze_proposal',
+      'bug-triage-specialist': 'analyze_proposal',
+
+      // Legacy aliases that should resolve to the above
+      'code-reviewer': 'analyze_proposal',
+      'security-auditor': 'analyze_proposal',
+      'refactorer': 'analyze_proposal',
+      'architect': 'analyze_proposal',
+      'architecture-patterns': 'analyze_proposal',
+
+      // Implementation / apply focused tools
+      'refactoring-strategies': 'suggest_refactor',
+      'testing-strategy': 'analyze_test_coverage',
+      'testing-lead': 'analyze_test_coverage',
+    };
+    return map[agent] || 'analyze_proposal';
+  }
+
+  private extractTextFromMcpResult(result: unknown): string {
+    const content = (result as any)?.content;
+    if (Array.isArray(content)) {
+      return content.map((c: any) => c.text ?? '').join('\n');
+    }
+    return JSON.stringify(result);
+  }
+
+  /**
+   * Format orchestration response
+   */
+  private formatOrchestrationResponse(
+    description: string,
+    result: OrchestrationResult,
+    executionMode: string
+  ): string {
+    return `🎯 Orchestration Complete: "${description}"
+
+**Session ID:** ${result.sessionId}
+**Success:** ${result.success ? '✅ COMPLETED' : '❌ FAILED'}
+**Duration:** ${result.duration}ms
+**Tasks:** ${result.completedTasks + result.failedTasks} total
+  - ✅ Completed: ${result.completedTasks}
+  - ❌ Failed: ${result.failedTasks}
+
+**Agent Utilization:**
+${Object.entries(result.agentUtilization)
+  .map(([agent, count]) => `• ${agent}: ${count} tasks`)
+  .join('\n')}
+
+${result.bottlenecks.length > 0 ? `**Bottlenecks Detected:**\n${result.bottlenecks.map((b) => `• 🚧 ${b}`).join('\n')}\n` : ''}
+**Recommendations:**
+${result.recommendations.length > 0 ? result.recommendations.map((r) => `• 💡 ${r}`).join('\n') : 'No recommendations'}
+
+**Execution Mode:** ${executionMode}
+**Status:** ${result.success ? '🟢 SUCCESS' : '🔴 ISSUES DETECTED'}
+
+${result.agentOutputs && Object.keys(result.agentOutputs).length > 0 
+  ? `**Agent Outputs (real MCP responses):**\n${Object.entries(result.agentOutputs).map(([k, v]) => `• ${k}: ${v.substring(0, 200)}${v.length > 200 ? '...' : ''}`).join('\n')}\n`
+  : ''}`;
+  }
+}