0xray 2.0.0

package/dist/analytics/predictive-analytics.js

@@ -0,0 +1,248 @@
+/**
+ * Predictive Analytics for Optimal Agent Routing
+ *
+ * Predicts the best agent to route a task to based on historical
+ * success rates using simple keyword overlap scoring.
+ *
+ * @version 1.0.0
+ */
+import { routingOutcomeTracker } from '../delegation/analytics/outcome-tracker.js';
+/**
+ * Calculate keyword overlap score between a task description and a set of
+ * historical task descriptions routed to a specific agent.
+ */
+function keywordOverlapScore(description, historicalDescriptions) {
+    const descWords = new Set(description.toLowerCase().split(/\W+/).filter(w => w.length > 2));
+    if (descWords.size === 0 || historicalDescriptions.length === 0)
+        return 0;
+    let totalScore = 0;
+    let matchCount = 0;
+    for (const hist of historicalDescriptions) {
+        const histWords = new Set(hist.toLowerCase().split(/\W+/).filter(w => w.length > 2));
+        let overlap = 0;
+        for (const w of descWords) {
+            if (histWords.has(w))
+                overlap++;
+        }
+        if (overlap > 0) {
+            totalScore += overlap / Math.max(descWords.size, histWords.size);
+            matchCount++;
+        }
+    }
+    return matchCount > 0 ? totalScore / matchCount : 0;
+}
+/**
+ * Calculate risk level based on confidence and success probability.
+ * Ported from advanced-features for enhanced decision-making.
+ */
+function calculateRiskLevel(confidence, successProbability) {
+    const riskScore = 1 - confidence + (1 - successProbability);
+    if (riskScore < 0.3)
+        return "low";
+    if (riskScore < 0.7)
+        return "medium";
+    return "high";
+}
+/**
+ * Estimate task duration based on agent's historical performance.
+ */
+function estimateTaskDuration(agentOutcomes) {
+    if (agentOutcomes.length === 0)
+        return 0;
+    const durations = agentOutcomes
+        .filter(o => o.executionTimeMs !== undefined)
+        .map(o => o.executionTimeMs);
+    if (durations.length === 0)
+        return 0;
+    const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
+    const variance = durations.reduce((acc, d) => acc + Math.pow(d - avg, 2), 0) / durations.length;
+    const stdDev = Math.sqrt(variance);
+    const coefficientOfVariation = avg > 0 ? stdDev / avg : 0;
+    return Math.max(avg * (1 + coefficientOfVariation * 0.1), 10);
+}
+/**
+ * Build agent performance summary from historical outcomes.
+ */
+function buildAgentMetrics(agentOutcomes) {
+    const totalTasks = agentOutcomes.length;
+    const successfulTasks = agentOutcomes.filter(o => o.success).length;
+    const failedTasks = totalTasks - successfulTasks;
+    // Calculate average execution time
+    const durations = agentOutcomes
+        .filter(o => o.executionTimeMs !== undefined)
+        .map(o => o.executionTimeMs);
+    const averageExecutionTime = durations.length > 0
+        ? durations.reduce((a, b) => a + b, 0) / durations.length
+        : 0;
+    // Recent performance (last 20 tasks)
+    const recentPerformance = agentOutcomes
+        .slice(-20)
+        .map(o => o.success ? 1 : 0);
+    // Task type breakdown
+    const taskTypeBreakdown = {};
+    for (const outcome of agentOutcomes) {
+        const taskType = outcome.taskType || "unknown";
+        if (!taskTypeBreakdown[taskType]) {
+            taskTypeBreakdown[taskType] = { count: 0, successRate: 0 };
+        }
+        taskTypeBreakdown[taskType].count++;
+    }
+    // Calculate per-task-type success rates
+    for (const taskType of Object.keys(taskTypeBreakdown)) {
+        const taskOutcomes = agentOutcomes.filter(o => (o.taskType || "unknown") === taskType);
+        const successes = taskOutcomes.filter(o => o.success).length;
+        const entry = taskTypeBreakdown[taskType];
+        if (entry) {
+            entry.successRate = successes / taskOutcomes.length;
+        }
+    }
+    return {
+        totalTasks,
+        successfulTasks,
+        failedTasks,
+        averageExecutionTime,
+        successRate: totalTasks > 0 ? successfulTasks / totalTasks : 0,
+        recentPerformance,
+        taskTypeBreakdown,
+    };
+}
+export const predictiveAnalytics = {
+    /**
+     * Predict the optimal agent for a given task description.
+     *
+     * Loads outcomes from routingOutcomeTracker, groups by agent,
+     * and picks the agent with the best historical success rate
+     * among those that have keyword overlap with the task.
+     */
+    async predict(taskDescription) {
+        await routingOutcomeTracker.reloadFromDisk();
+        const outcomes = routingOutcomeTracker.getOutcomes();
+        // Filter to outcomes that have a resolved success field
+        const resolved = outcomes.filter((o) => o.success !== undefined && o.taskDescription);
+        if (resolved.length === 0)
+            return null;
+        // Group outcomes by agent
+        const agentMap = new Map();
+        for (const o of resolved) {
+            const list = agentMap.get(o.routedAgent) || [];
+            list.push(o);
+            agentMap.set(o.routedAgent, list);
+        }
+        let bestPrediction = null;
+        let bestScore = -1;
+        for (const [agent, agentOutcomes] of agentMap.entries()) {
+            const descriptions = agentOutcomes.map(o => o.taskDescription);
+            const overlap = keywordOverlapScore(taskDescription, descriptions);
+            if (overlap <= 0)
+                continue; // skip agents with no keyword overlap
+            const successes = agentOutcomes.filter(o => o.success).length;
+            const successRate = successes / agentOutcomes.length;
+            // Weighted score: 70% keyword overlap, 30% success rate
+            const score = (overlap * 0.7) + (successRate * 0.3);
+            if (score > bestScore) {
+                bestScore = score;
+                const riskLevel = calculateRiskLevel(score, successRate);
+                const estimatedDuration = estimateTaskDuration(agentOutcomes);
+                const agentMetrics = buildAgentMetrics(agentOutcomes);
+                bestPrediction = {
+                    agent,
+                    confidence: Math.min(score, 1),
+                    historicalSuccessRate: successRate,
+                    sampleSize: agentOutcomes.length,
+                    riskLevel,
+                    estimatedDuration,
+                    agentMetrics,
+                };
+            }
+        }
+        return bestPrediction;
+    },
+    /**
+     * Predict the globally optimal agent regardless of task description.
+     *
+     * Returns the agent with the highest success rate that has at least
+     * 3 historical samples.
+     */
+    async predictOptimalAgent() {
+        await routingOutcomeTracker.reloadFromDisk();
+        const stats = routingOutcomeTracker.getStats();
+        // Filter to agents with >= 3 samples
+        const qualified = stats.filter(s => s.total >= 3);
+        if (qualified.length === 0)
+            return null;
+        // Sort by success rate descending, then by total samples descending
+        qualified.sort((a, b) => {
+            if (b.successRate !== a.successRate)
+                return b.successRate - a.successRate;
+            return b.total - a.total;
+        });
+        const top = qualified[0];
+        const outcomes = routingOutcomeTracker.getOutcomes();
+        const agentOutcomes = outcomes.filter(o => o.routedAgent === top.agent);
+        const riskLevel = calculateRiskLevel(top.successRate, top.successRate);
+        const estimatedDuration = estimateTaskDuration(agentOutcomes);
+        const agentMetrics = buildAgentMetrics(agentOutcomes);
+        return {
+            agent: top.agent,
+            confidence: top.successRate,
+            historicalSuccessRate: top.successRate,
+            sampleSize: top.total,
+            riskLevel,
+            estimatedDuration,
+            agentMetrics,
+        };
+    },
+    /**
+     * Synchronous prediction — uses in-memory outcome data without disk reload.
+     * Suitable for hot-path usage in agent-delegator.
+     */
+    predictSync(taskDescription) {
+        const stats = routingOutcomeTracker.getStats();
+        const outcomes = routingOutcomeTracker.getOutcomes();
+        if (stats.length === 0 || outcomes.length === 0)
+            return null;
+        // Group outcomes by agent
+        const byAgent = new Map();
+        for (const o of outcomes) {
+            const arr = byAgent.get(o.routedAgent) || [];
+            arr.push(o);
+            byAgent.set(o.routedAgent, arr);
+        }
+        let bestAgent = null;
+        let bestScore = -1;
+        let bestRate = 0;
+        let bestSamples = 0;
+        let bestAgentOutcomes = [];
+        for (const [agent, agentOutcomes] of byAgent) {
+            const descriptions = agentOutcomes.map(o => o.taskDescription);
+            const overlap = keywordOverlapScore(taskDescription, descriptions);
+            const agentStat = stats.find(s => s.agent === agent);
+            const successRate = agentStat?.successRate ?? 0;
+            const total = agentStat?.total ?? 0;
+            // Weighted score: 70% keyword overlap + 30% historical success rate
+            const score = (0.7 * overlap) + (0.3 * successRate);
+            if (score > bestScore && total >= 3) {
+                bestScore = score;
+                bestAgent = agent;
+                bestRate = successRate;
+                bestSamples = total;
+                // Store for enhanced return
+                bestAgentOutcomes = agentOutcomes;
+            }
+        }
+        if (!bestAgent || bestScore < 0.3)
+            return null;
+        const riskLevel = calculateRiskLevel(bestScore, bestRate);
+        const estimatedDuration = estimateTaskDuration(bestAgentOutcomes);
+        const agentMetrics = buildAgentMetrics(bestAgentOutcomes);
+        return {
+            agent: bestAgent,
+            confidence: Math.min(bestScore, 1.0),
+            historicalSuccessRate: bestRate,
+            sampleSize: bestSamples,
+            riskLevel,
+            estimatedDuration,
+            agentMetrics,
+        };
+    },
+};

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

