0xray 2.0.0 → 2.1.0

package/dist/delegation/session-coordinator.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Session Coordinator
+ *
+ * Manages cross-agent communication and coordination within sessions.
+ * Tracks delegation state, agent interactions, and conflict resolution.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+import { DelegationResult } from "./agent-delegator.js";
+export interface SessionContext {
+    sessionId: string;
+    startTime: number;
+    activeDelegations: Map<string, DelegationResult>;
+    agentInteractions: Map<string, AgentInteraction[]>;
+    conflictHistory: ConflictRecord[];
+    coordinationState: CoordinationState;
+    isActive: boolean;
+}
+export interface AgentInteraction {
+    agentName: string;
+    timestamp: number;
+    action: string;
+    result: unknown;
+    duration: number;
+    success: boolean;
+}
+export interface ConflictRecord {
+    conflictId: string;
+    timestamp: number;
+    agents: string[];
+    resolution: "consensus" | "majority_vote" | "expert_priority" | "manual";
+    outcome: unknown;
+}
+export interface CoordinationState {
+    activeAgents: Set<string>;
+    pendingCommunications: Communication[];
+    sharedContext: Map<string, SharedContextEntry[]>;
+    sessionMetrics: SessionMetrics;
+}
+export interface SharedContextEntry {
+    value: unknown;
+    fromAgent: string;
+    timestamp: number;
+}
+export interface Communication {
+    id: string;
+    fromAgent: string;
+    toAgent: string;
+    message: unknown;
+    timestamp: number;
+    priority: "low" | "medium" | "high";
+}
+export interface SessionMetrics {
+    totalInteractions: number;
+    successfulInteractions: number;
+    failedInteractions: number;
+    averageResponseTime: number;
+    conflictResolutionRate: number;
+    coordinationEfficiency: number;
+}
+export declare class SessionCoordinator {
+    private stateManager;
+    private sessions;
+    constructor(stateManager: XrayStateManager);
+    /**
+     * Get read-only view of all sessions - avoids breaking encapsulation
+     */
+    getSessions(): ReadonlyMap<string, SessionContext>;
+    /**
+     * Get a specific session by ID
+     */
+    getSession(sessionId: string): SessionContext | undefined;
+    /**
+     * Initialize session coordination for a new session
+     */
+    initializeSession(sessionId: string): {
+        sessionId: string;
+        createdAt: Date;
+        active: boolean;
+        agentCount: number;
+    };
+    /**
+     * Register delegation execution in session
+     */
+    registerDelegation(sessionId: string, delegationId: string, delegation: DelegationResult): void;
+    /**
+     * Record agent interaction within session
+     */
+    recordInteraction(sessionId: string, agentName: string, interaction: Omit<AgentInteraction, "timestamp">): void;
+    /**
+     * Send message between agents within session
+     */
+    sendMessage(sessionId: string, fromAgent: string, toAgent: string, message: unknown, priority?: "low" | "medium" | "high"): Promise<void>;
+    /**
+     * Receive pending messages for an agent
+     */
+    receiveMessages(sessionId: string, agentName: string): Communication[];
+    /**
+     * Share context data between agents
+     */
+    shareContext(sessionId: string, key: string, value: unknown, fromAgent: string): void;
+    /**
+     * Get shared context data
+     */
+    getSharedContext(sessionId: string, key: string): unknown;
+    /**
+     * Record conflict and resolution
+     */
+    recordConflict(sessionId: string, agents: string[], resolution: ConflictRecord["resolution"], outcome: unknown): void;
+    /**
+     * Complete delegation and cleanup
+     */
+    completeDelegation(sessionId: string, delegationId: string, result: unknown): void;
+    /**
+     * Get session coordination status
+     */
+    getSessionStatus(sessionId: string): {
+        active: boolean;
+        agentCount: number;
+    } | null;
+    /**
+     * Resolve conflicts using specified strategy
+     */
+    resolveConflict(sessionId: string, conflictKey: string, strategy: "majority_vote" | "expert_priority" | "consensus"): unknown;
+    /**
+     * Cleanup session coordination data
+     */
+    cleanupSession(sessionId: string): void;
+    private updateSessionMetrics;
+}
+export declare const createSessionCoordinator: (stateManager: XrayStateManager) => SessionCoordinator;

