0xray 4.0.13 → 4.0.14

package/dist/mcps/orchestrator/execution/execution-planner.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Execution Planner
+ *
+ * Creates optimized execution plans for orchestration tasks
+ */
+import type { OrchestrationTask, ExecutionPlan, ComplexityAnalysis, TaskValidation } from '../types.js';
+/** Dependency count from task-ID list or numeric hint from analyze-complexity */
+export declare function dependencyCount(deps: OrchestrationTask['dependencies'] | undefined): number;
+/**
+ * Execution Planner
+ * Plans and optimizes task execution strategies
+ */
+export declare class ExecutionPlanner {
+    private capabilitiesManager;
+    /**
+     * Validate a list of tasks
+     */
+    validateTasks(tasks: OrchestrationTask[]): TaskValidation;
+    /**
+     * Create an execution plan based on tasks and mode
+     */
+    createExecutionPlan(tasks: OrchestrationTask[], executionMode: string): Promise<ExecutionPlan>;
+    /**
+     * Create a parallel execution plan
+     */
+    private createParallelPlan;
+    /**
+     * Create a sequential execution plan
+     */
+    private createSequentialPlan;
+    /**
+     * Create an optimized execution plan considering dependencies and complexity
+     */
+    private createOptimizedPlan;
+    /**
+     * Sort tasks by their dependencies
+     */
+    private sortByDependencies;
+    /**
+     * Assign tasks to agents based on capability
+     */
+    private assignTasksToAgents;
+    /**
+     * Estimate execution duration based on agent assignments
+     */
+    estimateExecutionDuration(agentAssignments: Map<string, OrchestrationTask[]>): number;
+    /**
+     * Analyze task complexity
+     */
+    analyzeTaskComplexity(tasks: OrchestrationTask[]): Promise<ComplexityAnalysis>;
+    /**
+     * Calculate complexity for a single task
+     */
+    calculateTaskComplexity(task: OrchestrationTask): number;
+    /**
+     * Recommend execution strategy based on complexity and task count
+     */
+    private recommendStrategy;
+    /**
+     * Calculate parallel execution potential
+     */
+    private calculateParallelPotential;
+}
+export declare function getExecutionPlanner(): ExecutionPlanner;

package/dist/mcps/orchestrator/execution/execution-planner.js