@@ -0,0 +1,371 @@
+/**
+ * Prompt Pattern Analyzer for 0xRay
+ *
+ * Analyzes actual vs. template prompts to detect gaps and emerging patterns.
+ * Integrates with RoutingOutcomeTracker to provide insights for template optimization.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import { routingOutcomeTracker } from "../delegation/analytics/outcome-tracker.js";
+class PromptPatternAnalyzer {
+    minFrequencyThreshold = 3;
+    confidenceThreshold = 0.7;
+    emergingPatternMinSamples = 5;
+    /**
+     * Analyze prompt patterns and compare against templates
+     */
+    analyzePromptPatterns() {
+        const promptData = routingOutcomeTracker.getPromptData();
+        const outcomes = routingOutcomeTracker.getOutcomes();
+        if (promptData.length === 0) {
+            return this.emptyComparisonResult();
+        }
+        const templateMatches = promptData.filter((p) => p.templatePrompt && p.templatePrompt.length > 0);
+        const nonTemplatePrompts = promptData.filter((p) => !p.templatePrompt || p.templatePrompt.length === 0);
+        const gaps = this.detectTemplateGaps(promptData, outcomes);
+        const emergingPatterns = this.identifyEmergingPatterns(promptData, outcomes);
+        const topMissedKeywords = this.analyzeMissedKeywords(promptData);
+        const agentCoverage = this.calculateAgentCoverage(promptData);
+        return {
+            totalPrompts: promptData.length,
+            templateMatches: templateMatches.length,
+            nonTemplatePrompts: nonTemplatePrompts.length,
+            templateMatchRate: promptData.length > 0 ? templateMatches.length / promptData.length : 0,
+            gaps,
+            emergingPatterns,
+            topMissedKeywords,
+            agentCoverage,
+        };
+    }
+    /**
+     * Detect gaps where templates don't match user requests
+     */
+    detectTemplateGaps(promptData, outcomes) {
+        const gaps = [];
+        const gapMap = new Map();
+        for (const prompt of promptData) {
+            if (!prompt.templatePrompt || prompt.templatePrompt.length === 0) {
+                const key = this.normalizeRequest(prompt.userRequest || '');
+                if (gapMap.has(key)) {
+                    const existing = gapMap.get(key);
+                    if (existing) {
+                        existing.frequency++;
+                        existing.lastSeen = prompt.timestamp;
+                    }
+                }
+                else {
+                    const outcome = outcomes.find((o) => o.taskId === prompt.taskId);
+                    gaps.push({
+                        gapType: this.classifyGapType(prompt, outcome),
+                        userRequest: prompt.userRequest || '',
+                        generatedPrompt: prompt.generatedPrompt || '',
+                        suggestedAgent: outcome?.routedAgent ?? "code-reviewer",
+                        suggestedSkill: outcome?.routedSkill ?? "code-review",
+                        frequency: 1,
+                        lastSeen: prompt.timestamp,
+                        confidence: prompt.confidence ?? 0.5,
+                    });
+                    const newGap = gaps[gaps.length - 1];
+                    if (newGap) {
+                        gapMap.set(key, newGap);
+                    }
+                }
+            }
+        }
+        return gaps
+            .filter((gap) => gap.frequency >= this.minFrequencyThreshold)
+            .sort((a, b) => b.frequency - a.frequency);
+    }
+    /**
+     * Identify emerging patterns from real usage
+     */
+    identifyEmergingPatterns(promptData, outcomes) {
+        const patternMap = new Map();
+        const keywordFrequency = new Map();
+        for (const prompt of promptData) {
+            const keywords = this.extractKeywords(prompt.userRequest || '');
+            for (const keyword of keywords) {
+                keywordFrequency.set(keyword, (keywordFrequency.get(keyword) || 0) + 1);
+            }
+        }
+        const significantKeywords = Array.from(keywordFrequency.entries())
+            .filter(([, count]) => count >= this.minFrequencyThreshold)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 50);
+        for (const prompt of promptData) {
+            const keywords = this.extractKeywords(prompt.userRequest || '');
+            const significantKeywordsInPrompt = keywords.filter((kw) => significantKeywords.some(([sigKw]) => kw === sigKw));
+            if (significantKeywordsInPrompt.length === 0)
+                continue;
+            const patternKey = significantKeywordsInPrompt.sort().join("|");
+            const outcome = outcomes.find((o) => o.taskId === prompt.taskId);
+            if (!outcome)
+                continue;
+            if (patternMap.has(patternKey)) {
+                const existing = patternMap.get(patternKey);
+                existing.frequency++;
+                existing.avgConfidence =
+                    (existing.avgConfidence * (existing.frequency - 1) + (prompt.confidence || 0.5)) /
+                        existing.frequency;
+                if (outcome.success !== undefined) {
+                    const totalSuccesses = existing.successRate * (existing.frequency - 1) +
+                        (outcome.success ? 1 : 0);
+                    existing.successRate = totalSuccesses / existing.frequency;
+                }
+                if (existing.sampleRequests.length < 3) {
+                    existing.sampleRequests.push(prompt.userRequest || '');
+                }
+            }
+            else {
+                patternMap.set(patternKey, {
+                    patternId: this.generatePatternId(significantKeywordsInPrompt),
+                    keywords: significantKeywordsInPrompt,
+                    sampleRequests: [prompt.userRequest || ''],
+                    suggestedAgent: outcome.routedAgent || 'enforcer',
+                    suggestedSkill: outcome.routedSkill || 'code-review',
+                    confidence: prompt.confidence || 0.5,
+                    frequency: 1,
+                    avgConfidence: prompt.confidence || 0.5,
+                    successRate: outcome.success !== undefined ? (outcome.success ? 1 : 0) : 0,
+                });
+            }
+        }
+        return Array.from(patternMap.values())
+            .filter((pattern) => pattern.frequency >= this.emergingPatternMinSamples &&
+            pattern.avgConfidence >= this.confidenceThreshold &&
+            pattern.successRate >= 0.6)
+            .sort((a, b) => b.frequency - a.frequency);
+    }
+    /**
+     * Analyze frequently missed keywords
+     */
+    analyzeMissedKeywords(promptData) {
+        const missedKeywords = new Map();
+        const keywordToAgent = new Map();
+        for (const prompt of promptData) {
+            if (!prompt.templatePrompt || prompt.templatePrompt.length === 0) {
+                const keywords = this.extractKeywords(prompt.userRequest || '');
+                for (const keyword of keywords) {
+                    if (keyword.length > 3) {
+                        missedKeywords.set(keyword, (missedKeywords.get(keyword) || 0) + 1);
+                        if (!keywordToAgent.has(keyword)) {
+                            keywordToAgent.set(keyword, new Set());
+                        }
+                        keywordToAgent.get(keyword).add(prompt.routedAgent || 'enforcer');
+                    }
+                }
+            }
+        }
+        return Array.from(missedKeywords.entries())
+            .filter(([, count]) => count >= this.minFrequencyThreshold)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 20)
+            .map(([keyword, count]) => ({
+            keyword,
+            count,
+            suggestedMappings: Array.from(keywordToAgent.get(keyword) || []),
+        }));
+    }
+    /**
+     * Calculate agent coverage metrics
+     */
+    calculateAgentCoverage(promptData) {
+        const coverage = new Map();
+        for (const prompt of promptData) {
+            const agent = prompt.routedAgent || 'enforcer';
+            const hasTemplate = prompt.templatePrompt && prompt.templatePrompt.length > 0;
+            if (!coverage.has(agent)) {
+                coverage.set(agent, { total: 0, withTemplate: 0, withoutTemplate: 0 });
+            }
+            const stats = coverage.get(agent);
+            stats.total++;
+            if (hasTemplate) {
+                stats.withTemplate++;
+            }
+            else {
+                stats.withoutTemplate++;
+            }
+        }
+        return coverage;
+    }
+    /**
+     * Generate template optimization suggestions
+     */
+    generateOptimizationSuggestions(comparisonResult) {
+        const suggestions = [];
+        for (const pattern of comparisonResult.emergingPatterns) {
+            if (pattern.avgConfidence >= 0.85 &&
+                pattern.successRate >= 0.8 &&
+                pattern.frequency >= 5) {
+                suggestions.push({
+                    suggestionType: "add_template",
+                    templateName: pattern.patternId,
+                    keywords: pattern.keywords,
+                    targetAgent: pattern.suggestedAgent,
+                    targetSkill: pattern.suggestedSkill,
+                    confidence: pattern.avgConfidence,
+                    expectedImpact: `Improve routing for ${pattern.frequency} similar requests`,
+                    reasoning: `Pattern detected in ${pattern.frequency} requests with ${(pattern.successRate * 100).toFixed(1)}% success rate`,
+                });
+            }
+        }
+        for (const gap of comparisonResult.gaps) {
+            if (gap.frequency >= 5 && gap.confidence >= 0.8) {
+                suggestions.push({
+                    suggestionType: "add_template",
+                    keywords: this.extractKeywords(gap.userRequest),
+                    targetAgent: gap.suggestedAgent || "code-reviewer",
+                    targetSkill: gap.suggestedSkill || "code-review",
+                    confidence: gap.confidence,
+                    expectedImpact: `Fill template gap for ${gap.frequency} similar requests`,
+                    reasoning: `Missing template detected for recurring request pattern`,
+                });
+            }
+        }
+        for (const missed of comparisonResult.topMissedKeywords.slice(0, 10)) {
+            if (missed.count >= 3 && missed.suggestedMappings.length > 0) {
+                const targetAgent = this.selectBestAgent(missed.suggestedMappings);
+                suggestions.push({
+                    suggestionType: "update_keywords",
+                    keywords: [missed.keyword],
+                    targetAgent,
+                    targetSkill: "code-review",
+                    confidence: 0.7,
+                    expectedImpact: `Improve routing for requests containing "${missed.keyword}"`,
+                    reasoning: `Keyword appears in ${missed.count} requests without template match`,
+                });
+            }
+        }
+        return suggestions.sort((a, b) => b.confidence - a.confidence);
+    }
+    /**
+     * Get analytics summary as formatted report
+     */
+    generateReport(comparisonResult) {
+        const lines = [];
+        lines.push("╔════════════════════════════════════════════════════════════╗");
+        lines.push("║        0xRay Prompt Pattern Analytics Report        ║");
+        lines.push("╚════════════════════════════════════════════════════════════╝");
+        lines.push("");
+        lines.push(`Total Prompts Analyzed: ${comparisonResult.totalPrompts}`);
+        lines.push(`Template Match Rate: ${(comparisonResult.templateMatchRate * 100).toFixed(1)}%`);
+        lines.push(`Non-Template Prompts: ${comparisonResult.nonTemplatePrompts}`);
+        lines.push("");
+        if (comparisonResult.gaps.length > 0) {
+            lines.push("=== Template Gaps ===");
+            lines.push(`Found ${comparisonResult.gaps.length} recurring gaps (frequency ≥ ${this.minFrequencyThreshold})`);
+            for (const gap of comparisonResult.gaps.slice(0, 5)) {
+                lines.push(`\n  ${gap.gapType.toUpperCase()}:`);
+                lines.push(`    Request: "${gap.userRequest.substring(0, 100)}..."`);
+                lines.push(`    Frequency: ${gap.frequency}`);
+                lines.push(`    Suggested: ${gap.suggestedAgent}/${gap.suggestedSkill}`);
+            }
+        }
+        if (comparisonResult.emergingPatterns.length > 0) {
+            lines.push("");
+            lines.push("=== Emerging Patterns ===");
+            lines.push(`Found ${comparisonResult.emergingPatterns.length} emerging patterns`);
+            for (const pattern of comparisonResult.emergingPatterns.slice(0, 5)) {
+                lines.push(`\n  ${pattern.patternId}:`);
+                lines.push(`    Keywords: ${pattern.keywords.join(", ")}`);
+                lines.push(`    Frequency: ${pattern.frequency}`);
+                lines.push(`    Avg Confidence: ${(pattern.avgConfidence * 100).toFixed(1)}%`);
+                lines.push(`    Success Rate: ${(pattern.successRate * 100).toFixed(1)}%`);
+            }
+        }
+        if (comparisonResult.agentCoverage.size > 0) {
+            lines.push("");
+            lines.push("=== Agent Template Coverage ===");
+            for (const [agent, stats] of Array.from(comparisonResult.agentCoverage.entries()).sort((a, b) => b[1].total - a[1].total)) {
+                const coverage = ((stats.withTemplate / stats.total) * 100).toFixed(1);
+                lines.push(`  ${agent}: ${coverage}% template coverage (${stats.withTemplate}/${stats.total})`);
+            }
+        }
+        lines.push("");
+        lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+        lines.push("Generated by 0xRay Prompt Pattern Analyzer");
+        return lines.join("\n");
+    }
+    classifyGapType(prompt, outcome) {
+        if (prompt.templatePrompt && prompt.templatePrompt.length > 0) {
+            if (prompt.generatedPrompt !== prompt.templatePrompt) {
+                return "pattern_mismatch";
+            }
+        }
+        const hasHighConfidence = (prompt.confidence || 0) >= this.confidenceThreshold;
+        const hasSuccess = outcome?.success === true;
+        if (hasHighConfidence && hasSuccess) {
+            return "emerging_pattern";
+        }
+        return "missing_template";
+    }
+    normalizeRequest(request) {
+        return request
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, " ")
+            .substring(0, 200);
+    }
+    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",
+            "into",
+            "over",
+            "after",
+        ]);
+        return words.filter((word) => !stopWords.has(word));
+    }
+    generatePatternId(keywords) {
+        return keywords.map((kw) => kw.substring(0, 3)).join("-") + "-pattern";
+    }
+    selectBestAgent(agents) {
+        if (agents.length === 1)
+            return agents[0];
+        const priorityOrder = [
+            "code-reviewer",
+            "architect",
+            "architect",
+            "code-reviewer",
+            "testing-lead",
+            "bug-triage-specialist",
+        ];
+        for (const priority of priorityOrder) {
+            if (agents.includes(priority)) {
+                return priority;
+            }
+        }
+        return agents[0] ?? "code-reviewer";
+    }
+    emptyComparisonResult() {
+        return {
+            totalPrompts: 0,
+            templateMatches: 0,
+            nonTemplatePrompts: 0,
+            templateMatchRate: 0,
+            gaps: [],
+            emergingPatterns: [],
+            topMissedKeywords: [],
+            agentCoverage: new Map(),
+        };
+    }
+}
+export const promptPatternAnalyzer = new PromptPatternAnalyzer();