0xray 2.0.0

package/dist/analytics/routing-refiner.js

@@ -0,0 +1,380 @@
+/**
+ * Routing Refiner for 0xRay
+ *
+ * Suggests new keyword mappings, optimizes existing mappings, and generates
+ * configuration updates based on analytics data from the routing system.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import { promptPatternAnalyzer, } from "./prompt-pattern-analyzer.js";
+import { routingPerformanceAnalyzer } from "./routing-performance-analyzer.js";
+class RoutingRefiner {
+    minSamplesForSuggestion = 5;
+    minSuccessRateForSuggestion = 0.7;
+    minConfidenceForSuggestion = 0.7;
+    /**
+     * Generate comprehensive routing refinement recommendations
+     */
+    generateRefinementReport() {
+        const promptAnalysis = promptPatternAnalyzer.analyzePromptPatterns();
+        const performanceReport = routingPerformanceAnalyzer.generatePerformanceReport();
+        const configurationUpdate = this.generateConfigurationUpdate(promptAnalysis, performanceReport);
+        const implementationSteps = this.generateImplementationSteps(configurationUpdate);
+        return {
+            promptAnalysis,
+            performanceReport,
+            configurationUpdate,
+            implementationSteps,
+        };
+    }
+    /**
+     * Generate configuration update suggestions
+     */
+    generateConfigurationUpdate(promptAnalysis, performanceReport) {
+        const newMappings = this.suggestNewKeywordMappings(promptAnalysis, performanceReport);
+        const optimizations = this.suggestMappingOptimizations(promptAnalysis, performanceReport);
+        const warnings = this.generateWarnings(newMappings, optimizations);
+        return {
+            version: "1.22.67",
+            generatedAt: new Date(),
+            summary: {
+                newMappings: newMappings.length,
+                optimizedMappings: optimizations.length,
+                removedMappings: this.calculateRemovals(optimizations),
+                estimatedImprovement: this.estimateImprovement(newMappings, optimizations),
+            },
+            newMappings,
+            optimizations,
+            warnings,
+        };
+    }
+    /**
+     * Suggest new keyword mappings based on analysis
+     */
+    suggestNewKeywordMappings(promptAnalysis, performanceReport) {
+        const suggestions = [];
+        for (const pattern of promptAnalysis.emergingPatterns) {
+            if (pattern.frequency >= this.minSamplesForSuggestion &&
+                pattern.successRate >= this.minSuccessRateForSuggestion &&
+                pattern.avgConfidence >= this.minConfidenceForSuggestion) {
+                const topKeywords = pattern.keywords.slice(0, 3);
+                for (const keyword of topKeywords) {
+                    suggestions.push({
+                        keyword,
+                        targetAgent: pattern.suggestedAgent,
+                        targetSkill: pattern.suggestedSkill,
+                        suggestedConfidence: Math.min(pattern.avgConfidence + 0.05, 0.95),
+                        reason: `Emerging pattern detected in ${pattern.frequency} requests with ${(pattern.successRate * 100).toFixed(1)}% success rate`,
+                        evidence: {
+                            frequency: pattern.frequency,
+                            successRate: pattern.successRate,
+                            avgConfidence: pattern.avgConfidence,
+                            sampleRequests: pattern.sampleRequests,
+                        },
+                        priority: this.calculatePriority(pattern.avgConfidence, pattern.successRate, pattern.frequency),
+                    });
+                }
+            }
+        }
+        for (const gap of promptAnalysis.gaps) {
+            if (gap.frequency >= this.minSamplesForSuggestion &&
+                gap.confidence >= this.minConfidenceForSuggestion) {
+                const keywords = this.extractKeywords(gap.userRequest);
+                for (const keyword of keywords) {
+                    if (keyword.length > 3) {
+                        suggestions.push({
+                            keyword,
+                            targetAgent: gap.suggestedAgent,
+                            targetSkill: gap.suggestedSkill,
+                            suggestedConfidence: Math.min(gap.confidence + 0.05, 0.95),
+                            reason: `Template gap detected - ${gap.frequency} recurring requests without template match`,
+                            evidence: {
+                                frequency: gap.frequency,
+                                successRate: 0.8,
+                                avgConfidence: gap.confidence,
+                                sampleRequests: [gap.userRequest],
+                            },
+                            priority: this.calculatePriority(gap.confidence, 0.8, gap.frequency),
+                        });
+                    }
+                }
+            }
+        }
+        for (const missedKeyword of promptAnalysis.topMissedKeywords.slice(0, 15)) {
+            if (missedKeyword.count >= this.minSamplesForSuggestion &&
+                missedKeyword.suggestedMappings.length > 0) {
+                const targetAgent = this.selectBestAgentForMapping(missedKeyword.suggestedMappings, performanceReport.agentMetrics);
+                suggestions.push({
+                    keyword: missedKeyword.keyword,
+                    targetAgent,
+                    targetSkill: "code-review",
+                    suggestedConfidence: 0.8,
+                    reason: `Keyword appears in ${missedKeyword.count} requests without template match`,
+                    evidence: {
+                        frequency: missedKeyword.count,
+                        successRate: 0.75,
+                        avgConfidence: 0.75,
+                        sampleRequests: [],
+                    },
+                    priority: this.calculatePriority(0.75, 0.75, missedKeyword.count),
+                });
+            }
+        }
+        return this.deduplicateSuggestions(suggestions);
+    }
+    /**
+     * Suggest optimizations for existing mappings
+     */
+    suggestMappingOptimizations(promptAnalysis, performanceReport) {
+        const optimizations = [];
+        for (const keyword of performanceReport.keywordEffectiveness) {
+            if (keyword.successRate < 0.6 && keyword.totalMatches >= 10) {
+                optimizations.push({
+                    mappingId: `keyword-${keyword.keyword}`,
+                    currentKeywords: [keyword.keyword],
+                    currentAgent: keyword.routedAgent,
+                    currentSkill: keyword.routedSkill,
+                    optimizationType: "remove_keywords",
+                    suggestedChanges: {
+                        keywordsToRemove: [keyword.keyword],
+                    },
+                    reason: `Low success rate (${(keyword.successRate * 100).toFixed(1)}%) for keyword "${keyword.keyword}"`,
+                    expectedImpact: `Reduce misroutings by approximately ${keyword.failedMatches} instances`,
+                });
+            }
+        }
+        for (const agent of performanceReport.agentMetrics) {
+            if (agent.successRate < 0.7 &&
+                agent.totalRoutings >= 20 &&
+                agent.escalatedRoutings > agent.totalRoutings * 0.3) {
+                optimizations.push({
+                    mappingId: `agent-${agent.agent}`,
+                    currentKeywords: [],
+                    currentAgent: agent.agent,
+                    currentSkill: agent.skill,
+                    optimizationType: "adjust_confidence",
+                    suggestedChanges: {
+                        newConfidence: agent.avgConfidence - 0.1,
+                    },
+                    reason: `Agent ${agent.agent} showing poor performance with high escalation rate`,
+                    expectedImpact: `Improve routing accuracy by redirecting tasks to more suitable agents`,
+                });
+            }
+        }
+        for (const pattern of promptAnalysis.emergingPatterns) {
+            if (pattern.successRate >= 0.9 &&
+                pattern.frequency >= 10 &&
+                pattern.avgConfidence < 0.85) {
+                optimizations.push({
+                    mappingId: `pattern-${pattern.patternId}`,
+                    currentKeywords: pattern.keywords,
+                    currentAgent: pattern.suggestedAgent,
+                    currentSkill: pattern.suggestedSkill,
+                    optimizationType: "adjust_confidence",
+                    suggestedChanges: {
+                        newConfidence: Math.min(pattern.avgConfidence + 0.1, 0.95),
+                    },
+                    reason: `Pattern "${pattern.patternId}" shows excellent performance but low confidence score`,
+                    expectedImpact: `Increase routing confidence for ${pattern.frequency} similar requests`,
+                });
+            }
+        }
+        return optimizations;
+    }
+    /**
+     * Generate warnings for configuration updates
+     */
+    generateWarnings(newMappings, optimizations) {
+        const warnings = [];
+        const lowPrioritySuggestions = newMappings.filter((m) => m.priority === "low");
+        if (lowPrioritySuggestions.length > newMappings.length * 0.5) {
+            warnings.push(`High proportion (${((lowPrioritySuggestions.length / newMappings.length) * 100).toFixed(1)}%) of suggestions are low priority - review carefully before applying`);
+        }
+        const agentConflictMap = new Map();
+        for (const mapping of newMappings) {
+            if (!agentConflictMap.has(mapping.keyword)) {
+                agentConflictMap.set(mapping.keyword, []);
+            }
+            agentConflictMap.get(mapping.keyword).push(mapping);
+        }
+        for (const [keyword, mappings] of agentConflictMap.entries()) {
+            const uniqueAgents = new Set(mappings.map((m) => m.targetAgent));
+            if (uniqueAgents.size > 1) {
+                warnings.push(`Keyword "${keyword}" suggested for multiple agents: ${Array.from(uniqueAgents).join(", ")}. Manual review required.`);
+            }
+        }
+        if (optimizations.length > 20) {
+            warnings.push("Large number of optimization suggestions - consider applying in batches");
+        }
+        return warnings;
+    }
+    /**
+     * Generate implementation steps
+     */
+    generateImplementationSteps(configurationUpdate) {
+        const steps = [];
+        if (configurationUpdate.newMappings.length > 0) {
+            steps.push(`1. Add ${configurationUpdate.newMappings.length} new keyword mappings`);
+            steps.push("   - Review high-priority suggestions first");
+            steps.push("   - Test new mappings in staging environment");
+            steps.push("   - Monitor impact on routing accuracy");
+        }
+        if (configurationUpdate.optimizations.length > 0) {
+            const stepNumber = configurationUpdate.newMappings.length > 0 ? 2 : 1;
+            steps.push(`${stepNumber}. Apply ${configurationUpdate.optimizations.length} mapping optimizations`);
+            steps.push("   - Backup current configuration before changes");
+            steps.push("   - Group optimizations by type (confidence adjustment, keyword removal, etc.)");
+            steps.push("   - Apply changes incrementally with testing between batches");
+        }
+        steps.push(`${(configurationUpdate.newMappings.length > 0 ? 3 : 2)}. Validate and deploy`);
+        steps.push("   - Run comprehensive routing tests");
+        steps.push("   - Monitor performance metrics for 24-48 hours");
+        steps.push("   - Roll back any changes that show negative impact");
+        steps.push(`${(configurationUpdate.newMappings.length > 0 ? 4 : 3)}. Continuous monitoring`);
+        steps.push("   - Review analytics dashboard weekly");
+        steps.push("   - Track success rate improvements");
+        steps.push("   - Iterate based on real-world usage data");
+        return steps;
+    }
+    /**
+     * Get formatted refinement report
+     */
+    generateFormattedReport() {
+        const report = this.generateRefinementReport();
+        const lines = [];
+        lines.push("╔════════════════════════════════════════════════════════════╗");
+        lines.push("║        0xRay Routing Refinement Report              ║");
+        lines.push("╚════════════════════════════════════════════════════════════╝");
+        lines.push("");
+        lines.push(`Generated: ${report.configurationUpdate.generatedAt.toISOString()}`);
+        lines.push(`Version: ${report.configurationUpdate.version}`);
+        lines.push("");
+        lines.push("=== Summary ===");
+        lines.push(`New Mappings: ${report.configurationUpdate.summary.newMappings}`);
+        lines.push(`Optimized Mappings: ${report.configurationUpdate.summary.optimizedMappings}`);
+        lines.push(`Removed Mappings: ${report.configurationUpdate.summary.removedMappings}`);
+        lines.push(`Estimated Improvement: ${report.configurationUpdate.summary.estimatedImprovement}`);
+        lines.push("");
+        if (report.configurationUpdate.newMappings.length > 0) {
+            lines.push("=== New Keyword Mappings ===");
+            for (const mapping of report.configurationUpdate.newMappings.slice(0, 20)) {
+                lines.push(`\n  Keyword: "${mapping.keyword}"`);
+                lines.push(`    Target: ${mapping.targetAgent}/${mapping.targetSkill}`);
+                lines.push(`    Confidence: ${mapping.suggestedConfidence.toFixed(2)}`);
+                lines.push(`    Priority: ${mapping.priority.toUpperCase()}`);
+                lines.push(`    Reason: ${mapping.reason}`);
+                lines.push(`    Evidence: ${mapping.evidence.frequency} occurrences, ${(mapping.evidence.successRate * 100).toFixed(1)}% success rate`);
+            }
+        }
+        if (report.configurationUpdate.optimizations.length > 0) {
+            lines.push("");
+            lines.push("=== Mapping Optimizations ===");
+            for (const optimization of report.configurationUpdate.optimizations.slice(0, 10)) {
+                lines.push(`\n  ${optimization.optimizationType.toUpperCase()}: ${optimization.mappingId}`);
+                lines.push(`    Current: ${optimization.currentAgent}/${optimization.currentSkill}`);
+                lines.push(`    Reason: ${optimization.reason}`);
+                lines.push(`    Expected Impact: ${optimization.expectedImpact}`);
+            }
+        }
+        if (report.configurationUpdate.warnings.length > 0) {
+            lines.push("");
+            lines.push("=== Warnings ===");
+            for (const warning of report.configurationUpdate.warnings) {
+                lines.push(`  ⚠️  ${warning}`);
+            }
+        }
+        lines.push("");
+        lines.push("=== Implementation Steps ===");
+        for (const step of report.implementationSteps) {
+            lines.push(`  ${step}`);
+        }
+        lines.push("");
+        lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+        lines.push("Generated by 0xRay Routing Refiner");
+        return lines.join("\n");
+    }
+    /**
+     * Export configuration update as JSON
+     */
+    exportConfigurationUpdate() {
+        const report = this.generateRefinementReport();
+        return JSON.stringify(report.configurationUpdate, null, 2);
+    }
+    calculatePriority(confidence, successRate, frequency) {
+        const score = confidence * 0.4 + successRate * 0.4 + (Math.min(frequency, 20) / 20) * 0.2;
+        if (score >= 0.85)
+            return "high";
+        if (score >= 0.7)
+            return "medium";
+        return "low";
+    }
+    extractKeywords(text) {
+        const words = text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, " ")
+            .split(/\s+/)
+            .filter((word) => word.length > 3);
+        const stopWords = new Set([
+            "this",
+            "that",
+            "with",
+            "from",
+            "have",
+            "will",
+            "just",
+            "like",
+            "they",
+            "them",
+            "than",
+            "then",
+            "some",
+            "such",
+        ]);
+        return words.filter((word) => !stopWords.has(word));
+    }
+    selectBestAgentForMapping(agents, agentMetrics) {
+        const agentPerformance = new Map(agentMetrics.map((m) => [m.agent, m.successRate]));
+        const sortedAgents = [...agents].sort((a, b) => {
+            const scoreA = agentPerformance.get(a) ?? 0;
+            const scoreB = agentPerformance.get(b) ?? 0;
+            return scoreB - scoreA;
+        });
+        return sortedAgents[0] ?? "code-reviewer";
+    }
+    deduplicateSuggestions(suggestions) {
+        const seen = new Map();
+        for (const suggestion of suggestions) {
+            const key = `${suggestion.keyword}-${suggestion.targetAgent}-${suggestion.targetSkill}`;
+            if (!seen.has(key)) {
+                seen.set(key, suggestion);
+            }
+            else {
+                const existing = seen.get(key);
+                if (suggestion.evidence.frequency > existing.evidence.frequency ||
+                    suggestion.evidence.successRate > existing.evidence.successRate) {
+                    seen.set(key, suggestion);
+                }
+            }
+        }
+        return Array.from(seen.values());
+    }
+    calculateRemovals(optimizations) {
+        return optimizations.filter((o) => o.optimizationType === "remove_keywords").length;
+    }
+    estimateImprovement(newMappings, optimizations) {
+        const highPriorityMappings = newMappings.filter((m) => m.priority === "high");
+        const confidenceAdjustments = optimizations.filter((o) => o.optimizationType === "adjust_confidence").length;
+        const estimatedAccuracyImprovement = (highPriorityMappings.length * 2) + (confidenceAdjustments * 1);
+        if (estimatedAccuracyImprovement > 15) {
+            return `${estimatedAccuracyImprovement}%+ (significant)`;
+        }
+        else if (estimatedAccuracyImprovement > 5) {
+            return `${estimatedAccuracyImprovement}%+ (moderate)`;
+        }
+        else {
+            return `${estimatedAccuracyImprovement}%+ (minor)`;
+        }
+    }
+}
+export const routingRefiner = new RoutingRefiner();

