0xray 3.4.2 → 3.4.3

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

@@ -0,0 +1,154 @@
+/**
+ * Voting System Types
+ *
+ * Comprehensive type definitions for the multi-agent voting system
+ * with weighted confidence scoring and adaptive conflict resolution.
+ *
+ * @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,36 @@
+/**
+ * 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
+ *
+ * @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,14 @@
+/**
+ * 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
+ */
+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,157 @@
+/**
+ * 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
+ *
+ * @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;
+}

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

@@ -0,0 +1,145 @@
+/**
+ * Rule Hierarchy - Manage rule dependencies and execution order
+ *
+ * This class manages rule dependencies and calculates execution order.
+ * It uses topological sorting to ensure dependencies are validated before dependents.
+ *
+ * Phase 5 refactoring: Extracted from RuleEnforcer.
+ *
+ * @module enforcement/core
+ *
+ * @example
+ * ```typescript
+ * const hierarchy = new RuleHierarchy();
+ * hierarchy.addDependency('tests-required', ['no-duplicate-code']);
+ * hierarchy.addDependency('memory-optimization', ['context-analysis-integration']);
+ *
+ * const order = hierarchy.getExecutionOrder(['tests-required', 'memory-optimization']);
+ * // Result: ['no-duplicate-code', 'tests-required', 'context-analysis-integration', 'memory-optimization']
+ * ```
+ */
+import { IRuleHierarchy } from '../types.js';
+/**
+ * RuleHierarchy manages rule dependency relationships and execution ordering.
+ *
+ * Key responsibilities:
+ * - Track rule dependencies (A depends on B)
+ * - Calculate execution order via topological sort
+ * - Detect circular dependencies
+ * - Check dependency satisfaction
+ */
+export declare class RuleHierarchy implements IRuleHierarchy {
+    /** Map of rule IDs to their dependencies */
+    private dependencies;
+    /** Map of rule IDs to rules that depend on them */
+    private dependents;
+    /**
+     * Add a dependency relationship.
+     * The rule will be executed after all its dependencies.
+     *
+     * @param ruleId - The rule that depends on others
+     * @param dependsOn - Array of rule IDs that must be executed first
+     *
+     * @example
+     * ```typescript
+     * hierarchy.addDependency('tests-required', ['no-duplicate-code']);
+     * // tests-required will be validated after no-duplicate-code
+     * ```
+     */
+    addDependency(ruleId: string, dependsOn: string[]): void;
+    /**
+     * Get all dependencies for a rule.
+     *
+     * @param ruleId - The rule to get dependencies for
+     * @returns Array of rule IDs that the rule depends on
+     *
+     * @example
+     * ```typescript
+     * const deps = hierarchy.getDependencies('tests-required');
+     * console.log(deps); // ['no-duplicate-code']
+     * ```
+     */
+    getDependencies(ruleId: string): string[];
+    /**
+     * Get all rules that depend on the given rule.
+     *
+     * @param ruleId - The rule to get dependents for
+     * @returns Array of rule IDs that depend on this rule
+     *
+     * @example
+     * ```typescript
+     * const dependents = hierarchy.getDependents('no-duplicate-code');
+     * console.log(dependents); // ['tests-required']
+     * ```
+     */
+    getDependents(ruleId: string): string[];
+    /**
+     * Get the execution order for a set of rules using topological sort.
+     * Rules are returned in order such that dependencies come before dependents.
+     *
+     * Uses Kahn's algorithm for topological sorting.
+     *
+     * @param ruleIds - Array of rule IDs to order
+     * @returns Sorted array of rule IDs in dependency order
+     *
+     * @example
+     * ```typescript
+     * const order = hierarchy.getExecutionOrder(['tests-required', 'no-duplicate-code']);
+     * // Result: ['no-duplicate-code', 'tests-required']
+     * ```
+     */
+    getExecutionOrder(ruleIds: string[]): string[];
+    /**
+     * Check if any circular dependencies exist in the hierarchy.
+     *
+     * @returns true if circular dependencies exist, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (hierarchy.hasCircularDependencies()) {
+     *   console.error('Circular dependencies detected!');
+     * }
+     * ```
+     */
+    hasCircularDependencies(): boolean;
+    /**
+     * Find all circular dependency cycles.
+     * Uses DFS to detect cycles in the dependency graph.
+     *
+     * @returns Array of cycles, where each cycle is an array of rule IDs
+     *
+     * @example
+     * ```typescript
+     * const cycles = hierarchy.findCircularDependencies();
+     * // cycles might be [['rule-a', 'rule-b', 'rule-c']]
+     * ```
+     */
+    findCircularDependencies(): string[][];
+    /**
+     * Check if all dependencies for a rule have been executed.
+     *
+     * @param ruleId - The rule to check
+     * @param executedRules - Set of rule IDs that have already been executed
+     * @returns true if all dependencies are satisfied, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const executed = new Set(['no-duplicate-code']);
+     * if (hierarchy.isDependencySatisfied('tests-required', executed)) {
+     *   // Safe to execute tests-required
+     * }
+     * ```
+     */
+    isDependencySatisfied(ruleId: string, executedRules: Set<string>): boolean;
+    /**
+     * Clear all dependency relationships.
+     * Useful for testing or reinitializing.
+     */
+    clear(): void;
+    /**
+     * Get all rules that have dependencies registered.
+     *
+     * @returns Array of rule IDs with dependencies
+     */
+    getAllRules(): string[];
+}

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

