0xray 4.0.11 → 4.0.13

package/dist/orchestrator/enhanced-multi-agent-orchestrator.d.ts

@@ -1,156 +0,0 @@
-/**
- * Enhanced Multi-Agent Orchestration with Clickable Monitoring
- * Integrates subagent spawning visibility and lifecycle management
- */
-import { XrayStateManager } from "../state/state-manager.js";
-export interface AgentSpawnRequest {
-    agentType: string;
-    task: string;
-    context?: Record<string, unknown>;
-    priority?: "low" | "medium" | "high" | "critical";
-    timeout?: number;
-    dependencies?: string[];
-}
-export interface AgentExecutionResult {
-    success: boolean;
-    agentType: string;
-    task: string;
-    executionTime?: number;
-    complexity?: number;
-    result?: unknown;
-    delegationResult?: unknown;
-}
-export interface SpawnedAgent {
-    id: string;
-    agentType: string;
-    task: string;
-    status: "spawning" | "active" | "completed" | "failed" | "cancelled";
-    startTime: number;
-    endTime?: number;
-    result?: AgentExecutionResult;
-    error?: string;
-    progress: number;
-    clickable: boolean;
-    monitorable: boolean;
-    cleanupRequired: boolean;
-    spawnTrackingId: string | undefined;
-}
-export interface AgentOrchestrationState {
-    activeAgents: Map<string, SpawnedAgent>;
-    pendingSpawns: AgentSpawnRequest[];
-    completedAgents: Map<string, SpawnedAgent>;
-    failedAgents: Map<string, SpawnedAgent>;
-    agentDependencies: Map<string, string[]>;
-    monitoringEnabled: boolean;
-    cleanupInterval: number;
-    isMainOrchestrator: boolean;
-}
-export interface ExecutionContext {
-    isExecutingAsSubagent: boolean;
-    currentAgentId: string | null;
-    spawnStack: string[];
-}
-export interface OrchestrationDelegationRequest {
-    operation: string;
-    description: string;
-    context?: Record<string, unknown>;
-}
-export interface OrchestrationDelegationResult {
-    success: boolean;
-    results?: Array<{
-        agent: string;
-        output: unknown;
-        executionTime: number;
-    }>;
-    totalTime: number;
-    errors?: string[];
-    agents?: string[];
-}
-export declare class EnhancedMultiAgentOrchestrator {
-    private state;
-    private stateManager;
-    private complexityAnalyzer;
-    private agentDelegator;
-    private executionContext;
-    private cleanupTimer;
-    constructor(stateManager?: XrayStateManager, isMainOrchestrator?: boolean);
-    /**
-     * 🚨 SECURITY: Check if currently executing as a subagent
-     * Prevents subagents from spawning other subagents (infinite loops, resource exhaustion)
-     */
-    private isCurrentlyExecutingAsSubagent;
-    /**
-     * Enhanced agent spawning with clickable monitoring integration
-     */
-    spawnAgent(request: AgentSpawnRequest): Promise<SpawnedAgent>;
-    /**
-     * Execute agent with monitoring and cleanup
-     */
-    private executeAgent;
-    /**
-     * Execute agent using the agent delegator system
-     */
-    private executeAgentWithDelegator;
-    /**
-     * Simulate agent execution (FALLBACK - used when plugin not loaded)
-     *
-     * NOTE: The primary execution path is through the OpenCode plugin:
-     * - .opencode/plugin/xray-codex-injection.js intercepts prompts
-     * - Routes to agents via .opencode/agents/*.yml configs
-     * - OpenCode spawns actual agent processes
-     * - Hermes Agent handles MCP server execution
-     *
-     * This simulation is a fallback for:
-     * - Testing without real agent execution
-     * - When plugin fails to load
-     * - Documentation of what the framework orchestrates
-     *
-     * For production use, ensure the plugin is loaded in OpenCode.
-     */
-    private simulateAgentExecution;
-    /**
-     * Get estimated execution time for agent type
-     */
-    private getAgentExecutionTime;
-    /**
-     * Update agent monitoring (integrates with clickable interface)
-     */
-    private updateAgentMonitoring;
-    /**
-     * Check for pending spawns that can now execute
-     */
-    private checkPendingSpawns;
-    /**
-     * Get clickable agent monitoring interface
-     */
-    getMonitoringInterface(): Record<string, SpawnedAgent>;
-    /**
-     * Cancel agent execution
-     */
-    cancelAgent(agentId: string): Promise<boolean>;
-    /**
-     * Initialize cleanup system for completed agents
-     */
-    private initializeCleanupSystem;
-    /**
-     * Perform cleanup of completed/failed agents
-     */
-    private performCleanup;
-    /**
-     * Get orchestration statistics
-     */
-    getStatistics(): {
-        activeAgents: number;
-        completedAgents: number;
-        failedAgents: number;
-        pendingSpawns: number;
-        totalSpawned: number;
-    };
-    /**
-     * Shutdown orchestration system
-     */
-    shutdown(): Promise<void>;
-    start(): void;
-    stop(): void;
-}
-export declare const enhancedMultiAgentOrchestrator: EnhancedMultiAgentOrchestrator;

