0xray 4.0.12 → 4.0.13

package/dist/delegation/agent-expertise.d.ts

@@ -1,15 +0,0 @@
-/**
- * Agent Expertise Configuration
- *
- * Defines expertise levels for weighted voting across all 0xRay agents.
- * Higher expertise = higher weight in voting decisions.
- *
- * @since 2026-04-16
- */
-import type { AgentExpertise } from "./voting-types.js";
-export declare const AGENT_EXPERTISE_LEVELS: Record<string, AgentExpertise>;
-export declare function getAgentExpertise(agentName: string): AgentExpertise | undefined;
-export declare function getAgentExpertiseLevel(agentName: string): number;
-export declare function getVotingWeight(agentName: string): number;
-export declare function getAgentsWithExpertiseDomain(domain: string): AgentExpertise[];
-export declare function getTopExpertsForDomain(domain: string, count?: number): AgentExpertise[];

package/dist/delegation/agent-expertise.js

@@ -1,155 +0,0 @@
-/**
- * Agent Expertise Configuration
- *
- * Defines expertise levels for weighted voting across all 0xRay agents.
- * Higher expertise = higher weight in voting decisions.
- *
- * @since 2026-04-16
- */
-export const AGENT_EXPERTISE_LEVELS = {
-    architect: {
-        name: "architect",
-        expertiseLevel: 10,
-        domain: "system design",
-        specialties: ["design", "planning", "architecture"],
-    },
-    "security-auditor": {
-        name: "security-auditor",
-        expertiseLevel: 10,
-        domain: "security",
-        specialties: ["security", "audit", "vulnerability-detection"],
-    },
-    strategist: {
-        name: "strategist",
-        expertiseLevel: 9,
-        domain: "strategy",
-        specialties: ["planning", "roadmap", "decision-making"],
-    },
-    refactorer: {
-        name: "refactorer",
-        expertiseLevel: 8,
-        domain: "refactoring",
-        specialties: ["optimization", "technical-debt", "consolidation"],
-    },
-    "testing-lead": {
-        name: "testing-lead",
-        expertiseLevel: 8,
-        domain: "testing",
-        specialties: ["test-architecture", "coverage", "quality"],
-    },
-    "code-reviewer": {
-        name: "code-reviewer",
-        expertiseLevel: 8,
-        domain: "review",
-        specialties: ["quality", "standards", "best-practices"],
-    },
-    "bug-triage-specialist": {
-        name: "bug-triage-specialist",
-        expertiseLevel: 7,
-        domain: "debugging",
-        specialties: ["bug-detection", "root-cause", "surgical-fixes"],
-    },
-    "database-engineer": {
-        name: "database-engineer",
-        expertiseLevel: 8,
-        domain: "database",
-        specialties: ["schema", "query-optimization", "migrations"],
-    },
-    "backend-engineer": {
-        name: "backend-engineer",
-        expertiseLevel: 7,
-        domain: "backend",
-        specialties: ["api", "server", "microservices"],
-    },
-    "frontend-engineer": {
-        name: "frontend-engineer",
-        expertiseLevel: 7,
-        domain: "frontend",
-        specialties: ["ui", "react", "responsive"],
-    },
-    "frontend-ui-ux-engineer": {
-        name: "frontend-ui-ux-engineer",
-        expertiseLevel: 8,
-        domain: "ui-ux",
-        specialties: ["design", "accessibility", "user-experience"],
-    },
-    "devops-engineer": {
-        name: "devops-engineer",
-        expertiseLevel: 7,
-        domain: "devops",
-        specialties: ["ci-cd", "infrastructure", "deployment"],
-    },
-    researcher: {
-        name: "researcher",
-        expertiseLevel: 6,
-        domain: "research",
-        specialties: ["search", "documentation", "patterns"],
-    },
-    "code-analyzer": {
-        name: "code-analyzer",
-        expertiseLevel: 7,
-        domain: "analysis",
-        specialties: ["metrics", "patterns", "static-analysis"],
-    },
-    "performance-engineer": {
-        name: "performance-engineer",
-        expertiseLevel: 8,
-        domain: "performance",
-        specialties: ["profiling", "optimization", "benchmarking"],
-    },
-    "log-monitor": {
-        name: "log-monitor",
-        expertiseLevel: 5,
-        domain: "monitoring",
-        specialties: ["logs", "alerts", "pattern-detection"],
-    },
-    "content-creator": {
-        name: "content-creator",
-        expertiseLevel: 5,
-        domain: "content",
-        specialties: ["writing", "seo", "marketing"],
-    },
-    "growth-strategist": {
-        name: "growth-strategist",
-        expertiseLevel: 7,
-        domain: "growth",
-        specialties: ["marketing", "conversion", "analysis"],
-    },
-    "seo-consultant": {
-        name: "seo-consultant",
-        expertiseLevel: 7,
-        domain: "seo",
-        specialties: ["search-optimization", "schema", "performance"],
-    },
-    "mobile-developer": {
-        name: "mobile-developer",
-        expertiseLevel: 6,
-        domain: "mobile",
-        specialties: ["ios", "android", "react-native"],
-    },
-    "tech-writer": {
-        name: "tech-writer",
-        expertiseLevel: 6,
-        domain: "documentation",
-        specialties: ["docs", "readme", "api-docs"],
-    },
-};
-export function getAgentExpertise(agentName) {
-    return AGENT_EXPERTISE_LEVELS[agentName];
-}
-export function getAgentExpertiseLevel(agentName) {
-    return AGENT_EXPERTISE_LEVELS[agentName]?.expertiseLevel ?? 5;
-}
-export function getVotingWeight(agentName) {
-    const level = getAgentExpertiseLevel(agentName);
-    return level * 10;
-}
-export function getAgentsWithExpertiseDomain(domain) {
-    return Object.values(AGENT_EXPERTISE_LEVELS).filter((agent) => agent.domain === domain || agent.specialties.some((s) => domain.includes(s)));
-}
-export function getTopExpertsForDomain(domain, count = 3) {
-    const domainExperts = getAgentsWithExpertiseDomain(domain);
-    return domainExperts
-        .sort((a, b) => b.expertiseLevel - a.expertiseLevel)
-        .slice(0, count);
-}