package/dist/delegation/strategy-selector.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Adaptive Strategy Selector
+ *
+ * Selects the optimal voting strategy based on:
+ * - Complexity level of the task
+ * - Risk level involved
+ * - Security concerns
+ * - Architectural impact
+ * - Participant count
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+import type { VotingStrategy, StrategySelectionContext, AdaptiveStrategyConfig } from "./voting-types.js";
+export declare class AdaptiveStrategySelector {
+    private config;
+    constructor(config?: Partial<AdaptiveStrategyConfig>);
+    selectStrategy(context: StrategySelectionContext): VotingStrategy;
+    selectStrategyWithDefaults(complexity: number, riskLevel: string, hasSecurityConcerns?: boolean, hasArchitecturalImpact?: boolean, participantCount?: number): VotingStrategy;
+    getStrategyReasoning(context: StrategySelectionContext): string;
+    private isSecurityRelated;
+    private isArchitecturalRelated;
+    private getComplexityTier;
+    getConfig(): AdaptiveStrategyConfig;
+    updateConfig(config: Partial<AdaptiveStrategyConfig>): void;
+}
+export declare const adaptiveStrategySelector: AdaptiveStrategySelector;
+export declare function selectVotingStrategy(complexity: number, riskLevel: string, hasSecurityConcerns?: boolean, hasArchitecturalImpact?: boolean, participantCount?: number): VotingStrategy;

package/dist/delegation/voting-coordinator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Voting Coordinator
+ *
+ * Multi-agent voting system with:
+ * - Weighted confidence scoring based on agent expertise
+ * - Adaptive strategy selection
+ * - Historical learning and pattern detection
+ * - Integration with session coordinator
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+import type { VotingSession, VotingResult, StrategySelectionContext, VotingHistoryEntry, VotingMetrics, ConflictResolutionRequest, ConflictResolutionResponse } from "./voting-types.js";
+import { SessionCoordinator } from "./session-coordinator.js";
+import { WeightedVotingAggregator } from "./weighted-voting-aggregator.js";
+import { XrayStateManager } from "../state/state-manager.js";
+export interface VotingCoordinatorConfig {
+    enableHistoryTracking: boolean;
+    enableLearning: boolean;
+    minVotersForConsensus: number;
+    consensusThreshold: number;
+}
+export declare class VotingCoordinator {
+    private stateManager;
+    private sessionCoordinator;
+    private activeVotingSessions;
+    private votingHistory;
+    private metrics;
+    private config;
+    private aggregator;
+    constructor(stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator, config?: Partial<VotingCoordinatorConfig>);
+    initiateVoting(sessionId: string, topic: string, description: string, participants: string[], context?: StrategySelectionContext): Promise<string>;
+    submitVote(voteId: string, agentName: string, vote: string, confidence: number, reasoning?: string): boolean;
+    resolveVoting(voteId: string): VotingResult | null;
+    resolveConflict(request: ConflictResolutionRequest): ConflictResolutionResponse;
+    getAggregator(): WeightedVotingAggregator;
+    getVotingSession(voteId: string): VotingSession | undefined;
+    getActiveVotingSessions(): VotingSession[];
+    getVotingHistory(sessionId?: string, limit?: number): VotingHistoryEntry[];
+    getMetrics(): VotingMetrics;
+    private resolveMajorityVote;
+    private resolveConsensus;
+    private resolveExpertPriority;
+    private recordVotingHistory;
+    private loadHistory;
+    private initializeMetrics;
+    private updateMetricsAfterVote;
+}
+export declare const createVotingCoordinator: (stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator) => VotingCoordinator;