package/dist/orchestrator/enhanced-multi-agent-orchestrator.js

@@ -1,399 +0,0 @@
-/**
- * Enhanced Multi-Agent Orchestration with Clickable Monitoring
- * Integrates subagent spawning visibility and lifecycle management
- */
-import { XrayStateManager } from "../state/state-manager.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { ComplexityAnalyzer, } from "../delegation/complexity-analyzer.js";
-import { createAgentDelegator, } from "../delegation/agent-delegator.js";
-import { xrayConfigLoader } from "../core/config-loader.js";
-import { agentSpawnGovernor } from "./agent-spawn-governor.js";
-import { spawnGate } from "../core/agent-spawn-gate.js";
-export class EnhancedMultiAgentOrchestrator {
-    state;
-    stateManager;
-    complexityAnalyzer;
-    agentDelegator;
-    executionContext;
-    cleanupTimer = null;
-    constructor(stateManager, isMainOrchestrator = false) {
-        this.stateManager = stateManager || new XrayStateManager();
-        this.complexityAnalyzer = new ComplexityAnalyzer();
-        this.agentDelegator = createAgentDelegator(this.stateManager, xrayConfigLoader);
-        this.state = {
-            activeAgents: new Map(),
-            pendingSpawns: [],
-            completedAgents: new Map(),
-            failedAgents: new Map(),
-            agentDependencies: new Map(),
-            monitoringEnabled: true,
-            cleanupInterval: stateManager ? 300000 : 30000,
-            isMainOrchestrator,
-        };
-        this.executionContext = {
-            isExecutingAsSubagent: false,
-            currentAgentId: null,
-            spawnStack: [],
-        };
-    }
-    /**
-     * 🚨 SECURITY: Check if currently executing as a subagent
-     * Prevents subagents from spawning other subagents (infinite loops, resource exhaustion)
-     */
-    isCurrentlyExecutingAsSubagent() {
-        // Main orchestrator can spawn agents, subagents cannot
-        return !this.state.isMainOrchestrator;
-    }
-    /**
-     * Enhanced agent spawning with clickable monitoring integration
-     */
-    async spawnAgent(request) {
-        const jobId = `spawn-agent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        let spawnTrackingId;
-        // 🚨 GATE: Check global spawn gate before any spawn attempt
-        try {
-            spawnGate.assertAllowed("enhanced-multi-agent-orchestrator");
-        }
-        catch (gateError) {
-            const error = new Error(`SPAWN GATE BLOCKED: ${gateError instanceof Error ? gateError.message : String(gateError)}`);
-            await frameworkLogger.log("enhanced-multi-agent-orchestrator", "spawn-gate-blocked", "error", { message: error.message, agentType: request.agentType });
-            throw error;
-        }
-        // 🚨 SECURITY: Prevent subagents from spawning other subagents
-        // This prevents infinite loops, resource exhaustion, and uncontrolled agent spawning
-        if (this.isCurrentlyExecutingAsSubagent()) {
-            const error = new Error(`SECURITY VIOLATION: Subagent attempted to spawn another agent. ` +
-                `Only the main orchestrator may spawn agents. ` +
-                `Subagent spawning is strictly prohibited to prevent infinite loops and resource exhaustion.`);
-            await frameworkLogger.log("enhanced-multi-agent-orchestrator", "subagent-spawn-violation", "error", { message: error.message });
-            throw error;
-        }
-        // 🚨 Governance: Authorize spawn via AgentSpawnGovernor
-        const auth = await agentSpawnGovernor.authorizeSpawn({
-            agentType: request.agentType,
-            operation: request.task,
-            sessionId: jobId,
-        });
-        if (!auth.authorized) {
-            const error = new Error(`Spawn denied by governance: ${auth.reason}. ` +
-                `Warnings: ${(auth.warnings || []).join(", ")}`);
-            await frameworkLogger.log("enhanced-multi-agent-orchestrator", "spawn-denied-by-governance", "error", { agentType: request.agentType, reason: auth.reason, trackingId: auth.trackingId });
-            throw error;
-        }
-        spawnTrackingId = auth.trackingId;
-        const agentId = `agent_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-        const spawnedAgent = {
-            id: agentId,
-            agentType: request.agentType,
-            task: request.task,
-            status: "spawning",
-            startTime: Date.now(),
-            progress: 0,
-            clickable: true, // Enable clickable monitoring
-            monitorable: true, // Enable real-time monitoring
-            cleanupRequired: true,
-            spawnTrackingId,
-        };
-        // Register agent in active pool
-        this.state.activeAgents.set(agentId, spawnedAgent);
-        // Handle dependencies
-        if (request.dependencies && request.dependencies.length > 0) {
-            this.state.agentDependencies.set(agentId, request.dependencies);
-            // Check if dependencies are met
-            const unmetDeps = request.dependencies.filter((depId) => !this.state.completedAgents.has(depId) ||
-                this.state.completedAgents.get(depId)?.status !== "completed");
-            if (unmetDeps.length > 0) {
-                frameworkLogger.log("orchestrator", `Agent ${agentId} waiting for dependencies: ${unmetDeps.join(", ")}`, "info", { jobId });
-                this.state.pendingSpawns.push(request);
-                return spawnedAgent;
-            }
-        }
-        // Log clickable spawn event
-        frameworkLogger.log("orchestrator", `🔗 SPAWNED: ${request.agentType} agent (${agentId}) - Click to monitor`, "info", {
-            jobId,
-            agentId,
-            agentType: request.agentType,
-            task: request.task,
-            clickable: true,
-            timestamp: Date.now(),
-        });
-        // Start agent execution
-        this.executeAgent(spawnedAgent, request, jobId).catch((error) => {
-            frameworkLogger.log("orchestrator", `Agent execution failed: ${error}`, "error", { jobId });
-        });
-        return spawnedAgent;
-    }
-    /**
-     * Execute agent with monitoring and cleanup
-     */
-    async executeAgent(agent, request, jobId) {
-        const executeJobId = `execute-agent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        try {
-            agent.status = "active";
-            agent.progress = 10;
-            // Execute agent with progress updates
-            const executionPromise = this.executeAgentWithDelegator(agent, request, executeJobId);
-            // Set up monitoring updates
-            const monitorInterval = setInterval(() => {
-                if (agent.status === "active") {
-                    agent.progress = Math.min(agent.progress + 10, 90);
-                    this.updateAgentMonitoring(agent);
-                }
-            }, 1000);
-            const result = await executionPromise;
-            clearInterval(monitorInterval);
-            // Mark as completed
-            agent.status = "completed";
-            agent.endTime = Date.now();
-            agent.progress = 100;
-            agent.result = result;
-            // Move to completed pool
-            this.state.activeAgents.delete(agent.id);
-            this.state.completedAgents.set(agent.id, agent);
-            // Notify governor
-            if (agent.spawnTrackingId) {
-                agentSpawnGovernor.completeSpawn(agent.spawnTrackingId);
-            }
-            frameworkLogger.log("orchestrator", `✅ COMPLETED: ${agent.agentType} agent (${agent.id})`, "info", {
-                executeJobId,
-                agentId: agent.id,
-                duration: agent.endTime - agent.startTime,
-                result: typeof result,
-            });
-            // Check for dependent agents that can now spawn
-            this.checkPendingSpawns();
-        }
-        catch (error) {
-            agent.status = "failed";
-            agent.endTime = Date.now();
-            agent.error = error instanceof Error ? error.message : String(error);
-            agent.progress = 0;
-            // Move to failed pool
-            this.state.activeAgents.delete(agent.id);
-            this.state.failedAgents.set(agent.id, agent);
-            // Notify governor
-            if (agent.spawnTrackingId) {
-                agentSpawnGovernor.failSpawn(agent.spawnTrackingId, error instanceof Error ? error : new Error(String(error)));
-            }
-            frameworkLogger.log("orchestrator", `❌ FAILED: ${agent.agentType} agent (${agent.id}): ${agent.error}`, "error", {
-                executeJobId,
-                agentId: agent.id,
-                error: agent.error,
-                duration: agent.endTime - agent.startTime,
-            });
-        }
-    }
-    /**
-     * Execute agent using the agent delegator system
-     */
-    async executeAgentWithDelegator(agent, request, jobId) {
-        try {
-            // Use the agent delegator system - first analyze, then execute
-            const delegationRequest = {
-                operation: "execute",
-                description: request.task,
-                context: {
-                    agentName: request.agentType,
-                    taskDescription: request.task,
-                    priority: request.priority || "medium",
-                    timeout: request.timeout,
-                    ...request.context,
-                },
-            };
-            // Analyze the delegation to get strategy
-            const delegation = await this.agentDelegator.analyzeDelegation(delegationRequest);
-            // Execute the delegation
-            const result = await this.agentDelegator.executeDelegation(delegation, delegationRequest);
-            const firstResult = result.results?.[0];
-            return {
-                success: result.success,
-                agentType: request.agentType,
-                task: request.task,
-                executionTime: result.totalTime,
-                complexity: delegation.complexity.score,
-                result: firstResult?.output || `Completed ${request.agentType} task: ${request.task}`,
-                delegationResult: result,
-            };
-        }
-        catch (error) {
-            // Fallback to simulation if delegation fails
-            frameworkLogger.log("orchestrator", `Agent delegation failed, using simulation: ${error}`, "info", { jobId });
-            return this.simulateAgentExecution(agent, request);
-        }
-    }
-    /**
-     * Simulate agent execution (FALLBACK - used when plugin not loaded)
-     *
-     * NOTE: The primary execution path is through the OpenCode plugin:
-     * - .opencode/plugin/xray-codex-injection.js intercepts prompts
-     * - Routes to agents via .opencode/agents/*.yml configs
-     * - OpenCode spawns actual agent processes
-     * - Hermes Agent handles MCP server execution
-     *
-     * This simulation is a fallback for:
-     * - Testing without real agent execution
-     * - When plugin fails to load
-     * - Documentation of what the framework orchestrates
-     *
-     * For production use, ensure the plugin is loaded in OpenCode.
-     */
-    async simulateAgentExecution(agent, request) {
-        // Simulate different execution times based on agent type and complexity
-        const baseTime = this.getAgentExecutionTime(request.agentType);
-        const complexityMetrics = await this.complexityAnalyzer.analyzeComplexity("execute", {
-            newCode: request.task,
-            files: [`task-${agent.id}.txt`],
-        });
-        const executionTime = baseTime * (1 + complexityMetrics.changeVolume / 100);
-        await new Promise((resolve) => setTimeout(resolve, executionTime));
-        return {
-            success: true,
-            agentType: request.agentType,
-            task: request.task,
-            executionTime,
-            complexity: complexityMetrics.changeVolume,
-            result: `Completed ${request.agentType} task: ${request.task}`,
-        };
-    }
-    /**
-     * Get estimated execution time for agent type
-     */
-    getAgentExecutionTime(agentType) {
-        const times = {
-            architect: 3000, // 3 seconds
-            enforcer: 2000, // 2 seconds
-            researcher: 4000, // 4 seconds
-            "code-reviewer": 2500, // 2.5 seconds
-            "security-auditor": 3500, // 3.5 seconds
-            "testing-lead": 3000, // 3 seconds
-            "bug-triage-specialist": 2800, // 2.8 seconds
-            refactorer: 3200, // 3.2 seconds
-        };
-        return times[agentType] || 3000;
-    }
-    /**
-     * Update agent monitoring (integrates with clickable interface)
-     */
-    updateAgentMonitoring(agent) {
-        if (!this.state.monitoringEnabled)
-            return;
-        // Log monitoring update for clickable interface
-        frameworkLogger.log("orchestrator", `📊 MONITOR: ${agent.agentType} (${agent.id}) - ${agent.progress}%`, "debug", {
-            agentId: agent.id,
-            progress: agent.progress,
-            status: agent.status,
-            clickable: agent.clickable,
-            timestamp: Date.now(),
-        });
-    }
-    /**
-     * Check for pending spawns that can now execute
-     */
-    checkPendingSpawns() {
-        const readySpawns = this.state.pendingSpawns.filter((spawn) => {
-            if (!spawn.dependencies)
-                return true;
-            return spawn.dependencies.every((depId) => this.state.completedAgents.has(depId) &&
-                this.state.completedAgents.get(depId)?.status === "completed");
-        });
-        // Execute ready spawns
-        readySpawns.forEach((spawn) => {
-            this.state.pendingSpawns = this.state.pendingSpawns.filter((s) => s !== spawn);
-            this.spawnAgent(spawn);
-        });
-    }
-    /**
-     * Get clickable agent monitoring interface
-     */
-    getMonitoringInterface() {
-        const allAgents = {
-            ...Object.fromEntries(this.state.activeAgents),
-            ...Object.fromEntries(this.state.completedAgents),
-            ...Object.fromEntries(this.state.failedAgents),
-        };
-        return allAgents;
-    }
-    /**
-     * Cancel agent execution
-     */
-    async cancelAgent(agentId) {
-        const agent = this.state.activeAgents.get(agentId);
-        if (!agent)
-            return false;
-        agent.status = "cancelled";
-        agent.endTime = Date.now();
-        agent.cleanupRequired = true;
-        this.state.activeAgents.delete(agentId);
-        this.state.failedAgents.set(agentId, agent);
-        frameworkLogger.log("orchestrator", `🚫 CANCELLED: ${agent.agentType} agent (${agentId})`, "info");
-        return true;
-    }
-    /**
-     * Initialize cleanup system for completed agents
-     */
-    initializeCleanupSystem() {
-        this.cleanupTimer = setInterval(() => {
-            this.performCleanup();
-        }, this.state.cleanupInterval);
-    }
-    /**
-     * Perform cleanup of completed/failed agents
-     */
-    performCleanup() {
-        const now = Date.now();
-        const cleanupThreshold = 5 * 60 * 1000; // 5 minutes
-        // Clean up old completed agents
-        for (const [agentId, agent] of this.state.completedAgents) {
-            if (agent.endTime && now - agent.endTime > cleanupThreshold) {
-                this.state.completedAgents.delete(agentId);
-                frameworkLogger.log("orchestrator", `🧹 CLEANED: Completed agent ${agentId}`, "debug");
-            }
-        }
-        // Clean up old failed agents
-        for (const [agentId, agent] of this.state.failedAgents) {
-            if (agent.endTime && now - agent.endTime > cleanupThreshold) {
-                this.state.failedAgents.delete(agentId);
-                frameworkLogger.log("orchestrator", `🧹 CLEANED: Failed agent ${agentId}`, "debug");
-            }
-        }
-    }
-    /**
-     * Get orchestration statistics
-     */
-    getStatistics() {
-        return {
-            activeAgents: this.state.activeAgents.size,
-            completedAgents: this.state.completedAgents.size,
-            failedAgents: this.state.failedAgents.size,
-            pendingSpawns: this.state.pendingSpawns.length,
-            totalSpawned: this.state.activeAgents.size +
-                this.state.completedAgents.size +
-                this.state.failedAgents.size,
-        };
-    }
-    /**
-     * Shutdown orchestration system
-     */
-    async shutdown() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-        // Cancel all active agents
-        const activeAgentIds = Array.from(this.state.activeAgents.keys());
-        await Promise.all(activeAgentIds.map((id) => this.cancelAgent(id)));
-        frameworkLogger.log("orchestrator", "🔄 Enhanced Multi-Agent Orchestrator shutdown complete", "info");
-    }
-    start() {
-        if (this.cleanupTimer)
-            return;
-        this.initializeCleanupSystem();
-    }
-    stop() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-    }
-}
-export const enhancedMultiAgentOrchestrator = new EnhancedMultiAgentOrchestrator(undefined, true);

package/dist/orchestrator/intelligent-commit-batcher.d.ts

@@ -1,114 +0,0 @@
-/**
- * Intelligent Commit Batcher - Batches related changes for optimal commit history
- * Implements configurable thresholds for file count, time windows, and risk levels
- *
- * Configuration is read from .xray/features.json -> commit_cycle
- */
-export interface PendingChange {
-    filePath: string;
-    operation: string;
-    changeType: string;
-    riskLevel: "low" | "medium" | "high" | "critical";
-    linesChanged: number;
-    timestamp: number;
-    relatedFiles?: string[];
-    commitMessage?: string;
-    author?: string;
-}
-export interface CommitBatchingConfig {
-    maxFilesPerCommit: number;
-    minFilesPerCommit: number;
-    maxTimeBetweenCommits: number;
-    minTimeBetweenCommits: number;
-    forceCommitAfter: number;
-    batchRelatedOperations: boolean;
-    maxOperationsPerBatch: number;
-    batchLowRiskChanges: boolean;
-    separateHighRiskChanges: boolean;
-    batchByComponent: boolean;
-    maxComponentsPerCommit: number;
-    autoCommit: boolean;
-    generateCommitMessages: boolean;
-    amendLastCommit: boolean;
-}
-export interface BatchMetrics {
-    fileCount: number;
-    operationCount: number;
-    componentCount: number;
-    totalLinesChanged: number;
-    timeSinceLastCommit: number;
-    averageRiskLevel: number;
-    oldestChangeTime: number;
-    newestChangeTime: number;
-}
-export declare class IntelligentCommitBatcher {
-    private pendingChanges;
-    private lastCommitTime;
-    private config;
-    constructor(config?: Partial<CommitBatchingConfig>);
-    private loadFeaturesConfig;
-    /**
-     * Add a change to the pending batch
-     */
-    addChange(change: PendingChange): boolean;
-    /**
-     * Add multiple changes to the batch
-     */
-    addChanges(changes: PendingChange[]): boolean;
-    /**
-     * Check if the current batch should be committed
-     */
-    shouldCommitBatch(): boolean;
-    /**
-     * Commit the current batch of changes
-     */
-    commitBatch(commitMessage?: string): Promise<boolean>;
-    /**
-     * Force commit current batch regardless of thresholds
-     */
-    forceCommitBatch(commitMessage?: string): Promise<boolean>;
-    /**
-     * Get current batch status and metrics
-     */
-    getBatchStatus(): {
-        pendingChanges: number;
-        metrics: BatchMetrics;
-        shouldCommit: boolean;
-        estimatedCommitMessage: string;
-    };
-    /**
-     * Calculate metrics for the current batch
-     */
-    private calculateBatchMetrics;
-    /**
-     * Check if batch has mixed risk levels that should be separated
-     */
-    private hasMixedRiskLevels;
-    /**
-     * Generate intelligent commit message
-     */
-    private generateCommitMessage;
-    /**
-     * Get files that should be staged for this commit
-     */
-    private getFilesToStage;
-    /**
-     * Stage files for commit
-     */
-    private stageFiles;
-    /**
-     * Perform the actual git commit
-     */
-    private performGitCommit;
-    /**
-     * Get summary of operations in this batch
-     */
-    private getOperationSummary;
-    private riskLevelToNumber;
-    private detectComponent;
-    private extractComponentName;
-    private getPrimaryOperation;
-    private getActionVerb;
-}
-export declare const createIntelligentCommitBatcher: (config?: Partial<CommitBatchingConfig>) => IntelligentCommitBatcher;
-export declare const intelligentCommitBatcher: IntelligentCommitBatcher;