@@ -0,0 +1,320 @@
+/**
+ * Execution Planner
+ *
+ * Creates optimized execution plans for orchestration tasks
+ */
+import { getAgentCapabilitiesManager } from '../config/agent-capabilities.js';
+import { getProvider, toMemoryTask, fromMemoryTask, } from '../config/memory-routing-bridge.js';
+/** Dependency count from task-ID list or numeric hint from analyze-complexity */
+export function dependencyCount(deps) {
+    if (deps == null)
+        return 0;
+    if (typeof deps === 'number' && Number.isFinite(deps)) {
+        return Math.max(0, Math.round(deps));
+    }
+    if (Array.isArray(deps))
+        return deps.length;
+    return 0;
+}
+function isDependencyIdList(deps) {
+    return Array.isArray(deps) && deps.length > 0;
+}
+/**
+ * Execution Planner
+ * Plans and optimizes task execution strategies
+ */
+export class ExecutionPlanner {
+    capabilitiesManager = getAgentCapabilitiesManager();
+    /**
+     * Validate a list of tasks
+     */
+    validateTasks(tasks) {
+        const errors = [];
+        if (!tasks || tasks.length === 0) {
+            errors.push('No tasks provided');
+            return { valid: false, errors };
+        }
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            if (!task)
+                continue;
+            if (!task.id) {
+                errors.push(`Task ${i}: Missing required field 'id'`);
+            }
+            if (!task.description) {
+                errors.push(`Task ${i}: Missing required field 'description'`);
+            }
+            if (!task.type) {
+                errors.push(`Task ${i}: Missing required field 'type'`);
+            }
+            // Check task-ID dependencies exist (numeric hints skip graph validation)
+            if (isDependencyIdList(task.dependencies) && task.id) {
+                const taskIds = new Set(tasks.map(t => t.id).filter((id) => !!id));
+                for (const depId of task.dependencies) {
+                    if (!taskIds.has(depId)) {
+                        errors.push(`Task ${i}: Dependency '${depId}' does not exist`);
+                    }
+                }
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Create an execution plan based on tasks and mode
+     */
+    async createExecutionPlan(tasks, executionMode) {
+        const provider = getProvider();
+        const memoryTasks = provider.enrichTasks(tasks.map(toMemoryTask));
+        const enrichedTasks = memoryTasks.map(fromMemoryTask);
+        const agentAssignments = new Map();
+        switch (executionMode) {
+            case 'parallel':
+                this.createParallelPlan(enrichedTasks, agentAssignments);
+                break;
+            case 'sequential':
+                this.createSequentialPlan(enrichedTasks, agentAssignments);
+                break;
+            case 'optimized':
+            default:
+                await this.createOptimizedPlan(enrichedTasks, agentAssignments);
+                break;
+        }
+        const estimatedDuration = this.estimateExecutionDuration(agentAssignments);
+        const plan = {
+            tasks: enrichedTasks,
+            strategy: executionMode,
+            agentAssignments,
+            estimatedDuration,
+        };
+        if (provider.id !== 'null') {
+            plan.memoryContext = {
+                ...provider.buildInheritedContext(memoryTasks),
+            };
+        }
+        return plan;
+    }
+    /**
+     * Create a parallel execution plan
+     */
+    createParallelPlan(tasks, agentAssignments) {
+        // Assign each task to an available agent
+        const agents = this.capabilitiesManager.getAllCapabilities();
+        let agentIndex = 0;
+        const agentList = Array.from(agents.keys()).filter((a) => !!a);
+        if (agentList.length === 0)
+            return;
+        for (const task of tasks) {
+            const agent = agentList[agentIndex % agentList.length];
+            if (!agent)
+                continue;
+            if (!agentAssignments.has(agent)) {
+                agentAssignments.set(agent, []);
+            }
+            agentAssignments.get(agent).push(task);
+            agentIndex++;
+        }
+    }
+    /**
+     * Create a sequential execution plan
+     */
+    createSequentialPlan(tasks, agentAssignments) {
+        // Use orchestrator agent for sequential execution
+        agentAssignments.set('orchestrator', [...tasks]);
+    }
+    /**
+     * Create an optimized execution plan considering dependencies and complexity
+     */
+    async createOptimizedPlan(tasks, agentAssignments) {
+        // Sort tasks by dependencies first
+        const sortedTasks = this.sortByDependencies(tasks);
+        // Group independent tasks for parallel execution
+        const independentTasks = [];
+        const dependentTasks = [];
+        for (const task of sortedTasks) {
+            if (isDependencyIdList(task.dependencies)) {
+                dependentTasks.push(task);
+            }
+            else {
+                independentTasks.push(task);
+            }
+        }
+        // Assign independent tasks in parallel
+        this.assignTasksToAgents(independentTasks, agentAssignments);
+        // Assign dependent tasks (these will run after dependencies complete)
+        this.assignTasksToAgents(dependentTasks, agentAssignments);
+    }
+    /**
+     * Sort tasks by their dependencies
+     */
+    sortByDependencies(tasks) {
+        const taskMap = new Map(tasks.map(t => [t.id, t]));
+        const sorted = [];
+        const visited = new Set();
+        const visit = (task) => {
+            if (visited.has(task.id))
+                return;
+            visited.add(task.id);
+            if (isDependencyIdList(task.dependencies)) {
+                for (const depId of task.dependencies) {
+                    const depTask = taskMap.get(depId);
+                    if (depTask)
+                        visit(depTask);
+                }
+            }
+            sorted.push(task);
+        };
+        for (const task of tasks) {
+            visit(task);
+        }
+        return sorted;
+    }
+    /**
+     * Assign tasks to agents based on capability
+     */
+    assignTasksToAgents(tasks, agentAssignments) {
+        for (const task of tasks) {
+            const complexity = this.calculateTaskComplexity(task);
+            const requiredCaps = [
+                task.type,
+                ...(task.metadata?.memorySignals ?? []),
+            ];
+            const operationDescription = task.metadata?.memoryHighConfidenceTrap
+                ? `${task.description} TYPE: ontological-trap`
+                : task.description;
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, operationDescription, task.type) || 'orchestrator';
+            if (!agentAssignments.has(agent)) {
+                agentAssignments.set(agent, []);
+            }
+            agentAssignments.get(agent).push(task);
+        }
+    }
+    /**
+     * Estimate execution duration based on agent assignments
+     */
+    estimateExecutionDuration(agentAssignments) {
+        let maxDuration = 0;
+        for (const [agent, tasks] of agentAssignments) {
+            const caps = this.capabilitiesManager.getCapabilities(agent);
+            if (!caps)
+                continue;
+            // Estimate time based on concurrent capacity
+            const batches = Math.ceil(tasks.length / caps.concurrentTasks);
+            const taskDuration = tasks.reduce((sum, t) => sum + (t.estimatedComplexity || 30) * 10, 0);
+            const agentDuration = batches * (taskDuration / tasks.length);
+            maxDuration = Math.max(maxDuration, agentDuration);
+        }
+        return Math.round(maxDuration);
+    }
+    /**
+     * Analyze task complexity
+     */
+    async analyzeTaskComplexity(tasks) {
+        const taskComplexity = [];
+        const agentAssignments = [];
+        const assignments = new Map();
+        for (const task of tasks) {
+            const complexity = this.calculateTaskComplexity(task);
+            taskComplexity.push({
+                complexity,
+                category: task.type,
+            });
+            // Assign to agent
+            const requiredCaps = [
+                task.type,
+                ...(task.metadata?.memorySignals ?? []),
+            ];
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, task.description, task.type) || 'orchestrator';
+            if (!assignments.has(agent)) {
+                assignments.set(agent, []);
+            }
+            assignments.get(agent).push(task);
+        }
+        // Calculate agent utilization
+        for (const [agent, assignedTasks] of assignments) {
+            const caps = this.capabilitiesManager.getCapabilities(agent);
+            const utilization = caps
+                ? Math.round((assignedTasks.length / caps.concurrentTasks) * 100)
+                : 100;
+            agentAssignments.push({
+                agent,
+                taskCount: assignedTasks.length,
+                utilization: Math.min(utilization, 100),
+            });
+        }
+        const overallComplexity = taskComplexity.length > 0
+            ? Math.round(taskComplexity.reduce((sum, t) => sum + t.complexity, 0) / taskComplexity.length)
+            : 0;
+        const recommendedStrategy = this.recommendStrategy(overallComplexity, tasks.length);
+        const estimatedDuration = this.estimateExecutionDuration(assignments);
+        const parallelPotential = this.calculateParallelPotential(tasks);
+        return {
+            overallComplexity,
+            recommendedStrategy,
+            taskComplexity,
+            agentAssignments,
+            estimatedDuration,
+            parallelPotential,
+        };
+    }
+    /**
+     * Calculate complexity for a single task
+     */
+    calculateTaskComplexity(task) {
+        let complexity = 30; // Base complexity
+        // Adjust based on priority
+        switch (task.priority) {
+            case 'critical':
+                complexity += 20;
+                break;
+            case 'high':
+                complexity += 10;
+                break;
+            case 'low':
+                complexity -= 5;
+                break;
+        }
+        // Adjust based on estimated complexity
+        if (task.estimatedComplexity) {
+            complexity = (complexity + task.estimatedComplexity) / 2;
+        }
+        complexity += dependencyCount(task.dependencies) * 5;
+        if (task.metadata?.memoryComplexityBoost !== undefined) {
+            complexity += task.metadata.memoryComplexityBoost;
+        }
+        else {
+            const provider = getProvider();
+            if (provider.id !== 'null' && provider.getTaskConfidence) {
+                complexity += provider.getTaskConfidence(toMemoryTask(task)).complexityBoost;
+            }
+        }
+        return Math.min(Math.max(Math.round(complexity), 1), 100);
+    }
+    /**
+     * Recommend execution strategy based on complexity and task count
+     */
+    recommendStrategy(overallComplexity, taskCount) {
+        if (taskCount <= 1)
+            return 'sequential';
+        if (overallComplexity > 70)
+            return 'sequential';
+        if (overallComplexity < 30 && taskCount > 3)
+            return 'parallel';
+        return 'optimized';
+    }
+    /**
+     * Calculate parallel execution potential
+     */
+    calculateParallelPotential(tasks) {
+        // Tasks without dependencies can run in parallel
+        const independent = tasks.filter((t) => !isDependencyIdList(t.dependencies));
+        return independent.length / tasks.length;
+    }
+}
+// Singleton
+let executionPlannerInstance = null;
+export function getExecutionPlanner() {
+    if (!executionPlannerInstance) {
+        executionPlannerInstance = new ExecutionPlanner();
+    }
+    return executionPlannerInstance;
+}