package/dist/delegation/analytics/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Analytics Module Index
- *
- * Barrel export for all analytics components.
- * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
- *
- * @since 2026-03-12
- */
-export { RoutingOutcomeTracker, routingOutcomeTracker } from './outcome-tracker.js';
-export { RoutingAnalytics } from './routing-analytics.js';
-export { LearningEngine, learningEngine } from './learning-engine.js';

package/dist/delegation/analytics/index.js

@@ -1,11 +0,0 @@
-/**
- * Analytics Module Index
- *
- * Barrel export for all analytics components.
- * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
- *
- * @since 2026-03-12
- */
-export { RoutingOutcomeTracker, routingOutcomeTracker } from './outcome-tracker.js';
-export { RoutingAnalytics } from './routing-analytics.js';
-export { LearningEngine, learningEngine } from './learning-engine.js';

package/dist/delegation/analytics/learning-engine.d.ts

@@ -1,84 +0,0 @@
-/**
- * Learning Engine
- *
- * P9 learning system - analyzes patterns, detects drift, and improves routing.
- * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
- *
- * @since 2026-03-12
- */
-import { P9LearningStats, PatternDriftAnalysis, LearningResult, AdaptiveThresholds } from '../config/types.js';
-/**
- * LearningEngine class
- *
- * Active implementation for P9 learning capabilities:
- * - Pattern drift detection
- * - Automatic routing refinement
- * - Success rate learning
- * - Adaptive confidence thresholds
- */
-export declare class LearningEngine {
-    private enabled;
-    private learningHistory;
-    constructor(enabled?: boolean);
-    /**
-     * Get P9 learning statistics
-     */
-    getP9LearningStats(): P9LearningStats;
-    /**
-     * Calculate overall success rate from outcome tracker
-     */
-    private calculateOverallSuccessRate;
-    /**
-     * Get pattern drift analysis from performance tracker
-     */
-    getPatternDriftAnalysis(): PatternDriftAnalysis;
-    /**
-     * Get adaptive thresholds based on learned data
-     */
-    getAdaptiveThresholds(): AdaptiveThresholds;
-    /**
-     * Trigger P9 learning process
-     */
-    triggerLearning(): Promise<LearningResult>;
-    /**
-     * Enable or disable learning
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * Check if learning is enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Get learning history
-     */
-    getLearningHistory(): Array<{
-        timestamp: Date;
-        patternsAnalyzed: number;
-        adaptations: number;
-        successRate: number;
-    }>;
-    /**
-     * Clear learning history
-     */
-    clearHistory(): void;
-    /**
-     * Analyze a specific pattern for optimization opportunities
-     */
-    analyzePattern(patternId: string): {
-        optimized: boolean;
-        recommendations: string[];
-        confidence: number;
-    };
-    /**
-     * Suggest routing improvements based on learning
-     */
-    suggestImprovements(): Array<{
-        type: 'mapping' | 'threshold' | 'confidence';
-        description: string;
-        impact: 'low' | 'medium' | 'high';
-    }>;
-}
-/**
- * Global learning engine instance (enabled by default)
- */
-export declare const learningEngine: LearningEngine;

