0xray 3.4.2 → 3.4.3

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

@@ -0,0 +1,156 @@
+/**
+ * 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/intelligent-commit-batcher.d.ts

@@ -0,0 +1,114 @@
+/**
+ * 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;

package/dist/orchestrator/multi-agent-orchestration-coordinator.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Multi-Agent Orchestration Coordinator
+ *
+ * Central coordinator for multi-agent orchestration that integrates all orchestration components
+ * for comprehensive E2E workflow management and coordination.
+ *
+ * @since 2026-01-23
+ */
+import { TaskDefinition } from "../agents/types.js";
+import { XrayStateManager } from "../state/state-manager.js";
+export interface OrchestrationWorkflow {
+    id: string;
+    name: string;
+    description: string;
+    tasks: TaskDefinition[];
+    priority: "low" | "medium" | "high" | "critical";
+    timeout?: number;
+    dependencies?: string[];
+    context?: Record<string, any>;
+}
+export interface OrchestrationResult {
+    success: boolean;
+    workflowId: string;
+    completedTasks: number;
+    failedTasks: number;
+    totalTasks: number;
+    duration: number;
+    results: unknown[];
+    errors: string[];
+    agentCoordination: {
+        agentsUsed: string[];
+        coordinationEvents: number;
+        conflictsResolved: number;
+    };
+}
+export interface ExecutionPlan {
+    complexityScore: number;
+    recommendedStrategy: "single-agent" | "multi-agent" | "orchestrator-led";
+    parallelGroups: TaskDefinition[][];
+    dependencyGraph: Map<string, string[]>;
+    estimatedDuration: number;
+}
+export interface ResourceAllocation {
+    allocatedAgents: string[];
+    resourceAvailability: Record<string, boolean>;
+    coordinationCapacity: number;
+}
+export interface WorkflowTaskResult {
+    success: boolean;
+    taskId?: string | undefined;
+    result?: unknown | undefined;
+    error?: string | undefined;
+    duration: number;
+}
+export interface CoordinatedWorkflowResult {
+    taskResults: WorkflowTaskResult[];
+    coordinationEvents: number;
+    conflictsResolved: number;
+    agentsUsed: string[];
+}
+export interface CoordinationMetrics {
+    totalWorkflows: number;
+    successfulWorkflows: number;
+    failedWorkflows: number;
+    averageDuration: number;
+    agentUtilization: Record<string, number>;
+    coordinationEfficiency: number;
+}
+export declare class MultiAgentOrchestrationCoordinator {
+    private xrayOrchestrator;
+    private enhancedOrchestrator;
+    private agentDelegator;
+    private stateManager;
+    private complexityAnalyzer;
+    private coordinationMetrics;
+    constructor(stateManager?: XrayStateManager);
+    /**
+     * Initialize the coordination system with all components
+     */
+    private initializeCoordinationSystem;
+    /**
+     * Execute a complete orchestration workflow with full coordination
+     */
+    executeOrchestrationWorkflow(workflow: OrchestrationWorkflow, sessionId?: string): Promise<OrchestrationResult>;
+    /**
+     * Analyze workflow complexity and create execution plan
+     */
+    private analyzeWorkflowComplexity;
+    /**
+     * Allocate resources for workflow execution
+     */
+    private allocateWorkflowResources;
+    /**
+     * Execute coordinated workflow using all orchestration components
+     */
+    private executeCoordinatedWorkflow;
+    /**
+     * Consolidate workflow results
+     */
+    private consolidateWorkflowResults;
+    /**
+     * Build parallel execution groups based on dependencies
+     */
+    private buildParallelExecutionGroups;
+    /**
+     * Update coordination metrics
+     */
+    private updateCoordinationMetrics;
+    /**
+     * Get coordination metrics
+     */
+    getCoordinationMetrics(): CoordinationMetrics;
+    /**
+     * Validate orchestration workflow
+     */
+    validateWorkflow(workflow: OrchestrationWorkflow): {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Shutdown coordination system
+     */
+    shutdown(): Promise<void>;
+}
+export declare const multiAgentOrchestrationCoordinator: MultiAgentOrchestrationCoordinator;

package/dist/orchestrator/orchestrator.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Orchestrator Agent
+ *
+ * Coordinates multi-step tasks and delegates to specialized subagents.
+ * Implements Sisyphus integration for relentless execution.
+ *
+ * @since 2026-01-07
+ */
+export interface OrchestratorConfig {
+    maxConcurrentTasks: number;
+    taskTimeout: number;
+    conflictResolutionStrategy: "majority_vote" | "expert_priority" | "consensus";
+}
+export interface TaskDefinition {
+    id: string;
+    description: string;
+    subagentType: string;
+    priority?: "high" | "medium" | "low";
+    dependencies?: string[];
+}
+export interface TaskResult {
+    success: boolean;
+    result?: TaskExecutionResult;
+    error?: string;
+    duration: number;
+    taskId?: string;
+    taskType?: string;
+    resolved?: boolean;
+    resolutionStrategy?: string;
+}
+export interface TaskExecutionResult {
+    fixesApplied?: number;
+    testsOptimized?: number;
+    performanceImprovement?: number;
+    recommendations?: string[];
+    [key: string]: unknown;
+}
+export interface TestFailureContext {
+    failedTests: string[];
+    timeoutIssues: string[];
+    performanceIssues: string[];
+    flakyTests: string[];
+    errorLogs: string[];
+    testExecutionTime: number;
+    sessionId?: string;
+}
+export interface HealingStrategy {
+    priorityLevel: "low" | "medium" | "high" | "critical";
+    agentsNeeded: string[];
+    estimatedTime: number;
+    complexityScore: number;
+    healingApproach: "simple" | "coordinated" | "enterprise";
+}
+export interface ConsolidationResult {
+    success: boolean;
+    fixesApplied: number;
+    testsOptimized: number;
+    performanceImprovement: number;
+    recommendations: string[];
+    summary: string;
+}
+export declare class XrayOrchestrator {
+    private config;
+    private activeTasks;
+    private taskToAgentMap;
+    private votingCoordinator;
+    constructor(config?: Partial<OrchestratorConfig>);
+    /**
+     * Load orchestrator config from features.json
+     */
+    private loadOrchestratorConfig;
+    /**
+     * Map config key to enum value
+     */
+    private mapConflictResolution;
+    /**
+     * Execute a complex multi-step task
+     */
+    executeComplexTask(description: string, tasks: TaskDefinition[], sessionId?: string): Promise<TaskResult[]>;
+    /**
+     * Execute a single task by delegating to appropriate subagent
+     */
+    private executeSingleTask;
+    /**
+     * Auto-healing orchestration for test failures - coordinates multi-agent response
+     */
+    orchestrateTestAutoHealing(failureContext: TestFailureContext, sessionId?: string): Promise<{
+        success: boolean;
+        healingResult: unknown;
+        agentCoordination: string[];
+        performanceImprovement: number;
+    }>;
+    /**
+     * Analyze test failure patterns to determine healing strategy
+     */
+    private analyzeTestFailurePatterns;
+    /**
+     * Create task definitions for healing orchestration
+     */
+    private createHealingTaskDefinitions;
+    /**
+     * Consolidate healing results from multiple agents
+     */
+    private consolidateHealingResults;
+    /**
+     * Delegate task to appropriate subagent using enhanced orchestration
+     */
+    private delegateToSubagent;
+    /**
+     * Resolve conflicts between subagent responses
+     */
+    resolveConflicts(conflicts: Array<{
+        response?: unknown;
+        agentType?: string;
+        expertiseScore?: number;
+    }>): unknown;
+    private resolveByMajorityVote;
+    private resolveByConsensus;
+    /**
+     * Detect and resolve conflicts between task results in a batch.
+     * This enables multi-agent governance by comparing results from parallel agents.
+     *
+     * Current implementation: Disabled by default - needs refinement to properly
+     * detect actual conflicts vs. expected different results from different agent types.
+     * Set ENABLE_CONFLICT_DETECTION=true to enable.
+     */
+    private detectAndResolveConflicts;
+    /**
+     * Populate expertiseScore based on agent type for expert_priority resolution.
+     * This maps agent types to expertise levels for conflict resolution.
+     */
+    private resolveByExpertPriority;
+    /**
+     * Get orchestrator status
+     */
+    getStatus(): {
+        activeTasks: number;
+        config: OrchestratorConfig;
+    };
+}
+export declare const xrayOrchestrator: XrayOrchestrator;

package/dist/orchestrator/self-direction-activation.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Self-Direction Activation System (Simplified)
+ *
+ * Commercial version with autonomous self-direction capabilities.
+ * Activates the framework's dormant self-evolution systems for continuous improvement.
+ * This version works without advanced-features dependencies for initial deployment.
+ *
+ * @since 2026-01-24
+ */
+export interface SelfDirectionConfig {
+    monitoringInterval: number;
+    analyticsInterval: number;
+    learningCycleInterval: number;
+    autonomousReporting: boolean;
+    predictiveOptimization: boolean;
+    scalingAutonomy: boolean;
+    evolutionSafety: boolean;
+}
+export interface SelfAssessmentReport {
+    timestamp: number;
+    healthScore: number;
+    criticalIssues: CriticalIssue[];
+    improvementOpportunities: ImprovementOpportunity[];
+    predictions: SystemPrediction[];
+    recommendations: string[];
+}
+export interface CriticalIssue {
+    id: string;
+    severity: "low" | "medium" | "high" | "critical";
+    component: string;
+    description: string;
+    impact: string;
+    recommendedAction: string;
+}
+export interface ImprovementOpportunity {
+    id: string;
+    type: "performance" | "reliability" | "efficiency" | "capability";
+    description: string;
+    potentialBenefit: string;
+    implementationComplexity: "low" | "medium" | "high";
+    confidence: number;
+}
+export interface SystemPrediction {
+    type: "scaling" | "performance" | "reliability" | "resource";
+    prediction: string;
+    confidence: number;
+    timeHorizon: number;
+    recommendedAction?: string;
+}
+/**
+ * Simplified Self-Direction Activation System
+ *
+ * Provides basic self-direction capabilities without advanced-features dependencies
+ * for initial deployment and testing.
+ */
+export declare class SelfDirectionSystem {
+    private config;
+    private activeMonitoring;
+    private activeLearning;
+    private monitoringIntervalId;
+    private learningIntervalId;
+    constructor(config?: Partial<SelfDirectionConfig>);
+    /**
+     * Phase 1: Activate Self-Monitoring Foundation
+     */
+    activateSelfMonitoring(): Promise<void>;
+    /**
+     * Setup autonomous critical issue reporting
+     */
+    private setupAutonomousReporting;
+    /**
+     * Start continuous self-assessment cycle
+     */
+    private startContinuousSelfAssessment;
+    /**
+     * Phase 2: Activate Self-Evolution Learning
+     */
+    activateSelfEvolution(): Promise<void>;
+    /**
+     * Start learning cycles
+     */
+    private startLearningCycles;
+    /**
+     * Core self-assessment method
+     */
+    performSelfAssessment(): Promise<SelfAssessmentReport>;
+    /**
+     * Process self-assessment results
+     */
+    private processSelfAssessmentResults;
+    /**
+     * Get current self-direction status
+     */
+    getStatus(): {
+        activeMonitoring: boolean;
+        activeLearning: boolean;
+        config: SelfDirectionConfig;
+        componentsHealth: Record<string, boolean>;
+    };
+    /**
+     * Shutdown self-direction system
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Export singleton instance
+ */
+export declare const selfDirectionSystem: SelfDirectionSystem;