0xray 2.0.0 → 2.0.1

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

@@ -0,0 +1,127 @@
+/**
+ * Multi-Agent Orchestration Coordinator
+ *
+ * Central coordinator for multi-agent orchestration that integrates all orchestration components
+ * for comprehensive E2E workflow management and coordination.
+ *
+ * @version 1.1.0
+ * @since 2026-01-23
+ */
+import { TaskDefinition } from "../agents/types.js";
+import { StringRayStateManager } 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 strRayOrchestrator;
+    private enhancedOrchestrator;
+    private agentDelegator;
+    private stateManager;
+    private complexityAnalyzer;
+    private coordinationMetrics;
+    constructor(stateManager?: StringRayStateManager);
+    /**
+     * 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,142 @@
+/**
+ * Orchestrator Agent
+ *
+ * Coordinates multi-step tasks and delegates to specialized subagents.
+ * Implements Sisyphus integration for relentless execution.
+ *
+ * @version 1.0.0
+ * @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 StringRayOrchestrator {
+    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 strRayOrchestrator: StringRayOrchestrator;

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

@@ -0,0 +1,109 @@
+/**
+ * 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.
+ *
+ * @version 2.0.0
+ * @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;

package/dist/orchestrator/universal-librarian-consultation.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Universal Librarian Consultation System
+ * Ensures researcher is involved in all major system actions for documentation and versioning
+ */
+import { RuleEnforcer } from "../enforcement/rule-enforcer.js";
+export interface SystemAction {
+    type: "code-change" | "rule-modification" | "architectural-change" | "configuration_update" | "documentation_update";
+    description: string;
+    scope: "framework" | "agent" | "tool" | "configuration" | "documentation";
+    complexity: "low" | "medium" | "high" | "critical";
+    files?: string[];
+    components?: string[];
+    metadata?: {
+        triggeredBy?: string;
+        [key: string]: unknown;
+    };
+}
+export interface LibrarianConsultationResult {
+    approved: boolean;
+    documentationImpact: "none" | "minor" | "major" | "critical";
+    versionUpdates: VersionUpdate[];
+    recommendations: string[];
+    pairProgrammingRequired: boolean;
+}
+export interface VersionUpdate {
+    file: string;
+    field: string;
+    oldVersion: string;
+    newVersion: string;
+    reason: string;
+}
+export interface ActionResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export interface LibrarianConsultationResult {
+    approved: boolean;
+    documentationImpact: "none" | "minor" | "major" | "critical";
+    versionUpdates: VersionUpdate[];
+    recommendations: string[];
+    pairProgrammingRequired: boolean;
+}
+export interface VersionUpdate {
+    file: string;
+    field: string;
+    oldVersion: string;
+    newVersion: string;
+    reason: string;
+}
+export declare class UniversalLibrarianConsultation {
+    private ruleEnforcer;
+    constructor(ruleEnforcer: RuleEnforcer);
+    /**
+     * Pre-action consultation - must be called before any major system action
+     */
+    consultBeforeAction(action: SystemAction): Promise<LibrarianConsultationResult>;
+    /**
+     * Post-action consultation - must be called after any major system action
+     */
+    consultAfterAction(action: SystemAction, result: ActionResult): Promise<void>;
+    /**
+     * Check if this action is related to researcher operations (to prevent recursion)
+     */
+    private isLibrarianOperation;
+    /**
+     * Assess documentation impact of the action
+     */
+    private assessDocumentationImpact;
+    /**
+     * Determine what version updates are needed
+     */
+    private determineVersionUpdates;
+    /**
+     * Check if pair programming with researcher is required
+     */
+    private requiresPairProgramming;
+    /**
+     * Generate recommendations for the action
+     */
+    private generateRecommendations;
+    /**
+     * Update documentation after action completion
+     */
+    private updateDocumentation;
+    /**
+     * Update versions after action completion
+     */
+    private updateVersions;
+    /**
+     * Validate documentation integrity
+     */
+    private validateDocumentationIntegrity;
+    /**
+     * Determine which documentation files need updating
+     */
+    private determineDocumentationFiles;
+}
+export declare const universalLibrarianConsultation: UniversalLibrarianConsultation;

package/dist/orchestrator/universal-registry-bridge.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Universal Registry Bridge
+ *
+ * Connects 0xRay to external agent registries.
+ * Enables dynamic agent configuration loading from external sources.
+ *
+ * @version 1.0.0
+ * @since 2026-02-14
+ */
+import type { AgentConfig } from "../agents/types.js";
+export interface ExternalRegistryConfig {
+    type: "file" | "http" | "npm";
+    location: string;
+    refreshInterval?: number;
+}
+export interface RegistryAgentDefinition {
+    name: string;
+    description: string;
+    version: string;
+    capabilities?: string[];
+    config?: Record<string, unknown>;
+}
+export interface BridgeOptions {
+    registries: ExternalRegistryConfig[];
+    cacheDir?: string;
+    autoRefresh?: boolean;
+}
+export declare class UniversalRegistryBridge {
+    private registries;
+    private cacheDir;
+    private autoRefresh;
+    private cache;
+    private logger;
+    constructor(options: BridgeOptions);
+    /**
+     * Load agents from all configured registries
+     */
+    loadAgents(): Promise<RegistryAgentDefinition[]>;
+    /**
+     * Fetch agents from a specific registry
+     */
+    private fetchFromRegistry;
+    /**
+     * Load agents from a local file
+     */
+    private loadFromFile;
+    /**
+     * Simple YAML parser for agent definitions
+     * Handles basic agent registry format
+     */
+    private parseYamlAgents;
+    /**
+     * Load agents from HTTP endpoint
+     */
+    private loadFromHttp;
+    /**
+     * Load agents from npm package
+     */
+    private loadFromNpm;
+    /**
+     * Convert registry definition to AgentConfig
+     */
+    toAgentConfig(registryDef: RegistryAgentDefinition): Partial<AgentConfig>;
+    /**
+     * Get cached agents from a specific registry
+     */
+    getCached(registryType: string, location: string): RegistryAgentDefinition[] | undefined;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Add a new registry dynamically
+     */
+    addRegistry(registry: ExternalRegistryConfig): void;
+    /**
+     * Get all configured registries
+     */
+    getRegistries(): ExternalRegistryConfig[];
+}
+/**
+ * Create a bridge from integration config
+ */
+export declare function createRegistryBridge(configPath?: string): Promise<UniversalRegistryBridge>;
+export declare function getDefaultBridge(): UniversalRegistryBridge;

package/dist/orchestrator/universal-registry-bridge.js

@@ -114,7 +114,7 @@ export class UniversalRegistryBridge {
                 currentAgent = {
                     name: nameMatch[1].trim(),
                     description: "",
-                    version: "1.22.67",
+                    version: "2.0.0",
                 };
                 inAgent = true;
                 continue;