package/dist/delegation/voting-types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Voting System Types
+ *
+ * Comprehensive type definitions for the multi-agent voting system
+ * with weighted confidence scoring and adaptive conflict resolution.
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+export type VotingStrategy = "majority_vote" | "consensus" | "expert_priority";
+export type VoteChoice = {
+    agentName: string;
+    vote: string;
+    confidence: number;
+    reasoning: string | undefined;
+    timestamp: number;
+};
+export type VotingResult = {
+    decision: string;
+    confidence: number;
+    strategy: VotingStrategy;
+    voteCount: number;
+    winningVotes: number;
+    totalVoters: number;
+    tied: boolean;
+    details: VotingResultDetail[];
+};
+export type VotingResultDetail = {
+    agentName: string;
+    expertiseLevel: number;
+    vote: string;
+    weight: number;
+    contributed: boolean;
+};
+export type AgentExpertise = {
+    name: string;
+    expertiseLevel: number;
+    domain: string;
+    specialties: string[];
+};
+export type VotingSession = {
+    id: string;
+    sessionId: string;
+    topic: string;
+    description: string;
+    strategy: VotingStrategy;
+    complexity: number;
+    riskLevel: string;
+    participants: string[];
+    votes: VoteChoice[];
+    result?: VotingResult;
+    createdAt: number;
+    resolvedAt?: number;
+};
+export type StrategySelectionContext = {
+    complexity: number;
+    riskLevel: string;
+    participantCount: number;
+    hasSecurityConcerns: boolean | undefined;
+    hasArchitecturalImpact: boolean | undefined;
+    timeConstraint?: number;
+};
+export type VotingHistoryEntry = {
+    id: string;
+    sessionId: string;
+    topic: string;
+    voteCount: number;
+    strategy: VotingStrategy;
+    decision: string;
+    confidence: number;
+    participantCount: number;
+    successRating?: number;
+    timestamp: number;
+    resolvedAt: number;
+    agentPerformance?: Record<string, AgentPerformanceEntry>;
+};
+export type AgentPerformanceEntry = {
+    agentName: string;
+    correctVotes: number;
+    totalVotes: number;
+    averageConfidence: number;
+    lastVotedAt: number;
+    successRate: number;
+};
+export type AdaptiveStrategyConfig = {
+    simple: VotingStrategy;
+    moderate: VotingStrategy;
+    complex: VotingStrategy;
+    enterprise: VotingStrategy;
+    securityDominant: VotingStrategy;
+    architecturalDominant: VotingStrategy;
+};
+export type VotingMetrics = {
+    totalVotes: number;
+    successfulVotes: number;
+    failedVotes: number;
+    averageConfidence: number;
+    strategyUsage: Record<VotingStrategy, number>;
+    agentParticipation: Record<string, number>;
+    averageVoterTurnout: number;
+};
+export interface ConflictResolutionRequest {
+    sessionId: string;
+    topic: string;
+    description: string;
+    agents: string[];
+    requiresSecurityVote: boolean;
+    requiresArchitectureVote: boolean;
+    complexity: number;
+    riskLevel: string;
+    context?: Record<string, unknown>;
+}
+export interface ConflictResolutionResponse {
+    resolved: boolean;
+    decision?: string;
+    strategy: VotingStrategy;
+    confidence: number;
+    details: string;
+    participatingAgents: string[];
+}
+export interface HistoricalWeightConfig {
+    decayFactor: number;
+    minWeight: number;
+    maxWeight: number;
+    lookbackPeriod: number;
+    successThreshold: number;
+}
+export interface AgentHistoricalPerformance {
+    agentName: string;
+    totalVotes: number;
+    correctVotes: number;
+    averageConfidence: number;
+    weightedScore: number;
+    lastActivity: number;
+    streakCount: number;
+    domainPerformance: Record<string, {
+        correct: number;
+        total: number;
+    }>;
+}
+export interface ConfidenceWeightConfig {
+    expertiseMultiplier: number;
+    confidenceMultiplier: number;
+    minConfidenceThreshold: number;
+    normalizeScores: boolean;
+}
+export interface WeightedVoteAggregation {
+    option: string;
+    baseWeight: number;
+    expertiseWeight: number;
+    confidenceWeight: number;
+    historicalWeight: number;
+    totalWeight: number;
+    contributingAgents: string[];
+}

