0xray 4.0.11 → 4.0.13

package/dist/delegation/weighted-voting-aggregator.js

@@ -1,193 +0,0 @@
-/**
- * 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 { getAgentExpertiseLevel, getVotingWeight, } from "./agent-expertise.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-export const DEFAULT_HISTORICAL_CONFIG = {
-    decayFactor: 0.95,
-    minWeight: 0.1,
-    maxWeight: 1.5,
-    lookbackPeriod: 30 * 24 * 60 * 60 * 1000,
-    successThreshold: 0.6,
-};
-export const DEFAULT_CONFIDENCE_CONFIG = {
-    expertiseMultiplier: 1.0,
-    confidenceMultiplier: 1.0,
-    minConfidenceThreshold: 0.3,
-    normalizeScores: true,
-};
-export class WeightedVotingAggregator {
-    historicalConfig;
-    confidenceConfig;
-    agentPerformance;
-    constructor(historicalConfig = {}, confidenceConfig = {}) {
-        this.historicalConfig = { ...DEFAULT_HISTORICAL_CONFIG, ...historicalConfig };
-        this.confidenceConfig = { ...DEFAULT_CONFIDENCE_CONFIG, ...confidenceConfig };
-        this.agentPerformance = new Map();
-    }
-    calculateExpertiseWeight(agentName) {
-        const expertiseLevel = getAgentExpertiseLevel(agentName);
-        const baseWeight = getVotingWeight(agentName);
-        return baseWeight * (expertiseLevel / 10);
-    }
-    calculateConfidenceWeight(agentName, voteConfidence) {
-        if (voteConfidence < this.confidenceConfig.minConfidenceThreshold) {
-            return 0;
-        }
-        const expertiseLevel = getAgentExpertiseLevel(agentName);
-        const expertiseBonus = (expertiseLevel / 10) * this.confidenceConfig.expertiseMultiplier;
-        const confidenceImpact = voteConfidence * this.confidenceConfig.confidenceMultiplier;
-        return expertiseBonus * confidenceImpact;
-    }
-    calculateHistoricalWeight(agentName) {
-        const performance = this.agentPerformance.get(agentName);
-        if (!performance) {
-            return 1.0;
-        }
-        const { totalVotes, correctVotes, weightedScore, lastActivity } = performance;
-        const daysSinceActive = (Date.now() - lastActivity) / (24 * 60 * 60 * 1000);
-        const decay = Math.pow(this.historicalConfig.decayFactor, daysSinceActive);
-        const successRate = totalVotes > 0 ? correctVotes / totalVotes : 0.5;
-        const minSuccess = this.historicalConfig.successThreshold;
-        let historicalWeight;
-        if (successRate >= minSuccess) {
-            historicalWeight = 1 + (successRate - minSuccess) * 0.5;
-        }
-        else {
-            historicalWeight = 0.5 + (successRate / minSuccess) * 0.5;
-        }
-        historicalWeight *= decay;
-        historicalWeight *= (weightedScore / 100);
-        return Math.max(this.historicalConfig.minWeight, Math.min(this.historicalConfig.maxWeight, historicalWeight));
-    }
-    calculateTotalVoteWeight(agentName, voteConfidence) {
-        const expertiseWeight = this.calculateExpertiseWeight(agentName);
-        const confidenceWeight = this.calculateConfidenceWeight(agentName, voteConfidence);
-        const historicalWeight = this.calculateHistoricalWeight(agentName);
-        return expertiseWeight * confidenceWeight * historicalWeight;
-    }
-    aggregateVotes(votes) {
-        const aggregated = new Map();
-        for (const vote of votes) {
-            const expertiseWeight = this.calculateExpertiseWeight(vote.agentName);
-            const confidenceWeight = this.calculateConfidenceWeight(vote.agentName, vote.confidence);
-            const historicalWeight = this.calculateHistoricalWeight(vote.agentName);
-            const totalWeight = expertiseWeight * confidenceWeight * historicalWeight;
-            const existing = aggregated.get(vote.vote);
-            if (existing) {
-                existing.baseWeight += expertiseWeight;
-                existing.confidenceWeight += confidenceWeight;
-                existing.historicalWeight += historicalWeight;
-                existing.totalWeight += totalWeight;
-                existing.contributingAgents.push(vote.agentName);
-            }
-            else {
-                aggregated.set(vote.vote, {
-                    option: vote.vote,
-                    baseWeight: expertiseWeight,
-                    expertiseWeight: expertiseWeight,
-                    confidenceWeight,
-                    historicalWeight,
-                    totalWeight,
-                    contributingAgents: [vote.agentName],
-                });
-            }
-        }
-        if (this.confidenceConfig.normalizeScores) {
-            const totalWeight = Array.from(aggregated.values()).reduce((sum, agg) => sum + agg.totalWeight, 0);
-            if (totalWeight > 0) {
-                for (const agg of aggregated.values()) {
-                    agg.totalWeight = agg.totalWeight / totalWeight;
-                }
-            }
-        }
-        return Array.from(aggregated.values()).sort((a, b) => b.totalWeight - a.totalWeight);
-    }
-    updateAgentPerformance(agentName, decision, votedFor, wasCorrect, confidence) {
-        let performance = this.agentPerformance.get(agentName);
-        if (!performance) {
-            performance = {
-                agentName,
-                totalVotes: 0,
-                correctVotes: 0,
-                averageConfidence: 0,
-                weightedScore: 50,
-                lastActivity: Date.now(),
-                streakCount: 0,
-                domainPerformance: {},
-            };
-            this.agentPerformance.set(agentName, performance);
-        }
-        performance.totalVotes++;
-        performance.lastActivity = Date.now();
-        if (wasCorrect) {
-            performance.correctVotes++;
-            performance.streakCount++;
-        }
-        else {
-            performance.streakCount = 0;
-        }
-        const newAvg = (performance.averageConfidence * (performance.totalVotes - 1) + confidence) /
-            performance.totalVotes;
-        performance.averageConfidence = newAvg;
-        const successRate = performance.correctVotes / performance.totalVotes;
-        const confidenceFactor = newAvg;
-        const streakBonus = Math.min(performance.streakCount * 0.05, 0.2);
-        performance.weightedScore = Math.max(0, Math.min(100, successRate * 50 + confidenceFactor * 30 + streakBonus * 20 + 20));
-        frameworkLogger.log("WeightedVotingAggregator", "agent-performance-updated", "debug", {
-            agentName,
-            totalVotes: performance.totalVotes,
-            correctVotes: performance.correctVotes,
-            successRate: successRate.toFixed(2),
-            weightedScore: performance.weightedScore.toFixed(2),
-        });
-    }
-    getAgentPerformance(agentName) {
-        return this.agentPerformance.get(agentName);
-    }
-    getAllPerformance() {
-        return Array.from(this.agentPerformance.values());
-    }
-    loadPerformance(performance) {
-        this.agentPerformance = new Map(performance);
-    }
-    reset() {
-        this.agentPerformance.clear();
-    }
-}
-export const createWeightedVotingAggregator = (historicalConfig, confidenceConfig) => {
-    return new WeightedVotingAggregator(historicalConfig, confidenceConfig);
-};
-export function createDetailedVotingResult(votes, aggregator) {
-    const aggregated = aggregator.aggregateVotes(votes);
-    const winner = aggregated[0] ?? null;
-    let confidence = 0;
-    if (winner && aggregated.length > 1) {
-        const secondPlace = aggregated[1];
-        if (secondPlace) {
-            const total = winner.totalWeight + secondPlace.totalWeight;
-            confidence = total > 0 ? winner.totalWeight / total : 0;
-        }
-        else {
-            confidence = 1;
-        }
-    }
-    else if (winner) {
-        confidence = 1;
-    }
-    const details = votes.map((vote) => ({
-        agentName: vote.agentName,
-        expertiseLevel: getAgentExpertiseLevel(vote.agentName),
-        vote: vote.vote,
-        weight: aggregator.calculateTotalVoteWeight(vote.agentName, vote.confidence),
-        contributed: vote.vote === winner?.option,
-    }));
-    return { aggregated, winner, confidence, details };
-}

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

@@ -1,14 +0,0 @@
-/**
- * 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/index.js

@@ -1,18 +0,0 @@
-/**
- * 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
- */
-// Rule storage and management
-export { RuleRegistry } from './rule-registry.js';
-// Rule dependency management
-export { RuleHierarchy } from './rule-hierarchy.js';
-// Validation execution orchestration
-export { RuleExecutor } from './rule-executor.js';
-// Violation fix delegation
-export { ViolationFixer } from './violation-fixer.js';

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

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