package/dist/delegation/analytics/learning-engine.js

@@ -1,276 +0,0 @@
-/**
- * Learning Engine
- *
- * P9 learning system - analyzes patterns, detects drift, and improves routing.
- * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
- *
- * @since 2026-03-12
- */
-import { patternPerformanceTracker } from '../../analytics/pattern-performance-tracker.js';
-import { routingOutcomeTracker } from './outcome-tracker.js';
-import { frameworkLogger } from '../../core/framework-logger.js';
-/**
- * LearningEngine class
- *
- * Active implementation for P9 learning capabilities:
- * - Pattern drift detection
- * - Automatic routing refinement
- * - Success rate learning
- * - Adaptive confidence thresholds
- */
-export class LearningEngine {
-    enabled;
-    learningHistory = [];
-    constructor(enabled = true) {
-        this.enabled = enabled;
-    }
-    /**
-     * Get P9 learning statistics
-     */
-    getP9LearningStats() {
-        const totalLearnings = this.learningHistory.length;
-        const avgLearningTime = totalLearnings > 0
-            ? this.learningHistory.reduce((sum, h) => sum + (h.patternsAnalyzed || 0), 0) /
-                totalLearnings
-            : 0;
-        const lastHistory = this.learningHistory[totalLearnings - 1];
-        return {
-            totalLearnings,
-            successRate: this.calculateOverallSuccessRate(),
-            lastLearning: lastHistory?.timestamp ?? null,
-            averageLearningTime: avgLearningTime,
-            enabled: this.enabled,
-        };
-    }
-    /**
-     * Calculate overall success rate from outcome tracker
-     */
-    calculateOverallSuccessRate() {
-        try {
-            const outcomes = routingOutcomeTracker.getOutcomes();
-            if (outcomes.length === 0)
-                return 1.0;
-            const successes = outcomes.filter((o) => o.success).length;
-            return successes / outcomes.length;
-        }
-        catch {
-            return 1.0;
-        }
-    }
-    /**
-     * Get pattern drift analysis from performance tracker
-     */
-    getPatternDriftAnalysis() {
-        if (!this.enabled) {
-            return {
-                driftDetected: false,
-                affectedPatterns: [],
-                severity: 'low',
-            };
-        }
-        try {
-            const driftAnalyses = patternPerformanceTracker.getAllDriftAnalyses();
-            const significantDrift = driftAnalyses.filter((a) => a.drifted);
-            return {
-                driftDetected: significantDrift.length > 0,
-                affectedPatterns: significantDrift.map((a) => a.patternId),
-                severity: significantDrift.length > 5 ? 'high' : significantDrift.length > 0 ? 'medium' : 'low',
-            };
-        }
-        catch {
-            return {
-                driftDetected: false,
-                affectedPatterns: [],
-                severity: 'low',
-            };
-        }
-    }
-    /**
-     * Get adaptive thresholds based on learned data
-     */
-    getAdaptiveThresholds() {
-        if (!this.enabled) {
-            return {
-                overall: {
-                    confidenceMin: 0.7,
-                    confidenceMax: 0.95,
-                    frequencyMin: 5,
-                    frequencyMax: 100,
-                },
-            };
-        }
-        try {
-            return patternPerformanceTracker.calculateAdaptiveThresholds();
-        }
-        catch {
-            return {
-                overall: {
-                    confidenceMin: 0.7,
-                    confidenceMax: 0.95,
-                    frequencyMin: 5,
-                    frequencyMax: 100,
-                },
-            };
-        }
-    }
-    /**
-     * Trigger P9 learning process
-     */
-    async triggerLearning() {
-        if (!this.enabled) {
-            return {
-                learningStarted: false,
-                patternsAnalyzed: 0,
-                adaptations: 0,
-            };
-        }
-        try {
-            // Import dependencies
-            const { routingOutcomeTracker } = await import('./outcome-tracker.js');
-            const { patternPerformanceTracker } = await import('../../analytics/pattern-performance-tracker.js');
-            const { emergingPatternDetector } = await import('../../analytics/emerging-pattern-detector.js');
-            const { patternLearningEngine } = await import('../../analytics/pattern-learning-engine.js');
-            // Reload fresh data from disk
-            routingOutcomeTracker.reloadFromDisk();
-            const outcomes = routingOutcomeTracker.getOutcomes();
-            const patternMetrics = patternPerformanceTracker.getAllPatternMetrics();
-            // Detect emerging patterns
-            const emergentResult = emergingPatternDetector.detectEmergingPatterns(outcomes.map((o) => ({
-                taskId: o.taskId,
-                taskDescription: o.taskDescription || o.taskId,
-                routedAgent: o.routedAgent,
-                routedSkill: o.routedSkill,
-                confidence: o.confidence,
-                timestamp: new Date(o.timestamp),
-                success: o.success ?? false
-            })));
-            // Learn from data - filter outcomes with success defined and cast type
-            const existingMappings = [];
-            const validOutcomes = outcomes
-                .filter((o) => o.success !== undefined)
-                .map((o) => ({
-                taskId: o.taskId,
-                taskDescription: o.taskDescription || o.taskId,
-                routedAgent: o.routedAgent,
-                routedSkill: o.routedSkill,
-                confidence: o.confidence,
-                success: o.success
-            }));
-            const learningResult = patternLearningEngine.learnFromData(validOutcomes, existingMappings);
-            const patternsAnalyzed = patternMetrics.length + emergentResult.emergentPatterns.length;
-            const adaptations = learningResult.newPatterns.length +
-                learningResult.modifiedPatterns.length +
-                learningResult.removedPatterns.length;
-            // Record in history
-            this.learningHistory.push({
-                timestamp: new Date(),
-                patternsAnalyzed,
-                adaptations,
-                successRate: this.calculateOverallSuccessRate(),
-            });
-            return {
-                learningStarted: true,
-                patternsAnalyzed,
-                adaptations,
-            };
-        }
-        catch (error) {
-            frameworkLogger.log("LearningEngine", "start-learning", "error", { error, message: 'Learning engine error:' });
-            return {
-                learningStarted: false,
-                patternsAnalyzed: 0,
-                adaptations: 0,
-            };
-        }
-    }
-    /**
-     * Enable or disable learning
-     */
-    setEnabled(enabled) {
-        this.enabled = enabled;
-    }
-    /**
-     * Check if learning is enabled
-     */
-    isEnabled() {
-        return this.enabled;
-    }
-    /**
-     * Get learning history
-     */
-    getLearningHistory() {
-        return [...this.learningHistory];
-    }
-    /**
-     * Clear learning history
-     */
-    clearHistory() {
-        this.learningHistory = [];
-    }
-    /**
-     * Analyze a specific pattern for optimization opportunities
-     */
-    analyzePattern(patternId) {
-        try {
-            const metrics = patternPerformanceTracker.getPatternMetrics(patternId);
-            if (!metrics) {
-                return { optimized: false, recommendations: ['Pattern not found'], confidence: 0 };
-            }
-            const recommendations = [];
-            if (metrics.successRate < 0.7) {
-                recommendations.push('Low success rate - consider adjusting confidence threshold');
-            }
-            if (metrics.totalUsages > 20 && metrics.successRate < 0.5) {
-                recommendations.push('Pattern consistently underperforming - consider removal');
-            }
-            if (metrics.avgConfidence < 0.6) {
-                recommendations.push('Low average confidence - verify keyword mapping');
-            }
-            return {
-                optimized: recommendations.length === 0,
-                recommendations,
-                confidence: Math.min(1, metrics.totalUsages / 30),
-            };
-        }
-        catch {
-            return { optimized: false, recommendations: [], confidence: 0.5 };
-        }
-    }
-    /**
-     * Suggest routing improvements based on learning
-     */
-    suggestImprovements() {
-        const suggestions = [];
-        if (!this.enabled)
-            return suggestions;
-        try {
-            const metrics = patternPerformanceTracker.getAllPatternMetrics();
-            for (const metric of metrics) {
-                if (metric.totalUsages < 5)
-                    continue;
-                if (metric.successRate < 0.6 && metric.totalUsages >= 10) {
-                    suggestions.push({
-                        type: 'mapping',
-                        description: `Pattern ${metric.patternId} has low success rate (${(metric.successRate * 100).toFixed(0)}%)`,
-                        impact: metric.totalUsages > 20 ? 'high' : 'medium',
-                    });
-                }
-                if (metric.avgConfidence < 0.5) {
-                    suggestions.push({
-                        type: 'confidence',
-                        description: `Pattern ${metric.patternId} has low confidence (${(metric.avgConfidence * 100).toFixed(0)}%)`,
-                        impact: 'medium',
-                    });
-                }
-            }
-        }
-        catch {
-            // Silent fail
-        }
-        return suggestions;
-    }
-}
-/**
- * Global learning engine instance (enabled by default)
- */
-export const learningEngine = new LearningEngine(true);