package/dist/delegation/weighted-voting-aggregator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Weighted Voting Aggregator
+ *
+ * Advanced voting system with:
+ * - Confidence-weighted voting where agent confidence affects their vote weight
+ * - History-weighted voting that considers past successful votes
+ * - Multiple aggregation strategies for different decision scenarios
+ *
+ * @version 1.0.0
+ * @since 2026-04-17
+ */
+import type { VoteChoice, VotingResultDetail, HistoricalWeightConfig, AgentHistoricalPerformance, ConfidenceWeightConfig, WeightedVoteAggregation } from "./voting-types.js";
+export declare const DEFAULT_HISTORICAL_CONFIG: HistoricalWeightConfig;
+export declare const DEFAULT_CONFIDENCE_CONFIG: ConfidenceWeightConfig;
+export declare class WeightedVotingAggregator {
+    private historicalConfig;
+    private confidenceConfig;
+    private agentPerformance;
+    constructor(historicalConfig?: Partial<HistoricalWeightConfig>, confidenceConfig?: Partial<ConfidenceWeightConfig>);
+    calculateExpertiseWeight(agentName: string): number;
+    calculateConfidenceWeight(agentName: string, voteConfidence: number): number;
+    calculateHistoricalWeight(agentName: string): number;
+    calculateTotalVoteWeight(agentName: string, voteConfidence: number): number;
+    aggregateVotes(votes: VoteChoice[]): WeightedVoteAggregation[];
+    updateAgentPerformance(agentName: string, decision: string, votedFor: string, wasCorrect: boolean, confidence: number): void;
+    getAgentPerformance(agentName: string): AgentHistoricalPerformance | undefined;
+    getAllPerformance(): AgentHistoricalPerformance[];
+    loadPerformance(performance: Map<string, AgentHistoricalPerformance>): void;
+    reset(): void;
+}
+export declare const createWeightedVotingAggregator: (historicalConfig?: Partial<HistoricalWeightConfig>, confidenceConfig?: Partial<ConfidenceWeightConfig>) => WeightedVotingAggregator;
+export declare function createDetailedVotingResult(votes: VoteChoice[], aggregator: WeightedVotingAggregator): {
+    aggregated: WeightedVoteAggregation[];
+    winner: WeightedVoteAggregation | null;
+    confidence: number;
+    details: VotingResultDetail[];
+};

package/dist/enforcement/core/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rule Enforcement Core Components
+ *
+ * This module exports the core components of the rule enforcement system.
+ * These components handle rule storage, hierarchy, execution, and fixing.
+ *
+ * Phase 5 refactoring: Extracted from RuleEnforcer.
+ *
+ * @module enforcement/core
+ * @version 1.0.0
+ */
+export { RuleRegistry } from './rule-registry.js';
+export { RuleHierarchy } from './rule-hierarchy.js';
+export { RuleExecutor } from './rule-executor.js';
+export { ViolationFixer } from './violation-fixer.js';

