0xray 2.0.0

package/dist/delegation/agent-expertise.js

@@ -0,0 +1,156 @@
+/**
+ * Agent Expertise Configuration
+ *
+ * Defines expertise levels for weighted voting across all 0xRay agents.
+ * Higher expertise = higher weight in voting decisions.
+ *
+ * @version 1.0.0
+ * @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.js

@@ -0,0 +1,12 @@
+/**
+ * Analytics Module Index
+ *
+ * Barrel export for all analytics components.
+ * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
+ *
+ * @version 1.0.0
+ * @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.js

@@ -0,0 +1,277 @@
+/**
+ * Learning Engine
+ *
+ * P9 learning system - analyzes patterns, detects drift, and improves routing.
+ * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
+ *
+ * @version 1.0.0
+ * @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);