@@ -0,0 +1,196 @@
+/**
+ * Rule Registry - Storage and management for validation rules
+ *
+ * This class separates rule storage concerns from rule execution.
+ * It provides a centralized registry for adding, retrieving, and
+ * managing rule definitions with lifecycle operations.
+ *
+ * @module enforcement/core
+ *
+ * @example
+ * ```typescript
+ * const registry = new RuleRegistry();
+ * registry.addRule({
+ *   id: "no-console",
+ *   name: "No Console Logs",
+ *   description: "Prevents console.log usage",
+ *   category: "code-quality",
+ *   severity: "warning",
+ *   enabled: true,
+ *   validator: async (ctx) => ({ passed: true, message: "OK" })
+ * });
+ * ```
+ */
+import { RuleDefinition, IRuleRegistry } from "../types.js";
+/**
+ * RuleRegistry provides storage and lifecycle management for validation rules.
+ *
+ * This class implements the IRuleRegistry interface and encapsulates
+ * all rule storage logic, keeping the RuleEnforcer focused on execution.
+ *
+ * Key responsibilities:
+ * - Rule storage and retrieval
+ * - Enable/disable rule state management
+ * - Rule statistics and metadata
+ * - Rule lifecycle operations (add, remove, clear)
+ */
+export declare class RuleRegistry implements IRuleRegistry {
+    /** Internal storage for rules */
+    private rules;
+    /**
+     * Add a rule to the registry.
+     *
+     * @param rule - The rule definition to add
+     * @throws Error if a rule with the same ID already exists
+     *
+     * @example
+     * ```typescript
+     * registry.addRule({
+     *   id: "no-console",
+     *   name: "No Console Logs",
+     *   description: "Prevents console.log usage",
+     *   category: "code-quality",
+     *   severity: "warning",
+     *   enabled: true,
+     *   validator: async (ctx) => ({ passed: true, message: "OK" })
+     * });
+     * ```
+     */
+    addRule(rule: RuleDefinition): void;
+    /**
+     * Get all loaded rules as an array.
+     *
+     * @returns Array of all rule definitions
+     *
+     * @example
+     * ```typescript
+     * const allRules = registry.getRules();
+     * console.log(`Loaded ${allRules.length} rules`);
+     * ```
+     */
+    getRules(): RuleDefinition[];
+    /**
+     * Get a specific rule by its ID.
+     *
+     * @param ruleId - The unique identifier of the rule
+     * @returns The rule definition or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const rule = registry.getRule("no-console");
+     * if (rule) {
+     *   console.log(rule.name);
+     * }
+     * ```
+     */
+    getRule(ruleId: string): RuleDefinition | undefined;
+    /**
+     * Enable a rule by its ID.
+     *
+     * @param ruleId - The unique identifier of the rule to enable
+     * @returns true if the rule was found and enabled, false if not found
+     *
+     * @example
+     * ```typescript
+     * if (registry.enableRule("no-console")) {
+     *   console.log("Rule enabled successfully");
+     * }
+     * ```
+     */
+    enableRule(ruleId: string): boolean;
+    /**
+     * Disable a rule by its ID.
+     *
+     * @param ruleId - The unique identifier of the rule to disable
+     * @returns true if the rule was found and disabled, false if not found
+     *
+     * @example
+     * ```typescript
+     * if (registry.disableRule("no-console")) {
+     *   console.log("Rule disabled successfully");
+     * }
+     * ```
+     */
+    disableRule(ruleId: string): boolean;
+    /**
+     * Check if a rule is enabled.
+     *
+     * @param ruleId - The unique identifier of the rule
+     * @returns true if the rule exists and is enabled, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.isRuleEnabled("no-console")) {
+     *   // Rule is active
+     * }
+     * ```
+     */
+    isRuleEnabled(ruleId: string): boolean;
+    /**
+     * Get the total count of rules in the registry.
+     *
+     * @returns The number of rules stored
+     *
+     * @example
+     * ```typescript
+     * console.log(`Registry contains ${registry.getRuleCount()} rules`);
+     * ```
+     */
+    getRuleCount(): number;
+    /**
+     * Get comprehensive statistics about rules in the registry.
+     *
+     * @returns Statistics including total, enabled, disabled counts and category breakdown
+     *
+     * @example
+     * ```typescript
+     * const stats = registry.getRuleStats();
+     * console.log(`Enabled: ${stats.enabledRules}/${stats.totalRules}`);
+     * console.log("By category:", stats.ruleCategories);
+     * ```
+     */
+    getRuleStats(): {
+        totalRules: number;
+        enabledRules: number;
+        disabledRules: number;
+        ruleCategories: Record<string, number>;
+    };
+    /**
+     * Check if a rule exists in the registry.
+     *
+     * @param ruleId - The unique identifier of the rule
+     * @returns true if the rule exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.hasRule("no-console")) {
+     *   // Rule exists
+     * }
+     * ```
+     */
+    hasRule(ruleId: string): boolean;
+    /**
+     * Remove a rule from the registry.
+     *
+     * @param ruleId - The unique identifier of the rule to remove
+     * @returns true if the rule was found and removed, false if not found
+     *
+     * @example
+     * ```typescript
+     * if (registry.removeRule("no-console")) {
+     *   console.log("Rule removed successfully");
+     * }
+     * ```
+     */
+    removeRule(ruleId: string): boolean;
+    /**
+     * Clear all rules from the registry.
+     *
+     * @example
+     * ```typescript
+     * registry.clearRules();
+     * console.log(`Registry cleared. Count: ${registry.getRuleCount()}`);
+     * ```
+     */
+    clearRules(): void;
+}