@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/handlers/github/githubDiscoverPatterns.js

@@ -1,621 +0,0 @@
-/**
- * GitHub Discover Patterns Handler
- * Analyzes a GitHub repo to discover coding patterns
- *
- * POST /api/github/discover (CognitoAuthorizer)
- * Body: { project_id, owner, repo, branch }
- * Timeout: 120s, Memory: 512MB
- *
- * Enhanced features:
- * - Fetches and analyzes actual code content (not just file paths)
- * - Uses LLM analysis to identify patterns in YAML standards format
- * - Maps tech stack to relevant YAML standards categories
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, verifyProjectAccess } = require('./helpers');
-const { LLMPatternDetector } = require('./core/LLMPatternDetector');
-const crypto = require('crypto');
-const https = require('https');
-
-// File patterns to sample for deep analysis
-const KEY_FILES_TO_SAMPLE = [
-    // Backend patterns
-    { pattern: /^src\/handlers\/[^/]+\.js$/, purpose: 'lambda_handlers', max: 3 },
-    { pattern: /^src\/.*\/(helpers|utils|lib)\/[^/]+\.js$/, purpose: 'utilities', max: 2 },
-    // Frontend patterns
-    { pattern: /^src\/components\/[^/]+\.(jsx?|tsx?)$/, purpose: 'components', max: 3 },
-    { pattern: /^src\/(pages|views)\/[^/]+\.(jsx?|tsx?)$/, purpose: 'pages', max: 2 },
-    // Config patterns
-    { pattern: /^(template|serverless|sam)\.ya?ml$/, purpose: 'infrastructure', max: 1 },
-    // Core app files
-    { pattern: /^src\/(app|index|main)\.(js|ts|jsx|tsx)$/, purpose: 'entry_point', max: 1 },
-];
-
-// Tech stack to YAML standards categories mapping
-const TECH_TO_STANDARDS = {
-    // Languages
-    'JavaScript': ['serverless-saas-aws', 'backend'],
-    'TypeScript': ['serverless-saas-aws', 'frontend-development'],
-    'Python': ['compliance-security'],
-    'Go': ['backend'],
-    'Rust': ['backend'],
-
-    // Frameworks
-    'React': ['frontend-development'],
-    'Next.js': ['frontend-development'],
-    'Vue.js': ['frontend-development'],
-    'Angular': ['frontend-development'],
-    'Express': ['serverless-saas-aws', 'backend'],
-    'Fastify': ['serverless-saas-aws', 'backend'],
-    'Svelte': ['frontend-development'],
-    'Tailwind CSS': ['frontend-development'],
-
-    // AWS Services
-    'AWS Lambda': ['serverless-saas-aws', 'backend'],
-    'Lambda': ['serverless-saas-aws', 'backend'],
-    'API Gateway': ['serverless-saas-aws'],
-    'Cognito': ['compliance-security', 'serverless-saas-aws'],
-    'DynamoDB': ['serverless-saas-aws'],
-    'S3': ['serverless-saas-aws'],
-    'CloudFormation': ['serverless-saas-aws', 'deployment'],
-    'SAM': ['serverless-saas-aws', 'deployment'],
-
-    // Databases
-    'PostgreSQL': ['database', 'real-time-systems'],
-    'MySQL': ['database'],
-    'MongoDB': ['database'],
-    'Redis': ['real-time-systems'],
-
-    // Patterns & Tools
-    'WebSockets': ['real-time-systems'],
-    'Docker': ['deployment'],
-    'GitHub Actions': ['deployment'],
-    'Jest': ['frontend-development'],
-    'Mocha': ['backend'],
-    'pytest': ['compliance-security'],
-
-    // AI/ML
-    'Claude': ['multi-agent-orchestration'],
-    'OpenAI': ['multi-agent-orchestration'],
-    'LangChain': ['multi-agent-orchestration'],
-    'Bedrock': ['multi-agent-orchestration', 'serverless-saas-aws'],
-};
-
-function httpsGet(path, token) {
-    return new Promise((resolve, reject) => {
-        const req = https.request({
-            hostname: 'api.github.com',
-            path: path,
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'User-Agent': 'MindMeld-App',
-                'Accept': 'application/json'
-            }
-        }, (res) => {
-            let data = '';
-            res.on('data', chunk => data += chunk);
-            res.on('end', () => {
-                try {
-                    resolve({ statusCode: res.statusCode, body: JSON.parse(data) });
-                } catch (e) {
-                    resolve({ statusCode: res.statusCode, body: data });
-                }
-            });
-        });
-        req.on('error', reject);
-        req.end();
-    });
-}
-
-function decryptToken(encryptedData, key) {
-    const [ivHex, encrypted] = encryptedData.split(':');
-    const iv = Buffer.from(ivHex, 'hex');
-    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
-    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
-    decrypted += decipher.final('utf8');
-    return decrypted;
-}
-
-/**
- * Select and fetch representative code files for deep analysis
- */
-async function fetchSampleFiles(tree, accessToken, owner, repo) {
-    const files = tree.filter(t => t.type === 'blob').map(t => t.path);
-    const samplesToFetch = [];
-
-    // Match files against patterns and select up to max per pattern
-    for (const config of KEY_FILES_TO_SAMPLE) {
-        const matches = files.filter(f => config.pattern.test(f));
-        const selected = matches.slice(0, config.max);
-        for (const path of selected) {
-            samplesToFetch.push({ path, purpose: config.purpose });
-        }
-    }
-
-    // Fetch content for selected files (limit total to avoid timeout)
-    const maxTotalFiles = 10;
-    const filesToFetch = samplesToFetch.slice(0, maxTotalFiles);
-
-    const samples = await Promise.all(
-        filesToFetch.map(async ({ path, purpose }) => {
-            try {
-                const res = await httpsGet(
-                    `/repos/${owner}/${repo}/contents/${encodeURIComponent(path)}`,
-                    accessToken
-                );
-                if (res.statusCode === 200 && res.body?.content) {
-                    const content = Buffer.from(res.body.content, 'base64').toString('utf8');
-                    return { path, purpose, content };
-                }
-            } catch (e) {
-                console.log(`Failed to fetch ${path}:`, e.message);
-            }
-            return null;
-        })
-    );
-
-    return samples.filter(Boolean);
-}
-
-/**
- * Analyze code samples using LLM for pattern detection
- */
-async function analyzeCodeWithLLM(samples, context) {
-    if (samples.length === 0) {
-        return { success: false, patterns: [], anti_patterns: [], recommendations: [] };
-    }
-
-    const detector = new LLMPatternDetector({ maxTokens: 2048 });
-
-    // Build combined code context
-    const codeContext = samples.map(s =>
-        `=== ${s.path} (${s.purpose}) ===\n${s.content.substring(0, 5000)}`
-    ).join('\n\n');
-
-    return await detector.analyzeRepoPatterns(codeContext, context);
-}
-
-/**
- * Generate standards recommendations based on discoveries and LLM analysis
- */
-function generateStandardsRecommendations(discoveries, llmAnalysis) {
-    const recommendedCategories = new Map();
-
-    // Map tech stack discoveries to standards categories
-    for (const discovery of discoveries) {
-        if (discovery.discovery_type === 'tech_stack') {
-            // Extract tech name from pattern_name (e.g., "Primary language: JavaScript" -> "JavaScript")
-            const techName = discovery.pattern_name.split(': ').pop();
-            const categories = TECH_TO_STANDARDS[techName] || [];
-
-            for (const cat of categories) {
-                if (!recommendedCategories.has(cat)) {
-                    recommendedCategories.set(cat, {
-                        category: cat,
-                        reasons: [],
-                        relevance: 0
-                    });
-                }
-                const rec = recommendedCategories.get(cat);
-                rec.reasons.push(`Uses ${techName}`);
-                rec.relevance += discovery.confidence;
-            }
-        }
-    }
-
-    // Add LLM recommendations
-    if (llmAnalysis?.recommendations) {
-        for (const rec of llmAnalysis.recommendations) {
-            const cat = rec.category;
-            if (!recommendedCategories.has(cat)) {
-                recommendedCategories.set(cat, {
-                    category: cat,
-                    reasons: [],
-                    relevance: 0
-                });
-            }
-            const existing = recommendedCategories.get(cat);
-            existing.reasons.push(rec.reason);
-            existing.relevance += rec.priority === 'high' ? 1 : rec.priority === 'medium' ? 0.5 : 0.25;
-        }
-    }
-
-    // Sort by relevance and return
-    return Array.from(recommendedCategories.values())
-        .sort((a, b) => b.relevance - a.relevance)
-        .slice(0, 5) // Top 5 recommendations
-        .map(r => ({
-            category: r.category,
-            reasons: [...new Set(r.reasons)].slice(0, 3),
-            relevance_score: Math.min(r.relevance, 1)
-        }));
-}
-
-async function githubDiscoverPatterns({ body, requestContext }) {
-    try {
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        const { project_id, owner, repo, branch } = body;
-        if (!project_id || !owner || !repo) {
-            return createErrorResponse(400, 'project_id, owner, and repo are required');
-        }
-
-        const targetBranch = branch || 'main';
-
-        // Verify user has access to project (collaborator or company member)
-        const projectAccess = await verifyProjectAccess(project_id, email);
-        if (!projectAccess) {
-            return createErrorResponse(403, 'Access denied to project');
-        }
-
-        // Get decrypted token
-        const connResult = await executeQuery(`
-            SELECT access_token_encrypted FROM rapport.github_connections
-            WHERE email_address = $1 AND revoked = FALSE
-        `, [email]);
-
-        if (connResult.rowCount === 0) {
-            return createErrorResponse(404, 'No GitHub connection found');
-        }
-
-        const encryptionKey = process.env.GITHUB_TOKEN_ENCRYPTION_KEY;
-        const accessToken = decryptToken(connResult.rows[0].access_token_encrypted, encryptionKey);
-
-        // Fetch repo data in parallel
-        const [languagesRes, treeRes, commitsRes] = await Promise.all([
-            httpsGet(`/repos/${owner}/${repo}/languages`, accessToken),
-            httpsGet(`/repos/${owner}/${repo}/git/trees/${targetBranch}?recursive=1`, accessToken),
-            httpsGet(`/repos/${owner}/${repo}/commits?per_page=50`, accessToken)
-        ]);
-
-        const discoveries = [];
-
-        // --- Analyze Languages (tech_stack) ---
-        if (languagesRes.statusCode === 200 && languagesRes.body) {
-            const languages = languagesRes.body;
-            const totalBytes = Object.values(languages).reduce((a, b) => a + b, 0);
-
-            for (const [lang, bytes] of Object.entries(languages)) {
-                const percentage = bytes / totalBytes;
-                if (percentage >= 0.05) { // At least 5% of codebase
-                    discoveries.push({
-                        discovery_type: 'tech_stack',
-                        pattern_name: `Primary language: ${lang}`,
-                        pattern_description: `${lang} makes up ${Math.round(percentage * 100)}% of the codebase`,
-                        confidence: Math.min(percentage * 2, 0.99),
-                        evidence: [{ source: 'languages_api', percentage: Math.round(percentage * 100) }]
-                    });
-                }
-            }
-        }
-
-        // --- Analyze File Tree (architecture, testing, ci_cd, naming) ---
-        if (treeRes.statusCode === 200 && treeRes.body?.tree) {
-            const tree = treeRes.body.tree;
-            const files = tree.filter(t => t.type === 'blob').map(t => t.path);
-            const dirs = tree.filter(t => t.type === 'tree').map(t => t.path);
-
-            // Detect test framework
-            const testFiles = files.filter(f =>
-                f.includes('.test.') || f.includes('.spec.') || f.includes('__tests__/')
-            );
-            if (testFiles.length > 0) {
-                const isJest = testFiles.some(f => f.endsWith('.test.js') || f.endsWith('.test.ts'));
-                const isMocha = files.some(f => f.includes('.mocharc') || f.includes('mocha'));
-                const isPytest = testFiles.some(f => f.startsWith('test_') || f.includes('/test_'));
-
-                let framework = 'Unknown';
-                if (isJest) framework = 'Jest';
-                else if (isMocha) framework = 'Mocha';
-                else if (isPytest) framework = 'pytest';
-
-                discoveries.push({
-                    discovery_type: 'testing',
-                    pattern_name: `Test framework: ${framework}`,
-                    pattern_description: `Found ${testFiles.length} test files using ${framework} conventions`,
-                    confidence: Math.min(testFiles.length / 10, 0.95),
-                    evidence: [{ source: 'file_tree', test_files_count: testFiles.length, sample: testFiles.slice(0, 5) }]
-                });
-            }
-
-            // Detect CI/CD
-            const ciFiles = files.filter(f =>
-                f.startsWith('.github/workflows/') || f === '.gitlab-ci.yml' ||
-                f === 'Jenkinsfile' || f === '.circleci/config.yml'
-            );
-            if (ciFiles.length > 0) {
-                const ciTool = ciFiles[0].startsWith('.github/') ? 'GitHub Actions' :
-                    ciFiles[0].includes('gitlab') ? 'GitLab CI' :
-                    ciFiles[0] === 'Jenkinsfile' ? 'Jenkins' : 'CircleCI';
-
-                discoveries.push({
-                    discovery_type: 'ci_cd',
-                    pattern_name: `CI/CD: ${ciTool}`,
-                    pattern_description: `Uses ${ciTool} with ${ciFiles.length} workflow file(s)`,
-                    confidence: 0.95,
-                    evidence: [{ source: 'file_tree', ci_files: ciFiles }]
-                });
-            }
-
-            // Detect Docker
-            const dockerFiles = files.filter(f =>
-                f === 'Dockerfile' || f === 'docker-compose.yml' || f === 'docker-compose.yaml' ||
-                f.endsWith('/Dockerfile')
-            );
-            if (dockerFiles.length > 0) {
-                discoveries.push({
-                    discovery_type: 'ci_cd',
-                    pattern_name: 'Containerization: Docker',
-                    pattern_description: `Found ${dockerFiles.length} Docker configuration file(s)`,
-                    confidence: 0.9,
-                    evidence: [{ source: 'file_tree', docker_files: dockerFiles }]
-                });
-            }
-
-            // Detect architecture patterns
-            const srcDirs = dirs.filter(d => d.split('/').length <= 2);
-            const hasSrcDir = srcDirs.some(d => d === 'src' || d.startsWith('src/'));
-            const hasLibDir = srcDirs.some(d => d === 'lib' || d.startsWith('lib/'));
-            const hasComponentsDir = dirs.some(d => d.includes('components'));
-            const hasPagesDir = dirs.some(d => d.includes('pages') || d.includes('views'));
-            const hasHandlersDir = dirs.some(d => d.includes('handlers') || d.includes('controllers'));
-
-            if (hasComponentsDir && hasPagesDir) {
-                discoveries.push({
-                    discovery_type: 'architecture',
-                    pattern_name: 'Frontend: Component-based architecture',
-                    pattern_description: 'Uses components/ and pages/ directory structure (React/Vue/Svelte pattern)',
-                    confidence: 0.85,
-                    evidence: [{ source: 'file_tree', pattern: 'components_pages' }]
-                });
-            }
-
-            if (hasHandlersDir) {
-                discoveries.push({
-                    discovery_type: 'architecture',
-                    pattern_name: 'Backend: Handler/Controller pattern',
-                    pattern_description: 'Uses handlers/ or controllers/ for request handling',
-                    confidence: 0.8,
-                    evidence: [{ source: 'file_tree', pattern: 'handlers_controllers' }]
-                });
-            }
-
-            // Detect naming conventions
-            const jsFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.ts'));
-            const camelCaseFiles = jsFiles.filter(f => {
-                const name = f.split('/').pop().replace(/\.(js|ts|tsx|jsx)$/, '');
-                return /^[a-z][a-zA-Z]*$/.test(name);
-            });
-            const kebabCaseFiles = jsFiles.filter(f => {
-                const name = f.split('/').pop().replace(/\.(js|ts|tsx|jsx)$/, '');
-                return /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(name);
-            });
-            const pascalCaseFiles = jsFiles.filter(f => {
-                const name = f.split('/').pop().replace(/\.(js|ts|tsx|jsx)$/, '');
-                return /^[A-Z][a-zA-Z]*$/.test(name);
-            });
-
-            if (jsFiles.length > 5) {
-                let namingConvention = 'mixed';
-                let confidence = 0.5;
-                const total = jsFiles.length;
-
-                if (camelCaseFiles.length / total > 0.6) {
-                    namingConvention = 'camelCase';
-                    confidence = camelCaseFiles.length / total;
-                } else if (kebabCaseFiles.length / total > 0.6) {
-                    namingConvention = 'kebab-case';
-                    confidence = kebabCaseFiles.length / total;
-                } else if (pascalCaseFiles.length / total > 0.6) {
-                    namingConvention = 'PascalCase';
-                    confidence = pascalCaseFiles.length / total;
-                }
-
-                if (namingConvention !== 'mixed') {
-                    discoveries.push({
-                        discovery_type: 'naming',
-                        pattern_name: `File naming: ${namingConvention}`,
-                        pattern_description: `${Math.round(confidence * 100)}% of JS/TS files use ${namingConvention} naming`,
-                        confidence: Math.min(confidence, 0.95),
-                        evidence: [{ source: 'file_tree', convention: namingConvention, sample_count: jsFiles.length }]
-                    });
-                }
-            }
-
-            // Detect TypeScript
-            const tsFiles = files.filter(f => f.endsWith('.ts') || f.endsWith('.tsx'));
-            const tsconfigExists = files.some(f => f === 'tsconfig.json');
-            if (tsFiles.length > 0 && tsconfigExists) {
-                discoveries.push({
-                    discovery_type: 'tech_stack',
-                    pattern_name: 'TypeScript enabled',
-                    pattern_description: `Found ${tsFiles.length} TypeScript files with tsconfig.json`,
-                    confidence: 0.95,
-                    evidence: [{ source: 'file_tree', ts_files_count: tsFiles.length }]
-                });
-            }
-        }
-
-        // --- Analyze package.json if available ---
-        const pkgRes = await httpsGet(`/repos/${owner}/${repo}/contents/package.json`, accessToken);
-        if (pkgRes.statusCode === 200 && pkgRes.body?.content) {
-            try {
-                const pkgContent = JSON.parse(Buffer.from(pkgRes.body.content, 'base64').toString());
-
-                // Detect frameworks from dependencies
-                const allDeps = { ...pkgContent.dependencies, ...pkgContent.devDependencies };
-                const frameworks = [];
-
-                if (allDeps['react']) frameworks.push('React');
-                if (allDeps['next']) frameworks.push('Next.js');
-                if (allDeps['vue']) frameworks.push('Vue.js');
-                if (allDeps['express']) frameworks.push('Express');
-                if (allDeps['fastify']) frameworks.push('Fastify');
-                if (allDeps['@angular/core']) frameworks.push('Angular');
-                if (allDeps['svelte']) frameworks.push('Svelte');
-                if (allDeps['tailwindcss']) frameworks.push('Tailwind CSS');
-
-                for (const fw of frameworks) {
-                    discoveries.push({
-                        discovery_type: 'tech_stack',
-                        pattern_name: `Framework: ${fw}`,
-                        pattern_description: `${fw} is listed as a dependency`,
-                        confidence: 0.95,
-                        evidence: [{ source: 'package_json', dependency: fw.toLowerCase() }]
-                    });
-                }
-
-                // Detect test runner from devDeps
-                if (allDeps['jest'] || allDeps['@jest/core']) {
-                    // Only add if not already detected from file tree
-                    if (!discoveries.some(d => d.pattern_name.includes('Jest'))) {
-                        discoveries.push({
-                            discovery_type: 'testing',
-                            pattern_name: 'Test framework: Jest',
-                            pattern_description: 'Jest is configured as a dev dependency',
-                            confidence: 0.9,
-                            evidence: [{ source: 'package_json' }]
-                        });
-                    }
-                }
-            } catch (e) {
-                console.log('Failed to parse package.json:', e.message);
-            }
-        }
-
-        // --- Analyze Commit Patterns ---
-        if (commitsRes.statusCode === 200 && Array.isArray(commitsRes.body)) {
-            const commits = commitsRes.body;
-
-            // Detect conventional commits
-            const conventionalPattern = /^(feat|fix|chore|docs|style|refactor|test|perf|ci|build|revert)(\(.+\))?: /;
-            const conventionalCount = commits.filter(c =>
-                conventionalPattern.test(c.commit?.message || '')
-            ).length;
-
-            if (conventionalCount > commits.length * 0.3) {
-                discoveries.push({
-                    discovery_type: 'naming',
-                    pattern_name: 'Commit convention: Conventional Commits',
-                    pattern_description: `${Math.round(conventionalCount / commits.length * 100)}% of recent commits follow conventional commit format`,
-                    confidence: Math.min(conventionalCount / commits.length, 0.95),
-                    evidence: [{ source: 'commits', conventional_count: conventionalCount, total: commits.length }]
-                });
-            }
-        }
-
-        // --- Deep Code Analysis with LLM ---
-        let llmAnalysis = { success: false, patterns: [], anti_patterns: [], recommendations: [] };
-        let codeSamples = [];
-
-        if (treeRes.statusCode === 200 && treeRes.body?.tree) {
-            try {
-                // Fetch representative code samples
-                codeSamples = await fetchSampleFiles(treeRes.body.tree, accessToken, owner, repo);
-
-                if (codeSamples.length > 0) {
-                    // Build context for LLM
-                    const techStack = discoveries
-                        .filter(d => d.discovery_type === 'tech_stack')
-                        .map(d => d.pattern_name.split(': ').pop());
-
-                    const frameworks = discoveries
-                        .filter(d => d.pattern_name.includes('Framework:'))
-                        .map(d => d.pattern_name.split(': ').pop());
-
-                    llmAnalysis = await analyzeCodeWithLLM(codeSamples, {
-                        repoName: `${owner}/${repo}`,
-                        techStack,
-                        frameworks
-                    });
-
-                    // Add LLM-detected patterns as discoveries
-                    if (llmAnalysis.success && llmAnalysis.patterns) {
-                        for (const pattern of llmAnalysis.patterns) {
-                            discoveries.push({
-                                discovery_type: 'code_pattern',
-                                pattern_name: `${pattern.action}: ${pattern.element}`,
-                                pattern_description: pattern.rule,
-                                confidence: pattern.confidence || 0.8,
-                                evidence: [{
-                                    source: 'llm_analysis',
-                                    category: pattern.category,
-                                    evidence: pattern.evidence
-                                }]
-                            });
-                        }
-                    }
-
-                    // Add anti-patterns as discoveries
-                    if (llmAnalysis.anti_patterns) {
-                        for (const antiPattern of llmAnalysis.anti_patterns) {
-                            discoveries.push({
-                                discovery_type: 'anti_pattern',
-                                pattern_name: `Anti-pattern: ${antiPattern.pattern.substring(0, 50)}`,
-                                pattern_description: `${antiPattern.risk}. Fix: ${antiPattern.fix}`,
-                                confidence: 0.85,
-                                evidence: [{ source: 'llm_analysis', type: 'anti_pattern' }]
-                            });
-                        }
-                    }
-                }
-            } catch (llmError) {
-                console.log('LLM analysis failed (continuing without):', llmError.message);
-            }
-        }
-
-        // Filter out low-confidence discoveries
-        const validDiscoveries = discoveries.filter(d => d.confidence >= 0.3);
-
-        // Generate standards recommendations
-        const recommendedStandards = generateStandardsRecommendations(validDiscoveries, llmAnalysis);
-
-        // Update project with GitHub info
-        await executeQuery(`
-            UPDATE rapport.projects SET github_owner = $1, github_repo = $2
-            WHERE project_id = $3
-        `, [owner, repo, project_id]);
-
-        // Save discoveries to DB and capture generated IDs
-        for (const discovery of validDiscoveries) {
-            const insertResult = await executeQuery(`
-                INSERT INTO rapport.onboarding_discoveries (
-                    project_id, email_address, discovery_type, pattern_name,
-                    pattern_description, confidence, evidence
-                ) VALUES ($1, $2, $3, $4, $5, $6, $7)
-                RETURNING discovery_id
-            `, [
-                project_id, email, discovery.discovery_type, discovery.pattern_name,
-                discovery.pattern_description, discovery.confidence,
-                JSON.stringify(discovery.evidence)
-            ]);
-            discovery.discovery_id = insertResult.rows[0]?.discovery_id;
-        }
-
-        return createSuccessResponse({
-            discoveries: validDiscoveries,
-            count: validDiscoveries.length,
-            llm_analysis: llmAnalysis.success ? {
-                patterns_detected: llmAnalysis.patterns?.length || 0,
-                anti_patterns_detected: llmAnalysis.anti_patterns?.length || 0,
-                tech_summary: llmAnalysis.tech_summary || {}
-            } : null,
-            recommended_standards: recommendedStandards,
-            code_samples_analyzed: codeSamples.length,
-            onboarding_suggestions: recommendedStandards.slice(0, 3).map(r => ({
-                category: r.category,
-                reason: r.reasons[0] || 'Detected in repository'
-            }))
-        }, 'Pattern discovery complete');
-    } catch (error) {
-        console.error('GitHub Discover Patterns Error:', error);
-        return createErrorResponse(500, 'Failed to discover patterns');
-    }
-}
-
-exports.handler = wrapHandler(githubDiscoverPatterns);