cmp-standards 3.1.2 → 3.3.1

package/dist/services/OpportunityDiscovery.js

@@ -0,0 +1,754 @@
+/**
+ * @file OpportunityDiscovery Service - cmp-standards
+ * @description Multi-angle opportunity discovery system
+ *
+ * This service analyzes code from multiple perspectives to find:
+ * - New feature ideas
+ * - Edge cases and error handling gaps
+ * - Future feature possibilities
+ * - Technical debt
+ * - Performance improvements
+ * - Security vulnerabilities
+ * - DX improvements
+ */
+import { ulid } from 'ulid';
+import fs from 'fs/promises';
+import path from 'path';
+import { turso } from '../db/turso-client.js';
+import { createOpportunity, } from '../schema/opportunity-types.js';
+import { getExpertRouter } from '../experts/ExpertRouter.js';
+const ANALYSIS_PATTERNS = [
+    // Edge Cases
+    {
+        name: 'Missing Error Handling',
+        category: 'edge_case',
+        patterns: [
+            /\.catch\s*\(\s*\)/,
+            /catch\s*\(\s*_?\s*\)\s*\{\s*\}/,
+            /catch\s*\{[\s\n]*\}/,
+            /\.then\([^)]+\)(?!\s*\.catch)/,
+        ],
+        impact: 'high',
+        effort: 'small',
+        description: 'Empty or missing error handlers can cause silent failures',
+        suggestedApproach: 'Add proper error handling with logging and user feedback',
+    },
+    {
+        name: 'Unchecked Array Access',
+        category: 'edge_case',
+        patterns: [
+            /\[\d+\](?!\s*\?\?)/,
+            /\.at\(\d+\)(?!\s*\?\?)/,
+        ],
+        impact: 'medium',
+        effort: 'trivial',
+        description: 'Array access without bounds checking can cause runtime errors',
+        suggestedApproach: 'Use optional chaining or array bounds validation',
+    },
+    {
+        name: 'Missing Null Checks',
+        category: 'edge_case',
+        patterns: [
+            /(\w+)\.\w+\s*&&\s*\1\./,
+            /if\s*\(\s*!\s*\w+\s*\)\s*return/,
+        ],
+        impact: 'medium',
+        effort: 'small',
+        description: 'Potential null/undefined access without proper guards',
+        suggestedApproach: 'Add null checks or use optional chaining',
+    },
+    // Technical Debt
+    {
+        name: 'TODO Comments',
+        category: 'technical_debt',
+        patterns: [
+            /\/\/\s*TODO/i,
+            /\/\/\s*FIXME/i,
+            /\/\/\s*HACK/i,
+            /\/\*\s*TODO/i,
+        ],
+        impact: 'low',
+        effort: 'medium',
+        description: 'Unaddressed TODO comments indicate incomplete work',
+        suggestedApproach: 'Review and either implement or create proper issues',
+    },
+    {
+        name: 'Any Type Usage',
+        category: 'technical_debt',
+        patterns: [
+            /:\s*any\b/,
+            /as\s+any\b/,
+            /<any>/,
+        ],
+        impact: 'medium',
+        effort: 'medium',
+        description: 'Using "any" type bypasses TypeScript safety',
+        suggestedApproach: 'Replace with proper types or use unknown with type guards',
+    },
+    {
+        name: 'Console Logs',
+        category: 'technical_debt',
+        patterns: [
+            /console\.log\(/,
+            /console\.warn\(/,
+            /console\.error\(/,
+        ],
+        impact: 'low',
+        effort: 'trivial',
+        description: 'Console statements should be replaced with proper logging',
+        suggestedApproach: 'Use structured logging service instead',
+    },
+    {
+        name: 'Magic Numbers',
+        category: 'technical_debt',
+        patterns: [
+            /(?<![\w.])(?:1000|3600|86400|60|24|365|100|1024)(?!\d)/,
+        ],
+        impact: 'low',
+        effort: 'trivial',
+        description: 'Magic numbers reduce code readability',
+        suggestedApproach: 'Extract to named constants with clear meaning',
+    },
+    // Performance
+    {
+        name: 'Potential N+1 Query',
+        category: 'performance',
+        patterns: [
+            /for\s*\([^)]+\)\s*\{[^}]*await\s+\w+\.(find|query|get|fetch)/i,
+            /\.map\([^)]*async/,
+            /\.forEach\([^)]*async/,
+        ],
+        impact: 'high',
+        effort: 'medium',
+        description: 'Async operations in loops can cause N+1 query problems',
+        suggestedApproach: 'Use Promise.all or batch queries',
+    },
+    {
+        name: 'Missing Memoization',
+        category: 'performance',
+        patterns: [
+            /useMemo\s*\(\s*\(\)\s*=>\s*\w+,\s*\[\]/,
+            /useCallback\s*\([^)]+,\s*\[\]/,
+        ],
+        impact: 'medium',
+        effort: 'small',
+        description: 'Empty dependency arrays may indicate missing memoization',
+        suggestedApproach: 'Review dependencies and add proper memo boundaries',
+    },
+    {
+        name: 'Unbounded Data Fetch',
+        category: 'performance',
+        patterns: [
+            /findMany\s*\(\s*\)/,
+            /find\s*\(\s*\{\s*\}\s*\)/,
+            /SELECT\s+\*\s+FROM/i,
+        ],
+        impact: 'high',
+        effort: 'small',
+        description: 'Fetching all records without limits can cause memory issues',
+        suggestedApproach: 'Add pagination or sensible limits',
+    },
+    // Security
+    {
+        name: 'Hardcoded Credentials',
+        category: 'security',
+        patterns: [
+            /password\s*[=:]\s*["'][^"']+["']/i,
+            /apiKey\s*[=:]\s*["'][^"']+["']/i,
+            /secret\s*[=:]\s*["'][^"']+["']/i,
+            /token\s*[=:]\s*["'][A-Za-z0-9]+["']/i,
+        ],
+        impact: 'high',
+        effort: 'small',
+        description: 'Hardcoded credentials are a security risk',
+        suggestedApproach: 'Move to environment variables or secrets manager',
+    },
+    {
+        name: 'SQL Injection Risk',
+        category: 'security',
+        patterns: [
+            /`SELECT.*\$\{/,
+            /`INSERT.*\$\{/,
+            /`UPDATE.*\$\{/,
+            /`DELETE.*\$\{/,
+        ],
+        impact: 'high',
+        effort: 'medium',
+        description: 'String interpolation in SQL queries risks injection',
+        suggestedApproach: 'Use parameterized queries or query builders',
+    },
+    {
+        name: 'Unsafe User Input',
+        category: 'security',
+        patterns: [
+            /innerHTML\s*=/,
+            /dangerouslySetInnerHTML/,
+            /eval\s*\(/,
+            /new\s+Function\s*\(/,
+        ],
+        impact: 'high',
+        effort: 'medium',
+        description: 'Unsafe handling of user input can lead to XSS',
+        suggestedApproach: 'Sanitize input and use safe alternatives',
+    },
+    // DX Improvements
+    {
+        name: 'Missing JSDoc',
+        category: 'dx_improvement',
+        patterns: [
+            /^export\s+(async\s+)?function\s+\w+/m,
+            /^export\s+const\s+\w+\s*=\s*\(/m,
+        ],
+        impact: 'low',
+        effort: 'small',
+        description: 'Exported functions should have documentation',
+        suggestedApproach: 'Add JSDoc comments with @param and @returns',
+    },
+    {
+        name: 'Complex Function',
+        category: 'dx_improvement',
+        patterns: [
+            /function\s+\w+[^{]*\{[\s\S]{500,}/,
+        ],
+        impact: 'medium',
+        effort: 'medium',
+        description: 'Large functions are hard to understand and test',
+        suggestedApproach: 'Break down into smaller, focused functions',
+    },
+    // Test Coverage
+    {
+        name: 'Missing Test File',
+        category: 'test_coverage',
+        patterns: [
+            /export\s+(async\s+)?function\s+\w+/,
+            /export\s+class\s+\w+/,
+        ],
+        impact: 'medium',
+        effort: 'medium',
+        description: 'Exported code should have corresponding tests',
+        suggestedApproach: 'Add unit tests for public API',
+    },
+    // Future Features
+    {
+        name: 'Feature Flag Candidate',
+        category: 'future_feature',
+        patterns: [
+            /if\s*\(\s*false\s*\)/,
+            /if\s*\(\s*true\s*\)/,
+            /\/\/\s*feature:/i,
+            /enabled:\s*false/,
+        ],
+        impact: 'medium',
+        effort: 'small',
+        description: 'Code suggests feature flags or conditional features',
+        suggestedApproach: 'Consider implementing proper feature flag system',
+    },
+    // Accessibility
+    {
+        name: 'Missing ARIA',
+        category: 'accessibility',
+        patterns: [
+            /<button[^>]*>(?![^<]*aria-)/i,
+            /<div[^>]*onClick/,
+            /<span[^>]*onClick/,
+        ],
+        impact: 'medium',
+        effort: 'small',
+        description: 'Interactive elements missing ARIA attributes',
+        suggestedApproach: 'Add appropriate aria-label and role attributes',
+    },
+];
+const IDEA_PATTERNS = [
+    {
+        name: 'Caching Opportunity',
+        triggers: ['fetch', 'query', 'api', 'request'],
+        category: 'performance',
+        description: 'Repeated data fetching could benefit from caching',
+        impact: 'high',
+        effort: 'medium',
+    },
+    {
+        name: 'Retry Logic',
+        triggers: ['fetch', 'api', 'request', 'error'],
+        category: 'edge_case',
+        description: 'Network operations could benefit from retry logic',
+        impact: 'medium',
+        effort: 'small',
+    },
+    {
+        name: 'Rate Limiting',
+        triggers: ['api', 'endpoint', 'route', 'handler'],
+        category: 'security',
+        description: 'API endpoints could benefit from rate limiting',
+        impact: 'high',
+        effort: 'medium',
+    },
+    {
+        name: 'Input Validation',
+        triggers: ['body', 'params', 'query', 'input'],
+        category: 'security',
+        description: 'User input should be validated with Zod or similar',
+        impact: 'high',
+        effort: 'small',
+    },
+    {
+        name: 'Batch Operations',
+        triggers: ['create', 'insert', 'update', 'loop', 'forEach'],
+        category: 'performance',
+        description: 'Multiple operations could be batched for efficiency',
+        impact: 'medium',
+        effort: 'medium',
+    },
+    {
+        name: 'Event Sourcing',
+        triggers: ['state', 'history', 'audit', 'log', 'track'],
+        category: 'future_feature',
+        description: 'State changes could be captured for audit trail',
+        impact: 'medium',
+        effort: 'large',
+    },
+    {
+        name: 'Webhook Support',
+        triggers: ['event', 'notify', 'callback', 'integration'],
+        category: 'future_feature',
+        description: 'External integrations could benefit from webhooks',
+        impact: 'medium',
+        effort: 'medium',
+    },
+    {
+        name: 'Analytics Tracking',
+        triggers: ['click', 'view', 'user', 'action', 'event'],
+        category: 'future_feature',
+        description: 'User interactions could be tracked for analytics',
+        impact: 'low',
+        effort: 'medium',
+    },
+];
+// =============================================================================
+// Service Implementation
+// =============================================================================
+export class OpportunityDiscovery {
+    system;
+    constructor(system) {
+        this.system = system;
+    }
+    /**
+     * Discover opportunities across the codebase
+     */
+    async discover(request) {
+        const startTime = Date.now();
+        const runId = ulid();
+        const fullRequest = {
+            paths: request.paths ?? ['.'],
+            categories: request.categories ?? [],
+            minImpact: request.minImpact ?? 'low',
+            maxEffort: request.maxEffort ?? 'epic',
+            includeUncertain: request.includeUncertain ?? false,
+            depth: request.depth ?? 'standard',
+            system: request.system ?? this.system,
+        };
+        const opportunities = [];
+        const expertsUsed = new Set();
+        let filesAnalyzed = 0;
+        // Get files to analyze
+        const files = await this.collectFiles(fullRequest.paths, fullRequest.depth);
+        filesAnalyzed = files.length;
+        // Analyze each file
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const fileOpportunities = await this.analyzeFile(file, content, fullRequest);
+                opportunities.push(...fileOpportunities);
+                // Track which experts would review this
+                const router = getExpertRouter();
+                const routing = router.route({ files: [file], content });
+                routing.selectedExperts.forEach(e => expertsUsed.add(e.expertId));
+            }
+            catch {
+                // Skip files that can't be read
+            }
+        }
+        // Run higher-level analysis
+        const ideaOpportunities = await this.analyzeForIdeas(files, fullRequest);
+        opportunities.push(...ideaOpportunities);
+        // Filter by impact and effort
+        const filtered = this.filterOpportunities(opportunities, fullRequest);
+        // Deduplicate similar opportunities
+        const deduped = this.deduplicateOpportunities(filtered);
+        // Calculate summary
+        const summary = this.calculateSummary(deduped, filesAnalyzed, Date.now() - startTime);
+        // Store opportunities in database
+        await this.storeOpportunities(runId, deduped);
+        return {
+            runId,
+            timestamp: new Date().toISOString(),
+            request: fullRequest,
+            opportunities: deduped,
+            summary,
+            expertsUsed: Array.from(expertsUsed),
+        };
+    }
+    /**
+     * Collect files to analyze based on paths and depth
+     */
+    async collectFiles(paths, depth) {
+        const files = [];
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs'];
+        const maxFiles = depth === 'quick' ? 50 : depth === 'standard' ? 200 : 500;
+        for (const basePath of paths) {
+            try {
+                const stat = await fs.stat(basePath);
+                if (stat.isFile()) {
+                    files.push(basePath);
+                }
+                else if (stat.isDirectory()) {
+                    await this.walkDirectory(basePath, files, extensions, maxFiles);
+                }
+            }
+            catch {
+                // Skip invalid paths
+            }
+            if (files.length >= maxFiles)
+                break;
+        }
+        return files.slice(0, maxFiles);
+    }
+    /**
+     * Recursively walk directory to collect files
+     */
+    async walkDirectory(dir, files, extensions, maxFiles) {
+        if (files.length >= maxFiles)
+            return;
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (files.length >= maxFiles)
+                    break;
+                const fullPath = path.join(dir, entry.name);
+                // Skip node_modules, .git, dist, etc.
+                if (entry.isDirectory()) {
+                    if (['node_modules', '.git', 'dist', 'build', '.next', 'coverage'].includes(entry.name)) {
+                        continue;
+                    }
+                    await this.walkDirectory(fullPath, files, extensions, maxFiles);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories that can't be read
+        }
+    }
+    /**
+     * Analyze a single file for opportunities
+     */
+    async analyzeFile(filePath, content, request) {
+        const opportunities = [];
+        const lines = content.split('\n');
+        for (const pattern of ANALYSIS_PATTERNS) {
+            // Skip if category is filtered out
+            if (request.categories.length > 0 && !request.categories.includes(pattern.category)) {
+                continue;
+            }
+            for (const regex of pattern.patterns) {
+                // Reset regex if global
+                regex.lastIndex = 0;
+                let match;
+                const fullContent = content;
+                const globalRegex = new RegExp(regex.source, regex.flags.includes('g') ? regex.flags : regex.flags + 'g');
+                while ((match = globalRegex.exec(fullContent)) !== null) {
+                    // Find line number
+                    const beforeMatch = fullContent.slice(0, match.index);
+                    const lineNumber = beforeMatch.split('\n').length;
+                    // Get code context (surrounding lines)
+                    const startLine = Math.max(0, lineNumber - 2);
+                    const endLine = Math.min(lines.length - 1, lineNumber + 2);
+                    const codeContext = lines.slice(startLine, endLine + 1).join('\n');
+                    const opportunity = createOpportunity(`${pattern.name} in ${path.basename(filePath)}`, pattern.description, pattern.category, {
+                        impact: pattern.impact,
+                        effort: pattern.effort,
+                        source: 'code_analysis',
+                        confidence: 0.8,
+                        relatedFiles: [filePath],
+                        suggestedApproach: pattern.suggestedApproach,
+                        codeExamples: [{
+                                file: filePath,
+                                lineStart: startLine + 1,
+                                lineEnd: endLine + 1,
+                                code: codeContext,
+                                note: `Match found at line ${lineNumber}`,
+                            }],
+                        tags: [pattern.category, pattern.name.toLowerCase().replace(/\s+/g, '-')],
+                    });
+                    opportunities.push(opportunity);
+                    // Limit matches per pattern per file
+                    if (opportunities.filter(o => o.title.includes(pattern.name)).length >= 3) {
+                        break;
+                    }
+                }
+            }
+        }
+        return opportunities;
+    }
+    /**
+     * Analyze files for higher-level idea opportunities
+     */
+    async analyzeForIdeas(files, request) {
+        const opportunities = [];
+        const triggerCounts = new Map();
+        // Count trigger occurrences across files
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const contentLower = content.toLowerCase();
+                for (const idea of IDEA_PATTERNS) {
+                    for (const trigger of idea.triggers) {
+                        if (contentLower.includes(trigger)) {
+                            const existing = triggerCounts.get(idea.name) ?? { files: [], count: 0 };
+                            if (!existing.files.includes(file)) {
+                                existing.files.push(file);
+                            }
+                            existing.count++;
+                            triggerCounts.set(idea.name, existing);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        // Generate opportunities from patterns that appear frequently
+        for (const idea of IDEA_PATTERNS) {
+            const data = triggerCounts.get(idea.name);
+            if (data && data.files.length >= 2) {
+                // Skip if category is filtered out
+                if (request.categories.length > 0 && !request.categories.includes(idea.category)) {
+                    continue;
+                }
+                const opportunity = createOpportunity(idea.name, idea.description, idea.category, {
+                    impact: idea.impact,
+                    effort: idea.effort,
+                    source: 'pattern_detection',
+                    confidence: Math.min(0.9, 0.5 + (data.files.length * 0.1)),
+                    relatedFiles: data.files.slice(0, 5),
+                    tags: [idea.category, 'pattern', idea.name.toLowerCase().replace(/\s+/g, '-')],
+                });
+                opportunities.push(opportunity);
+            }
+        }
+        return opportunities;
+    }
+    /**
+     * Filter opportunities by impact and effort
+     */
+    filterOpportunities(opportunities, request) {
+        const impactOrder = ['low', 'medium', 'high'];
+        const effortOrder = ['trivial', 'small', 'medium', 'large', 'epic'];
+        const minImpactIndex = impactOrder.indexOf(request.minImpact);
+        const maxEffortIndex = effortOrder.indexOf(request.maxEffort);
+        return opportunities.filter(opp => {
+            const impactIndex = impactOrder.indexOf(opp.impact);
+            const effortIndex = effortOrder.indexOf(opp.effort);
+            // Filter by impact (must be >= minImpact)
+            if (impactIndex < minImpactIndex)
+                return false;
+            // Filter by effort (must be <= maxEffort)
+            if (effortIndex > maxEffortIndex)
+                return false;
+            // Filter by confidence
+            if (!request.includeUncertain && opp.confidence < 0.5)
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Deduplicate similar opportunities
+     */
+    deduplicateOpportunities(opportunities) {
+        const seen = new Map();
+        for (const opp of opportunities) {
+            // Create a key based on title and first related file
+            const key = `${opp.title}-${opp.relatedFiles[0] ?? ''}`;
+            const existing = seen.get(key);
+            if (!existing || opp.confidence > existing.confidence) {
+                seen.set(key, opp);
+            }
+        }
+        return Array.from(seen.values());
+    }
+    /**
+     * Calculate summary statistics
+     */
+    calculateSummary(opportunities, filesAnalyzed, analysisTimeMs) {
+        const byCategory = {};
+        const byImpact = {};
+        const byEffort = {};
+        const bySource = {};
+        const fileCount = {};
+        for (const opp of opportunities) {
+            byCategory[opp.category] = (byCategory[opp.category] ?? 0) + 1;
+            byImpact[opp.impact] = (byImpact[opp.impact] ?? 0) + 1;
+            byEffort[opp.effort] = (byEffort[opp.effort] ?? 0) + 1;
+            bySource[opp.source] = (bySource[opp.source] ?? 0) + 1;
+            for (const file of opp.relatedFiles) {
+                fileCount[file] = (fileCount[file] ?? 0) + 1;
+            }
+        }
+        const topFiles = Object.entries(fileCount)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([file, count]) => ({ file, count }));
+        return {
+            totalFound: opportunities.length,
+            byCategory,
+            byImpact,
+            byEffort,
+            bySource,
+            topFiles,
+            analysisTimeMs,
+            filesAnalyzed,
+        };
+    }
+    /**
+     * Store opportunities in Turso database
+     */
+    async storeOpportunities(runId, opportunities) {
+        for (const opp of opportunities) {
+            await turso.create('opportunity', this.system, {
+                ...opp,
+                runId,
+            }, 'active');
+        }
+    }
+    /**
+     * Get recent opportunities from Turso
+     */
+    async getRecent(limit = 20) {
+        const items = await turso.query({
+            system: this.system,
+            type: 'opportunity',
+            status: 'active',
+            limit,
+            orderBy: 'updated_at',
+            orderDir: 'DESC',
+        });
+        return items.map(item => item.content);
+    }
+    /**
+     * Get opportunities by category from Turso
+     */
+    async getByCategory(category, limit = 20) {
+        const items = await turso.query({
+            system: this.system,
+            type: 'opportunity',
+            status: 'active',
+            limit: limit * 2, // Fetch more to filter
+        });
+        return items
+            .map(item => item.content)
+            .filter(opp => opp.category === category)
+            .slice(0, limit);
+    }
+    /**
+     * Update opportunity status in Turso
+     */
+    async updateStatus(opportunityId, status) {
+        const items = await turso.query({
+            system: this.system,
+            type: 'opportunity',
+            limit: 100,
+        });
+        const item = items.find(i => i.content?.id === opportunityId);
+        if (item) {
+            const content = item.content;
+            content.status = status;
+            content.updatedAt = new Date().toISOString();
+            await turso.update(item.id, {
+                status: status === 'rejected' || status === 'implemented' ? 'done' : 'active',
+                content,
+            });
+        }
+    }
+    /**
+     * Export opportunities as markdown
+     */
+    async exportMarkdown(opportunities) {
+        let md = `# Opportunity Discovery Report\n\n`;
+        md += `*Generated: ${new Date().toISOString()}*\n\n`;
+        md += `Total opportunities found: **${opportunities.length}**\n\n`;
+        // Group by category
+        const byCategory = new Map();
+        for (const opp of opportunities) {
+            const list = byCategory.get(opp.category) ?? [];
+            list.push(opp);
+            byCategory.set(opp.category, list);
+        }
+        // Output by category
+        for (const [category, opps] of byCategory) {
+            md += `## ${this.formatCategory(category)} (${opps.length})\n\n`;
+            for (const opp of opps) {
+                md += `### ${opp.title}\n\n`;
+                md += `- **Impact**: ${opp.impact}\n`;
+                md += `- **Effort**: ${opp.effort}\n`;
+                md += `- **Confidence**: ${Math.round(opp.confidence * 100)}%\n`;
+                md += `- **Source**: ${opp.source}\n`;
+                if (opp.relatedFiles.length > 0) {
+                    md += `- **Files**: ${opp.relatedFiles.join(', ')}\n`;
+                }
+                md += `\n${opp.description}\n\n`;
+                if (opp.suggestedApproach) {
+                    md += `**Suggested Approach**: ${opp.suggestedApproach}\n\n`;
+                }
+                if (opp.codeExamples.length > 0) {
+                    md += `**Code Context**:\n\`\`\`\n${opp.codeExamples[0].code}\n\`\`\`\n\n`;
+                }
+                md += `---\n\n`;
+            }
+        }
+        return md;
+    }
+    /**
+     * Format category name for display
+     */
+    formatCategory(category) {
+        const names = {
+            idea: 'Ideas',
+            edge_case: 'Edge Cases',
+            future_feature: 'Future Features',
+            technical_debt: 'Technical Debt',
+            performance: 'Performance',
+            security: 'Security',
+            dx_improvement: 'Developer Experience',
+            documentation: 'Documentation',
+            test_coverage: 'Test Coverage',
+            accessibility: 'Accessibility',
+        };
+        return names[category] ?? category;
+    }
+}
+// =============================================================================
+// Factory Functions
+// =============================================================================
+let discoveryInstance = null;
+/**
+ * Get or create OpportunityDiscovery instance
+ */
+export function getOpportunityDiscovery(system) {
+    if (!discoveryInstance) {
+        discoveryInstance = new OpportunityDiscovery(system);
+    }
+    return discoveryInstance;
+}
+/**
+ * Create fresh OpportunityDiscovery instance
+ */
+export function createOpportunityDiscovery(system) {
+    return new OpportunityDiscovery(system);
+}
+//# sourceMappingURL=OpportunityDiscovery.js.map