@equilateral_ai/mindmeld 3.0.0

package/src/core/LLMPatternDetector.js

@@ -0,0 +1,508 @@
+/**
+ * LLMPatternDetector - LLM-powered pattern detection for Rapport v3
+ *
+ * Uses AWS Bedrock (Claude) to analyze session transcripts and detect:
+ * - Architectural decisions made during coding
+ * - Coding patterns and conventions applied
+ * - Anti-patterns or standards violations
+ * - Semantic intent behind code changes
+ *
+ * Replaces regex-based pattern detection with semantic understanding.
+ *
+ * @module LLMPatternDetector
+ */
+
+const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
+const fs = require('fs').promises;
+const path = require('path');
+
+class LLMPatternDetector {
+    constructor(config = {}) {
+        this.config = {
+            // Bedrock model ID for Claude 3.5 Haiku (cross-region inference profile)
+            model: config.model || 'us.anthropic.claude-3-5-haiku-20241022-v1:0',
+            maxTokens: config.maxTokens || 2048,
+            enabled: config.enabled !== false,
+            cacheEnabled: config.cacheEnabled !== false,
+            cacheTTL: config.cacheTTL || 300000, // 5 minutes
+            region: config.region || 'us-east-2',
+            ...config
+        };
+
+        this.client = null;
+        this.cache = new Map();
+        this.patternExamples = null;
+
+        // Initialize Bedrock client (uses default AWS credentials)
+        try {
+            this.client = new BedrockRuntimeClient({ region: this.config.region });
+        } catch (error) {
+            console.error('[LLMPatternDetector] Failed to initialize Bedrock client:', error.message);
+        }
+    }
+
+    /**
+     * Check if LLM detection is available
+     * Uses AWS Bedrock - no API key needed, uses default AWS credentials
+     */
+    isAvailable() {
+        return this.config.enabled && this.client !== null;
+    }
+
+    /**
+     * Load pattern examples for LLM context
+     */
+    async loadPatternExamples() {
+        if (this.patternExamples) return this.patternExamples;
+
+        try {
+            const examplesPath = path.join(__dirname, '../../docs/PATTERN_EXAMPLES.md');
+            this.patternExamples = await fs.readFile(examplesPath, 'utf-8');
+        } catch (error) {
+            this.patternExamples = '';
+        }
+        return this.patternExamples;
+    }
+
+    /**
+     * Analyze a Claude Code session transcript for patterns
+     *
+     * @param {string} transcript - Full session transcript text
+     * @param {Object} context - Additional context (project, files, etc.)
+     * @returns {Promise<Object>} Detected patterns and analysis
+     */
+    async analyzeSessionTranscript(transcript, context = {}) {
+        if (!this.isAvailable()) {
+            return this.fallbackAnalysis(transcript, context);
+        }
+
+        // Check cache
+        const cacheKey = this.getCacheKey(transcript);
+        if (this.config.cacheEnabled && this.cache.has(cacheKey)) {
+            const cached = this.cache.get(cacheKey);
+            if (Date.now() - cached.timestamp < this.config.cacheTTL) {
+                return cached.result;
+            }
+        }
+
+        try {
+            const result = await this.callLLM(transcript, context);
+
+            // Cache result
+            if (this.config.cacheEnabled) {
+                this.cache.set(cacheKey, {
+                    result,
+                    timestamp: Date.now()
+                });
+            }
+
+            return result;
+        } catch (error) {
+            console.error('[LLMPatternDetector] Analysis error:', error.message);
+            return this.fallbackAnalysis(transcript, context);
+        }
+    }
+
+    /**
+     * Call AWS Bedrock (Claude) for pattern analysis
+     */
+    async callLLM(transcript, context) {
+        const systemPrompt = await this.buildSystemPrompt(context);
+        const userPrompt = this.buildUserPrompt(transcript, context);
+
+        // Bedrock request body for Claude Messages API
+        const requestBody = {
+            anthropic_version: 'bedrock-2023-05-31',
+            max_tokens: this.config.maxTokens,
+            system: systemPrompt,
+            messages: [
+                { role: 'user', content: userPrompt }
+            ]
+        };
+
+        const command = new InvokeModelCommand({
+            modelId: this.config.model,
+            contentType: 'application/json',
+            accept: 'application/json',
+            body: JSON.stringify(requestBody)
+        });
+
+        const response = await this.client.send(command);
+        const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+
+        const content = responseBody.content?.[0]?.text || '';
+        return this.parseResponse(content);
+    }
+
+    /**
+     * Build system prompt for pattern detection
+     */
+    async buildSystemPrompt(context) {
+        const examples = await this.loadPatternExamples();
+        const techStack = context.techStack || 'Node.js, AWS Lambda, PostgreSQL, React';
+
+        return `You are an expert software architecture analyst for MindMeld/Rapport, a team knowledge sharing platform.
+
+Your task is to analyze Claude Code session transcripts and extract:
+1. **Architectural Decisions**: Key decisions made about code structure, patterns, or approaches
+2. **Coding Patterns**: Reusable patterns applied (e.g., error handling, database access, API design)
+3. **Anti-Patterns**: Potential violations of best practices or standards
+4. **Invariants**: Rules that should always be followed based on this session
+
+Context about the codebase:
+- Tech stack: ${techStack}
+- Standards: .equilateral-standards/ (serverless-saas-aws, tim-combo pattern)
+
+Key patterns to detect:
+- Lambda database connections (MUST use cached single client, NEVER pools)
+- API Gateway CORS (NEVER use DefaultAuthorizer)
+- Handler pattern (wrapHandler, executeQuery, createSuccessResponse)
+- Business-scoped IDs (NOT random UUIDs)
+- SSM parameters (NEVER fetch at runtime, use env vars)
+
+${examples ? `\n## Pattern Examples Reference:\n${examples.substring(0, 8000)}` : ''}
+
+Respond ONLY with valid JSON in this exact format:
+{
+  "patterns": [
+    {
+      "element": "Pattern name",
+      "type": "standard|anti_pattern|invariant|architectural_decision",
+      "intent": "What this pattern achieves",
+      "evidence": "Quote or reference from transcript",
+      "confidence": 0.95,
+      "severity": "info|warning|critical",
+      "category": "database|api|security|performance|architecture"
+    }
+  ],
+  "summary": "Brief summary of key patterns detected",
+  "recommendations": ["Actionable recommendations"],
+  "violations": [
+    {
+      "standard": "Which standard was violated",
+      "description": "What the violation is",
+      "fix": "How to fix it"
+    }
+  ]
+}`;
+    }
+
+    /**
+     * Build user prompt with transcript
+     */
+    buildUserPrompt(transcript, context) {
+        // Truncate very long transcripts to stay within token limits
+        const maxLength = 50000;
+        const truncated = transcript.length > maxLength
+            ? transcript.substring(0, maxLength) + '\n\n[... transcript truncated ...]'
+            : transcript;
+
+        const projectName = context.projectName || 'Unknown';
+        const filesChanged = context.filesChanged?.join(', ') || 'Unknown';
+
+        return `Analyze this Claude Code session transcript for patterns, decisions, and potential violations:
+
+---
+PROJECT: ${projectName}
+FILES CHANGED: ${filesChanged}
+---
+
+TRANSCRIPT:
+${truncated}
+
+---
+
+Extract all architectural decisions, coding patterns, anti-patterns, and invariants from this session. Focus on:
+1. Database connection patterns
+2. Error handling approaches
+3. API design decisions
+4. Security considerations
+5. Performance patterns
+
+Respond with JSON only.`;
+    }
+
+    /**
+     * Parse LLM response into structured data
+     */
+    parseResponse(content) {
+        try {
+            // Extract JSON from response (handle markdown code blocks)
+            let jsonStr = content;
+            const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
+            if (jsonMatch) {
+                jsonStr = jsonMatch[1];
+            }
+
+            const parsed = JSON.parse(jsonStr.trim());
+
+            return {
+                success: true,
+                source: 'llm',
+                model: this.config.model,
+                timestamp: new Date().toISOString(),
+                ...parsed
+            };
+        } catch (error) {
+            console.error('[LLMPatternDetector] Failed to parse response:', error.message);
+            return {
+                success: false,
+                source: 'llm',
+                error: 'Failed to parse LLM response',
+                rawContent: content.substring(0, 500),
+                patterns: [],
+                violations: []
+            };
+        }
+    }
+
+    /**
+     * Fallback to regex-based analysis when LLM unavailable
+     */
+    fallbackAnalysis(transcript, context) {
+        const patterns = [];
+
+        // Basic regex patterns (existing logic)
+        const patternMatchers = [
+            {
+                regex: /wrapHandler/g,
+                element: 'Lambda Handler Pattern',
+                type: 'standard',
+                category: 'api',
+                intent: 'Consistent error handling and logging for Lambda functions'
+            },
+            {
+                regex: /executeQuery/g,
+                element: 'Database Query Pattern',
+                type: 'standard',
+                category: 'database',
+                intent: 'Standardized database query execution with error handling'
+            },
+            {
+                regex: /createSuccessResponse/g,
+                element: 'API Response Pattern',
+                type: 'standard',
+                category: 'api',
+                intent: 'Consistent API response format'
+            },
+            {
+                regex: /new Pool\(|createPool/g,
+                element: 'Connection Pool in Lambda',
+                type: 'anti_pattern',
+                category: 'database',
+                severity: 'critical',
+                intent: 'Connection pools are wasteful in Lambda - use cached single client'
+            },
+            {
+                regex: /ssm\.getParameter|GetParameter/g,
+                element: 'SSM Runtime Fetch',
+                type: 'anti_pattern',
+                category: 'performance',
+                severity: 'critical',
+                intent: 'SSM at runtime costs $25/month per million - use env vars'
+            },
+            {
+                regex: /DefaultAuthorizer/g,
+                element: 'DefaultAuthorizer Usage',
+                type: 'anti_pattern',
+                category: 'api',
+                severity: 'critical',
+                intent: 'DefaultAuthorizer breaks CORS preflight'
+            },
+            {
+                regex: /uuid(?:v4)?|randomUUID/gi,
+                element: 'Random UUID for Business ID',
+                type: 'anti_pattern',
+                category: 'architecture',
+                severity: 'warning',
+                intent: 'Use business-scoped IDs, not random UUIDs'
+            },
+            {
+                regex: /console\.log\s*\(/g,
+                element: 'Console.log in Production',
+                type: 'anti_pattern',
+                category: 'performance',
+                severity: 'warning',
+                intent: 'Debug logging should be removed from production code'
+            },
+            {
+                regex: /(password|secret|key)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
+                element: 'Hardcoded Secret',
+                type: 'anti_pattern',
+                category: 'security',
+                severity: 'critical',
+                intent: 'Secrets must come from environment variables, never hardcoded'
+            }
+        ];
+
+        for (const matcher of patternMatchers) {
+            const matches = transcript.match(matcher.regex);
+            if (matches && matches.length > 0) {
+                patterns.push({
+                    element: matcher.element,
+                    type: matcher.type,
+                    intent: matcher.intent,
+                    category: matcher.category,
+                    severity: matcher.severity || 'info',
+                    confidence: 0.7, // Lower confidence for regex matches
+                    evidence: `Found ${matches.length} occurrence(s)`,
+                    matchCount: matches.length
+                });
+            }
+        }
+
+        return {
+            success: true,
+            source: 'fallback_regex',
+            timestamp: new Date().toISOString(),
+            patterns,
+            summary: `Detected ${patterns.length} patterns using regex fallback`,
+            violations: patterns.filter(p => p.type === 'anti_pattern'),
+            recommendations: []
+        };
+    }
+
+    /**
+     * Generate cache key from transcript
+     */
+    getCacheKey(transcript) {
+        // Simple hash based on length and sample content
+        const sample = transcript.substring(0, 1000) + transcript.slice(-1000);
+        let hash = 0;
+        for (let i = 0; i < sample.length; i++) {
+            const char = sample.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return `session_${hash}_${transcript.length}`;
+    }
+
+    /**
+     * Analyze code content for patterns (standalone file analysis)
+     */
+    async analyzeCode(code, filename, context = {}) {
+        if (!this.isAvailable()) {
+            return this.fallbackAnalysis(code, context);
+        }
+
+        const codeSnippet = code.substring(0, 10000);
+
+        const prompt = `Analyze this code file for patterns and potential issues:
+
+FILE: ${filename}
+CONTEXT: ${context.projectName || 'Unknown project'}
+
+\`\`\`
+${codeSnippet}
+\`\`\`
+
+Focus on:
+1. Adherence to Lambda database standards (no pools, cached client)
+2. Error handling patterns
+3. Security issues (hardcoded secrets, SQL injection)
+4. Performance anti-patterns
+
+Respond with JSON containing patterns and violations.`;
+
+        try {
+            const systemPrompt = await this.buildSystemPrompt(context);
+
+            const requestBody = {
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: 1024,
+                system: systemPrompt,
+                messages: [{ role: 'user', content: prompt }]
+            };
+
+            const command = new InvokeModelCommand({
+                modelId: this.config.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(requestBody)
+            });
+
+            const response = await this.client.send(command);
+            const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+
+            return this.parseResponse(responseBody.content?.[0]?.text || '');
+        } catch (error) {
+            console.error('[LLMPatternDetector] Code analysis error:', error.message);
+            return this.fallbackAnalysis(code, context);
+        }
+    }
+
+    /**
+     * Extract invariants from session patterns
+     * Returns patterns that should become team invariants
+     */
+    extractInvariants(analysisResult) {
+        if (!analysisResult.success || !analysisResult.patterns) {
+            return [];
+        }
+
+        return analysisResult.patterns
+            .filter(p =>
+                p.type === 'invariant' ||
+                (p.type === 'anti_pattern' && p.severity === 'critical') ||
+                (p.confidence >= 0.9 && p.type === 'standard')
+            )
+            .map(p => ({
+                element: p.element,
+                rule: p.intent,
+                severity: p.severity || 'info',
+                source: 'llm_detected',
+                confidence: p.confidence,
+                evidence: p.evidence
+            }));
+    }
+
+    /**
+     * Summarize session for team learning
+     */
+    async summarizeSession(transcript, context = {}) {
+        if (!this.isAvailable()) {
+            return { summary: 'LLM not available for summarization' };
+        }
+
+        const prompt = `Summarize this Claude Code session in 2-3 sentences, focusing on:
+1. What was accomplished
+2. Key architectural decisions made
+3. Any patterns or invariants established
+
+TRANSCRIPT:
+${transcript.substring(0, 20000)}
+
+Respond with a JSON object: { "summary": "...", "keyDecisions": ["..."], "newPatterns": ["..."] }`;
+
+        try {
+            const requestBody = {
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: 512,
+                messages: [{ role: 'user', content: prompt }]
+            };
+
+            const command = new InvokeModelCommand({
+                modelId: this.config.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(requestBody)
+            });
+
+            const response = await this.client.send(command);
+            const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+
+            return this.parseResponse(responseBody.content?.[0]?.text || '');
+        } catch (error) {
+            return { summary: 'Failed to summarize session', error: error.message };
+        }
+    }
+
+    /**
+     * Clear cache (for testing or memory management)
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+}
+
+module.exports = { LLMPatternDetector };