package/dist/mcps/orchestrator/handlers/complexity-handler.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Complexity Handler
+ *
+ * Handles complexity analysis requests
+ */
+import type { OrchestrationTask } from '../types.js';
+type AnalyzeComplexityInput = {
+    id?: string;
+    description?: string;
+    type?: string;
+    files?: string[];
+    dependencyCount?: number;
+    dependencies?: string[] | number;
+    riskLevel?: string;
+    estimatedComplexity?: number;
+    priority?: OrchestrationTask['priority'];
+};
+/**
+ * Complexity Handler
+ * Processes analyze-complexity requests
+ */
+export declare class ComplexityHandler {
+    private planner;
+    /**
+     * Handle analyze-complexity request
+     */
+    handleAnalyzeComplexity(args: {
+        tasks: AnalyzeComplexityInput[];
+        sessionId?: string;
+        synthesisCheckpoint?: boolean;
+        synthesisDueReason?: string | null;
+        collocatedText?: string | null;
+        conferFixture?: boolean;
+        userAsideId?: string;
+        userAsideTitle?: string;
+        worktree?: string;
+        branch?: string;
+        setActiveAside?: boolean;
+    }, asideId?: string): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+        ok: boolean;
+    }>;
+    /**
+     * Generate recommendations based on complexity analysis
+     */
+    private generateRecommendations;
+    /**
+     * Format complexity response
+     */
+    private formatComplexityResponse;
+}
+export {};