package/dist/analytics/simple-pattern-analyzer.js

@@ -0,0 +1,297 @@
+/**
+ * Simple Pattern Analyzer for 0xRay
+ *
+ * Reads activity log → Counts patterns → Generates insights
+ *
+ * This is the "learning" system - simple pattern matching, not ML.
+ *
+ * @version 1.0.0
+ */
+import * as fs from "fs";
+import * as path from "path";
+export class SimplePatternAnalyzer {
+    logPath;
+    outcomesPath;
+    constructor(logPath) {
+        const cwd = process.cwd();
+        this.logPath =
+            logPath || path.join(cwd, "logs", "framework", "activity.log");
+        // Only use outcomes path when using default log path
+        this.outcomesPath = logPath ? "" : path.join(cwd, "logs", "framework", "routing-outcomes.json");
+    }
+    /**
+     * Main analysis method - reads log and returns insights
+     */
+    async analyze(limit) {
+        const entries = [];
+        // Try to read from routing-outcomes.json first (has more complete data)
+        // Only when using default paths
+        if (this.outcomesPath && fs.existsSync(this.outcomesPath)) {
+            try {
+                const outcomes = JSON.parse(fs.readFileSync(this.outcomesPath, "utf-8"));
+                const outcomesToAnalyze = limit ? outcomes.slice(-limit) : outcomes;
+                for (const outcome of outcomesToAnalyze) {
+                    entries.push({
+                        timestamp: outcome.timestamp || new Date().toISOString(),
+                        jobId: outcome.taskId || "",
+                        component: outcome.routedAgent || "unknown",
+                        action: "routing-outcome",
+                        status: outcome.success ? "success" : "error",
+                        agentUsed: outcome.routedAgent,
+                        operationType: outcome.routedSkill,
+                        outcome: outcome.success ? "success" : "fail",
+                        complexityScore: outcome.complexity,
+                    });
+                }
+            }
+            catch {
+                // Fall back to activity log parsing
+            }
+        }
+        // Fall back to activity log parsing if no outcomes
+        if (entries.length === 0 && fs.existsSync(this.logPath)) {
+            const content = fs.readFileSync(this.logPath, "utf-8");
+            const lines = content.split("\n").filter((l) => l.trim());
+            // Filter to task completion entries
+            const completionLines = lines.filter((line) => line.includes("complex-task-completed") ||
+                line.includes("job-completed") ||
+                line.includes("task-completed"));
+            const entriesToAnalyze = limit ? completionLines.slice(-limit) : completionLines;
+            const parsedEntries = entriesToAnalyze
+                .map((line) => this.parseLine(line))
+                .filter((e) => e !== null);
+            entries.push(...parsedEntries);
+        }
+        if (entries.length === 0) {
+            return this.emptyInsights();
+        }
+        return this.calculateStats(entries);
+    }
+    /**
+     * Parse a single log line
+     */
+    parseLine(line) {
+        // Format: 2026-02-24T10:30:00.000Z [job-123-abc] [component] action - STATUS | {"details": "..."}
+        const match = line.match(/^(\d{4}-\d{2}-\d{2}T[\d:.]+Z)\s+\[([^\]]+)\]\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)(?:\s*\|\s*(.+))?$/);
+        if (!match) {
+            return null;
+        }
+        const [, timestamp, jobId, component, actionRaw, statusRaw, detailsRaw] = match;
+        // Parse action and any embedded details
+        const action = actionRaw?.trim() || "unknown";
+        const status = statusRaw?.toLowerCase() || "info";
+        // Parse JSON details if present
+        let details = {};
+        if (detailsRaw) {
+            try {
+                details = JSON.parse(detailsRaw.trim());
+            }
+            catch {
+                // Not JSON, ignore
+            }
+        }
+        return {
+            timestamp: timestamp || "",
+            jobId: jobId || "",
+            component: component || "unknown",
+            action,
+            status,
+            duration: details.duration,
+            complexityScore: details.complexityScore,
+            agentUsed: details.agentUsed || details.agent || details.taskType,
+            operationType: details.operationType || details.taskType,
+            outcome: details.outcome,
+            complexityAccuracy: details.complexityAccuracy,
+        };
+    }
+    /**
+     * Calculate statistics from parsed entries
+     */
+    calculateStats(entries) {
+        const agentStats = new Map();
+        const taskTypeStats = new Map();
+        const complexityStats = {
+            underestimated: 0,
+            accurate: 0,
+            overestimated: 0,
+            total: 0,
+        };
+        // Filter to entries with analytics data (task completions or routing outcomes)
+        const relevantEntries = entries.filter((e) => e.action === "job-completed" ||
+            e.action === "routing-outcome" ||
+            e.action.includes("completed") ||
+            e.outcome !== undefined);
+        for (const entry of relevantEntries) {
+            const agent = entry.agentUsed || entry.component || "unknown";
+            // Agent stats
+            if (!agentStats.has(agent)) {
+                agentStats.set(agent, {
+                    attempts: 0,
+                    successes: 0,
+                    failures: 0,
+                    escalated: 0,
+                    autoFixed: 0,
+                    avgDuration: 0,
+                    totalDuration: 0,
+                });
+            }
+            const stats = agentStats.get(agent);
+            stats.attempts++;
+            if (entry.duration) {
+                stats.totalDuration += entry.duration;
+                stats.avgDuration = stats.totalDuration / stats.attempts;
+            }
+            // Outcome tracking
+            const outcome = entry.outcome || (entry.status === "success" ? "success" : "fail");
+            switch (outcome) {
+                case "success":
+                    stats.successes++;
+                    break;
+                case "fail":
+                    stats.failures++;
+                    break;
+                case "escalated":
+                    stats.escalated++;
+                    break;
+                case "auto-fixed":
+                    stats.autoFixed++;
+                    break;
+            }
+            // Task type stats
+            const taskType = entry.operationType || "unknown";
+            if (!taskTypeStats.has(taskType)) {
+                taskTypeStats.set(taskType, {
+                    count: 0,
+                    successRate: 0,
+                    avgComplexity: 0,
+                });
+            }
+            const taskStat = taskTypeStats.get(taskType);
+            taskStat.count++;
+            if (entry.complexityScore) {
+                taskStat.avgComplexity =
+                    (taskStat.avgComplexity * (taskStat.count - 1) +
+                        entry.complexityScore) /
+                        taskStat.count;
+            }
+            // Complexity accuracy
+            if (entry.complexityAccuracy) {
+                complexityStats.total++;
+                switch (entry.complexityAccuracy) {
+                    case "underestimated":
+                        complexityStats.underestimated++;
+                        break;
+                    case "accurate":
+                        complexityStats.accurate++;
+                        break;
+                    case "overestimated":
+                        complexityStats.overestimated++;
+                        break;
+                }
+            }
+        }
+        // Calculate success rates
+        for (const [agent, stats] of agentStats) {
+            if (stats.attempts > 0) {
+                // We'll calculate in the output
+            }
+        }
+        for (const [taskType, stats] of taskTypeStats) {
+            const agentStatsForTask = Array.from(agentStats.values()).reduce((acc, s) => ({
+                attempts: acc.attempts + s.attempts,
+                successes: acc.successes + s.successes,
+            }), { attempts: 0, successes: 0 });
+            stats.successRate =
+                agentStatsForTask.attempts > 0
+                    ? (agentStatsForTask.successes / agentStatsForTask.attempts) * 100
+                    : 0;
+        }
+        const sortedEntries = [...entries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        return {
+            agentStats,
+            taskTypeStats,
+            complexityStats,
+            totalEntries: entries.length,
+            dateRange: {
+                start: sortedEntries[0]?.timestamp || "",
+                end: sortedEntries[sortedEntries.length - 1]?.timestamp || "",
+            },
+        };
+    }
+    /**
+     * Generate human-readable insights
+     */
+    generateInsights(insights) {
+        const output = [];
+        if (insights.totalEntries === 0) {
+            return ["No activity log entries found."];
+        }
+        // Agent performance
+        output.push("=== Agent Performance ===");
+        for (const [agent, stats] of insights.agentStats) {
+            const successRate = stats.attempts > 0
+                ? ((stats.successes / stats.attempts) * 100).toFixed(1)
+                : "0.0";
+            const avgDuration = stats.avgDuration > 0
+                ? (stats.avgDuration / 1000).toFixed(1) + "s"
+                : "N/A";
+            output.push(`- ${agent}: ${successRate}% success (${stats.attempts} tasks), avg ${avgDuration}`);
+        }
+        // Complexity accuracy
+        output.push("");
+        output.push("=== Complexity Accuracy ===");
+        const { underestimated, accurate, overestimated, total } = insights.complexityStats;
+        if (total > 0) {
+            output.push(`- Underestimated: ${((underestimated / total) * 100).toFixed(1)}% (tasks took longer than predicted)`);
+            output.push(`- Accurate: ${((accurate / total) * 100).toFixed(1)}% (predictions within 50%)`);
+            output.push(`- Overestimated: ${((overestimated / total) * 100).toFixed(1)}% (tasks completed faster than predicted)`);
+        }
+        else {
+            output.push("- Not enough data to determine accuracy");
+        }
+        // Task type breakdown
+        output.push("");
+        output.push("=== Task Types ===");
+        for (const [taskType, stats] of insights.taskTypeStats) {
+            output.push(`- ${taskType}: ${stats.count} tasks, avg complexity ${stats.avgComplexity.toFixed(0)}`);
+        }
+        return output;
+    }
+    /**
+     * Generate insights as a formatted report
+     */
+    async generateReport() {
+        const insights = await this.analyze();
+        const insightsLines = this.generateInsights(insights);
+        const report = [
+            "╔════════════════════════════════════════════════════════════╗",
+            "║           0xRay Pattern Analytics Report             ║",
+            "╚════════════════════════════════════════════════════════════╝",
+            "",
+            `Analyzed: ${insights.totalEntries} log entries`,
+            `Date Range: ${insights.dateRange.start || "N/A"} to ${insights.dateRange.end || "N/A"}`,
+            "",
+            ...insightsLines,
+            "",
+            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+            "Generated by 0xRay Simple Pattern Analyzer",
+        ];
+        return report.join("\n");
+    }
+    emptyInsights() {
+        return {
+            agentStats: new Map(),
+            taskTypeStats: new Map(),
+            complexityStats: {
+                underestimated: 0,
+                accurate: 0,
+                overestimated: 0,
+                total: 0,
+            },
+            totalEntries: 0,
+            dateRange: { start: "", end: "" },
+        };
+    }
+}
+// Export singleton for easy use
+export const patternAnalyzer = new SimplePatternAnalyzer();