package/dist/enforcement/core/rule-executor.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Rule Executor - Orchestrate validation execution
+ *
+ * This class orchestrates the execution of validation rules, handling
+ * single rule execution, batch execution, parallel vs serial execution,
+ * dependency ordering, timeouts, and error handling.
+ *
+ * Phase 5 refactoring: Extracted from RuleEnforcer.
+ *
+ * @module enforcement/core
+ * @version 1.0.0
+ *
+ * @example
+ * ```typescript
+ * const executor = new RuleExecutor(registry, hierarchy, validatorRegistry);
+ *
+ * // Execute all applicable rules for an operation
+ * const report = await executor.execute('write', context);
+ *
+ * // Execute a specific rule
+ * const result = await executor.executeSingle('no-duplicate-code', context);
+ *
+ * // Execute multiple rules in batch
+ * const results = await executor.executeBatch(['rule1', 'rule2'], context);
+ * ```
+ */
+import { IRuleExecutor, IRuleRegistry, IRuleHierarchy, IValidatorRegistry, RuleValidationContext, RuleValidationResult, ValidationReport, ExecutionOptions, BatchExecutionOptions } from '../types.js';
+/**
+ * RuleExecutor orchestrates the execution of validation rules.
+ *
+ * Key responsibilities:
+ * - Execute single rules
+ * - Execute rules in batch (parallel or serial)
+ * - Sort rules by dependency order
+ * - Handle timeouts and errors
+ * - Generate validation reports
+ */
+export declare class RuleExecutor implements IRuleExecutor {
+    private registry;
+    private hierarchy;
+    private validatorRegistry;
+    /** Default timeout for rule validation in milliseconds */
+    private readonly DEFAULT_TIMEOUT_MS;
+    constructor(registry: IRuleRegistry, hierarchy: IRuleHierarchy, validatorRegistry: IValidatorRegistry);
+    /**
+     * Execute validation for an operation against all applicable rules.
+     *
+     * This method:
+     * 1. Gets all applicable rules for the operation
+     * 2. Sorts them by dependency order
+     * 3. Executes each rule
+     * 4. Collects results and generates a validation report
+     *
+     * @param operation - The operation being performed (e.g., 'write', 'create')
+     * @param context - Validation context with code and operation info
+     * @param options - Optional execution options
+     * @returns Promise resolving to validation report
+     *
+     * @example
+     * ```typescript
+     * const report = await executor.execute('write', {
+     *   operation: 'write',
+     *   files: ['src/index.ts'],
+     *   newCode: 'console.log("hello");'
+     * });
+     *
+     * console.log(report.passed); // false if any rule failed
+     * console.log(report.errors); // Array of error messages
+     * ```
+     */
+    execute(operation: string, context: RuleValidationContext, options?: ExecutionOptions): Promise<ValidationReport>;
+    /**
+     * Execute a single rule by ID.
+     *
+     * @param ruleId - The ID of the rule to execute
+     * @param context - Validation context
+     * @returns Promise resolving to validation result
+     * @throws Error if rule not found or not enabled
+     *
+     * @example
+     * ```typescript
+     * const result = await executor.executeSingle('no-duplicate-code', context);
+     * console.log(result.passed); // true or false
+     * ```
+     */
+    executeSingle(ruleId: string, context: RuleValidationContext): Promise<RuleValidationResult>;
+    /**
+     * Execute multiple rules in batch.
+     *
+     * Supports parallel or serial execution based on options.
+     * Optionally sorts rules by dependency order before execution.
+     *
+     * @param ruleIds - Array of rule IDs to execute
+     * @param context - Validation context
+     * @param options - Optional batch execution options
+     * @returns Promise resolving to array of validation results
+     *
+     * @example
+     * ```typescript
+     * const results = await executor.executeBatch(
+     *   ['no-duplicate-code', 'tests-required'],
+     *   context,
+     *   { parallel: true, sortByDependencies: true }
+     * );
+     * ```
+     */
+    executeBatch(ruleIds: string[], context: RuleValidationContext, options?: BatchExecutionOptions): Promise<RuleValidationResult[]>;
+    /**
+     * Execute a rule with timeout protection.
+     *
+     * @param rule - The rule definition to execute
+     * @param context - Validation context
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Promise resolving to validation result
+     */
+    private executeRuleWithTimeout;
+    /**
+     * Execute rules in parallel.
+     *
+     * @param rules - Array of rules to execute
+     * @param context - Validation context
+     * @param options - Execution options
+     * @returns Promise resolving to array of results
+     */
+    private executeParallel;
+    /**
+     * Sort rules by dependency order using the hierarchy.
+     *
+     * @param rules - Array of rules to sort
+     * @returns Sorted array of rules
+     */
+    private sortByDependencyOrder;
+    /**
+     * Process a single result and categorize errors/warnings.
+     */
+    private processResult;
+    /**
+     * Process multiple results and categorize errors/warnings.
+     */
+    private processResults;
+    /**
+     * Get applicable rules for an operation and context.
+     *
+     * @param operation - The operation being performed
+     * @param context - Validation context
+     * @returns Array of applicable rule definitions
+     */
+    private getApplicableRules;
+    /**
+     * Check if a rule is applicable to the current operation.
+     *
+     * @param rule - The rule definition
+     * @param operation - The operation being performed
+     * @param context - Validation context
+     * @returns true if the rule is applicable
+     */
+    private isRuleApplicable;
+}