0xray 4.0.12 → 4.0.13

package/dist/mcps/orchestrator/handlers/task-handler.js

@@ -1,354 +0,0 @@
-/**
- * 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 { addObservations, extractOrchestrationObservations, spawnAside } from '../aside-context.js';
-import { getProvider } from '../config/memory-routing-bridge.js';
-import { delegationSummaryForResponse, recordDeferredDelegations, } from '../../../nucleus/pending-delegations.js';
-/**
- * Task Handler
- * Processes orchestrate-task requests
- */
-export class TaskHandler {
-    planner = getExecutionPlanner();
-    /**
-     * Handle orchestrate-task request
-     */
-    async handleOrchestrateTask(args, deps) {
-        if (args.clearActiveAside === true) {
-            const projectRoot = process.cwd();
-            const { clearActiveAside, getActiveAsideId } = await import('../../../nucleus/user-aside.js');
-            const prior = getActiveAsideId(projectRoot, args.sessionId ?? null);
-            clearActiveAside(projectRoot);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: prior
-                            ? `✅ Cleared active aside \`${prior}\` — spawns resume main lead-dev plan.`
-                            : 'ℹ️ No active aside was set.',
-                    },
-                ],
-            };
-        }
-        if (args.userAsideId?.trim()) {
-            const projectRoot = process.cwd();
-            const { setActiveAsideId, loadUserAside, formatUserAsideSummary, isUserAsidesEnabled, UserAsideValidationError, } = await import('../../../nucleus/user-aside.js');
-            const { clearPendingDelegations } = await import('../../../nucleus/pending-delegations.js');
-            if (!isUserAsidesEnabled(projectRoot)) {
-                return {
-                    content: [{ type: 'text', text: '❌ User asides disabled in features.json' }],
-                };
-            }
-            const asideId = args.userAsideId.trim();
-            const aside = loadUserAside(asideId, projectRoot);
-            if (!aside) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ User aside \`${asideId}\` not found — run analyze-complexity with userAsideId first.`,
-                        },
-                    ],
-                };
-            }
-            if (args.setActiveAside !== false) {
-                try {
-                    clearPendingDelegations(projectRoot);
-                    setActiveAsideId(asideId, projectRoot, args.sessionId ?? null);
-                }
-                catch (err) {
-                    const message = err instanceof UserAsideValidationError ? err.message : String(err);
-                    return { content: [{ type: 'text', text: `❌ ${message}` }] };
-                }
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ Active aside: \`${asideId}\`\n\n${formatUserAsideSummary(aside)}`,
-                    },
-                ],
-            };
-        }
-        if (args.confer === true) {
-            const { runConferQuorum, formatConferQuorumReport, isConferEnabled } = await import('../../../nucleus/confer.js');
-            const sid = args.sessionId ?? `confer_${Date.now()}`;
-            if (!isConferEnabled()) {
-                return {
-                    content: [{ type: 'text', text: '❌ Confer disabled in features.json' }],
-                };
-            }
-            const conferOpts = {
-                dueReason: args.description,
-                fixture: args.conferFixture === true,
-            };
-            if (args.collocatedText)
-                conferOpts.collocatedText = args.collocatedText;
-            const result = await runConferQuorum(process.cwd(), sid, conferOpts);
-            return {
-                content: [{ type: 'text', text: formatConferQuorumReport(result) }],
-            };
-        }
-        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 = {
-            sessionId,
-            success: false,
-            completedTasks: 0,
-            failedTasks: 0,
-            duration: 0,
-            agentUtilization: {},
-            bottlenecks: [],
-            recommendations: [],
-        };
-        const startTime = Date.now();
-        let pendingDelegations = [];
-        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);
-            const memoryProvider = getProvider();
-            if (memoryProvider.id !== 'null' && executionPlan.memoryContext) {
-                await spawnAside({
-                    description: `Orchestrate: ${description}`,
-                    sessionId,
-                    inheritedContext: {
-                        memoryRouting: executionPlan.memoryContext,
-                    },
-                });
-            }
-            const results = await this.executePlan(executionPlan, sessionId, timeout);
-            if (results.deferredRecords.length > 0) {
-                pendingDelegations = recordDeferredDelegations(sessionId, results.deferredRecords);
-                await frameworkLogger.log('orchestrator.task-handler', 'pending-delegations-recorded', 'info', { count: pendingDelegations.length, sessionId });
-            }
-            // Feed per-task outcomes back to memory provider (not aggregate session stats)
-            if (memoryProvider.ingestFeedback) {
-                const outcomeByKey = new Map(results.taskOutcomes.map((o) => [`${o.agent}:${o.taskId}`, o]));
-                for (const [agent, assignedTasks] of executionPlan.agentAssignments) {
-                    for (const task of assignedTasks) {
-                        const outcome = outcomeByKey.get(`${agent}:${task.id}`);
-                        memoryProvider.ingestFeedback({
-                            timestamp: new Date().toISOString(),
-                            sessionId,
-                            taskId: task.id,
-                            assignedAgent: agent,
-                            memorySignals: task.metadata?.memorySignals ?? [],
-                            complexity: task.estimatedComplexity ?? 30,
-                            success: outcome?.success ?? false,
-                            durationMs: outcome?.durationMs ?? 0,
-                        });
-                    }
-                }
-            }
-            // Update result
-            orchestrationResult.success = results.success;
-            orchestrationResult.completedTasks = results.completedTasks;
-            orchestrationResult.failedTasks = results.failedTasks;
-            orchestrationResult.deferredTasks = results.deferredTasks;
-            orchestrationResult.recommendations.push(...results.recommendations);
-            orchestrationResult.agentUtilization = results.agentUtilization;
-            orchestrationResult.bottlenecks = results.bottlenecks;
-            orchestrationResult.recommendations = results.recommendations;
-            if (results.agentOutputs) {
-                orchestrationResult.agentOutputs = results.agentOutputs;
-            }
-            // Push observations into aside context if active
-            if (deps.asideId) {
-                addObservations(deps.asideId, extractOrchestrationObservations(orchestrationResult));
-            }
-            // 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, pendingDelegations);
-        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.
-     */
-    async executePlan(plan, sessionId, _timeout) {
-        const agentUtilization = {};
-        let completedTasks = 0;
-        let failedTasks = 0;
-        let deferredTasks = 0;
-        const agentOutputs = {};
-        const deferredRecords = [];
-        const taskOutcomes = [];
-        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) {
-                    const taskStart = Date.now();
-                    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++;
-                        taskOutcomes.push({
-                            taskId: task.id,
-                            agent,
-                            success: true,
-                            durationMs: Date.now() - taskStart,
-                        });
-                    }
-                    catch (err) {
-                        failedTasks++;
-                        agentOutputs[`${agent}:${task.id}`] = `Error: ${err instanceof Error ? err.message : String(err)}`;
-                        taskOutcomes.push({
-                            taskId: task.id,
-                            agent,
-                            success: false,
-                            durationMs: Date.now() - taskStart,
-                        });
-                        frameworkLogger.log('orchestrator.task-handler', 'task-execution-failed', 'warning', {
-                            agent,
-                            taskId: task.id,
-                            error: String(err),
-                        });
-                    }
-                }
-            }
-            else {
-                for (const task of tasks) {
-                    deferredTasks++;
-                    deferredRecords.push({
-                        taskId: task.id,
-                        agent,
-                        description: task.description,
-                        type: task.type,
-                    });
-                    taskOutcomes.push({
-                        taskId: task.id,
-                        agent,
-                        success: false,
-                        durationMs: 0,
-                    });
-                    await frameworkLogger.log('orchestrator.task-handler', 'delegate-deferred', 'info', { agent, taskId: task.id, sessionId });
-                }
-            }
-        }
-        const recommendations = [];
-        const bottlenecks = [];
-        if (deferredTasks > 0) {
-            recommendations.push(`${deferredTasks} task(s) require host delegation (Task/spawn_subagent per lead-dev-plan) — orchestrate-task only invokes MCP consult skills directly`);
-        }
-        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 && deferredTasks === 0,
-            completedTasks,
-            failedTasks,
-            deferredTasks,
-            agentUtilization,
-            bottlenecks,
-            recommendations,
-            agentOutputs,
-            deferredRecords,
-            taskOutcomes,
-        };
-    }
-    mapAgentToTool(agent) {
-        const map = {
-            // 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';
-    }
-    extractTextFromMcpResult(result) {
-        const content = result?.content;
-        if (Array.isArray(content)) {
-            return content.map((c) => c.text ?? '').join('\n');
-        }
-        return JSON.stringify(result);
-    }
-    /**
-     * Format orchestration response
-     */
-    formatOrchestrationResponse(description, result, executionMode, pendingDelegations = []) {
-        const delegationsBlock = pendingDelegations.length > 0
-            ? `\n**Delegations (host Task required):**\n\`\`\`json\n${JSON.stringify({ delegations: delegationSummaryForResponse(pendingDelegations) }, null, 2)}\n\`\`\`\n`
-            : '';
-        return `🎯 Orchestration Complete: "${description}"
-
-**Session ID:** ${result.sessionId}
-**Success:** ${result.success ? '✅ COMPLETED' : '❌ FAILED'}
-**Duration:** ${result.duration}ms
-**Tasks:** ${result.completedTasks + result.failedTasks + (result.deferredTasks ?? 0)} total
-  - ✅ Completed: ${result.completedTasks}
-  - ❌ Failed: ${result.failedTasks}
-  - ⏸ Deferred (host delegation required): ${result.deferredTasks ?? 0}
-
-**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`
-            : ''}${delegationsBlock}`;
-    }
-}

package/dist/mcps/orchestrator/index.d.ts

@@ -1,6 +0,0 @@
-export { OrchestratorServer, createOrchestratorServer } from './server.js';
-export { TaskHandler } from './handlers/task-handler.js';
-export { ComplexityHandler } from './handlers/complexity-handler.js';
-export { StatusHandler } from './handlers/status-handler.js';
-export { spawnAside, closeAside, closeAllAsides, addObservations, getActiveAsideCount, getActiveAsideIds, getAsideState, resetAsideContext, extractGovernanceObservations, extractOrchestrationObservations, extractComplexityObservations, } from './aside-context.js';
-export type { AsideContextOptions, AsideObservation, AsideResult, ActiveAside, OrchestrationTask, OrchestrationResult, OrchestrationStatus, ComplexityAnalysis, TaskExecutionResult, ExecutionPlan, } from './types.js';

package/dist/mcps/orchestrator/index.js

@@ -1,5 +0,0 @@
-export { OrchestratorServer, createOrchestratorServer } from './server.js';
-export { TaskHandler } from './handlers/task-handler.js';
-export { ComplexityHandler } from './handlers/complexity-handler.js';
-export { StatusHandler } from './handlers/status-handler.js';
-export { spawnAside, closeAside, closeAllAsides, addObservations, getActiveAsideCount, getActiveAsideIds, getAsideState, resetAsideContext, extractGovernanceObservations, extractOrchestrationObservations, extractComplexityObservations, } from './aside-context.js';

package/dist/mcps/orchestrator/server.d.ts

@@ -1,38 +0,0 @@
-/**
- * Orchestrator MCP Server - Facade
- *
- * Main entry point for the orchestrator MCP server
- * Provides a clean API while hiding internal complexity
- */
-/**
- * Orchestrator MCP Server
- * Enterprise-grade orchestration with advanced task management and agent coordination
- */
-export declare class OrchestratorServer {
-    private server;
-    private activeTasks;
-    private taskHistory;
-    private taskHandler;
-    private complexityHandler;
-    private statusHandler;
-    private coordinator;
-    constructor();
-    /**
-     * Initialize tool definitions
-     */
-    private initializeTools;
-    /**
-     * Set up tool request handlers
-     */
-    private setupToolHandlers;
-    private handleGovernAndApply;
-    /**
-     * Start the server
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the server
-     */
-    stop(): Promise<void>;
-}
-export declare function createOrchestratorServer(): OrchestratorServer;