package/dist/delegation/analytics/outcome-tracker.d.ts

@@ -1,117 +0,0 @@
-/**
- * Routing Outcome Tracker
- *
- * Tracks routing outcomes and provides statistics for performance analysis.
- * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
- *
- * @since 2026-03-12
- */
-import { RoutingOutcome, AgentStats, PromptDataPoint, RoutingDecision } from '../config/types.js';
-/**
- * RoutingOutcomeTracker class
- *
- * Tracks routing outcomes with circular buffer pattern for memory efficiency.
- * Provides methods for recording outcomes, calculating statistics, and
- * retrieving data for analytics.
- *
- * Persists outcomes to logs/framework/routing-outcomes.json for analytics to read.
- */
-export declare class RoutingOutcomeTracker {
-    private outcomes;
-    private readonly maxOutcomes;
-    private readonly persistencePath;
-    private saveTimeout;
-    private readonly SAVE_DEBOUNCE_MS;
-    /**
-     * Create a new outcome tracker
-     * @param maxOutcomes Maximum number of outcomes to retain (default: 1000)
-     */
-    constructor(maxOutcomes?: number);
-    /**
-     * Ensure the log directory and file exist on initialization
-     */
-    private initializeFile;
-    /**
-     * Load outcomes from disk on initialization
-     */
-    private loadFromDisk;
-    /**
-     * Save outcomes to disk (debounced)
-     */
-    private scheduleSave;
-    /**
-     * Immediately save to disk (synchronous for reliability)
-     */
-    private saveToDisk;
-    /**
-     * Record a new routing outcome
-     * @param outcome The outcome to record (timestamp will be added)
-     */
-    recordOutcome(outcome: Omit<RoutingOutcome, 'timestamp'>): void;
-    /**
-     * Update an existing outcome by taskId
-     * @param taskId The task ID to update
-     * @param updates The fields to update
-     * @returns true if updated, false if not found
-     */
-    updateOutcome(taskId: string, updates: Partial<RoutingOutcome>): boolean;
-    /**
-     * Force reload from disk - call this before analytics to get latest data
-     */
-    reloadFromDisk(): Promise<void>;
-    /**
-     * Get all outcomes, optionally filtered by agent
-     * @param agent Optional agent name to filter by
-     * @returns Array of routing outcomes
-     */
-    getOutcomes(agent?: string): RoutingOutcome[];
-    /**
-     * Calculate success rate for a specific agent
-     * @param agent The agent name
-     * @returns Success rate between 0 and 1
-     */
-    getSuccessRate(agent: string): number;
-    /**
-     * Get statistics for all agents
-     * @returns Array of agent statistics
-     */
-    getStats(): AgentStats[];
-    /**
-     * Clear all recorded outcomes
-     */
-    clear(): void;
-    /**
-     * Get the count of recorded outcomes
-     * @returns Number of outcomes
-     */
-    getCount(): number;
-    /**
-     * Export outcomes to JSON string
-     * @returns JSON string of all outcomes
-     */
-    toJSON(): string;
-    /**
-     * Convert outcomes to prompt data points for pattern analysis
-     * @returns Array of prompt data points
-     */
-    getPromptData(): PromptDataPoint[];
-    /**
-     * Convert outcomes to routing decisions
-     * @returns Array of routing decisions
-     */
-    getRoutingDecisions(): RoutingDecision[];
-    /**
-     * Apply routing refinements to existing outcomes
-     * @param changes Array of changes to apply
-     */
-    applyRoutingRefinements(changes: Array<{
-        taskId: string;
-        agent?: string;
-        skill?: string;
-        confidence?: number;
-    }>): void;
-}
-/**
- * Global routing outcome tracker instance
- */
-export declare const routingOutcomeTracker: RoutingOutcomeTracker;