@equilateral_ai/mindmeld 3.0.0

package/src/handlers/scheduled/scanCompliance.js

@@ -0,0 +1,334 @@
+/**
+ * Standards Compliance Scanner
+ * Scans committed code for standards patterns and anti-patterns
+ *
+ * Schedule: Daily after git history analysis
+ * Auth: None (Lambda scheduled event)
+ *
+ * Requires: GitHub token with contents:read permission
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
+const https = require('https');
+
+exports.handler = wrapHandler(async (event, context) => {
+    // Check if GitHub token is available
+    if (!process.env.GITHUB_TOKEN) {
+        return createSuccessResponse({ scanned: false }, 'Compliance scan skipped - no GitHub token');
+    }
+
+    // Get patterns to scan for
+    const patterns = await getActivePatterns();
+
+    // Get recent commits that need scanning
+    const commits = await getUnscannedCommits();
+
+    if (commits.length === 0) {
+        return createSuccessResponse({ scanned: 0 }, 'No commits to scan');
+    }
+
+    const results = {
+        commits_scanned: 0,
+        files_scanned: 0,
+        patterns_found: 0,
+        anti_patterns_found: 0
+    };
+
+    for (const commit of commits) {
+        try {
+            const scanResult = await scanCommit(commit, patterns);
+            results.commits_scanned++;
+            results.files_scanned += scanResult.files_scanned;
+            results.patterns_found += scanResult.patterns_found;
+            results.anti_patterns_found += scanResult.anti_patterns_found;
+
+            // Update developer metrics with compliance data
+            await updateComplianceMetrics(commit, scanResult);
+
+        } catch (error) {
+            // Continue scanning other commits even if one fails
+        }
+    }
+
+    // Refresh team summary view
+    await executeQuery('SELECT rapport.refresh_team_summary()');
+
+    return createSuccessResponse(results, 'Compliance scan complete');
+});
+
+/**
+ * Get active patterns from database
+ */
+async function getActivePatterns() {
+    const result = await executeQuery(`
+        SELECT pattern_id, pattern_name, pattern_type, language,
+               regex_pattern, severity, source
+        FROM rapport.code_patterns
+        WHERE enabled = true
+    `);
+    return result.rows;
+}
+
+/**
+ * Get commits that haven't been scanned yet
+ */
+async function getUnscannedCommits() {
+    const result = await executeQuery(`
+        SELECT c.commit_sha, c.repo_id, c.author_email,
+               r.repo_url, r.repo_name
+        FROM rapport.commits c
+        JOIN rapport.git_repositories r ON c.repo_id = r.repo_id
+        WHERE c.scanned_at IS NULL
+        AND c.committed_at >= NOW() - INTERVAL '7 days'
+        ORDER BY c.committed_at DESC
+        LIMIT 100
+    `);
+    return result.rows;
+}
+
+/**
+ * Scan a single commit for patterns
+ */
+async function scanCommit(commit, patterns) {
+    const result = {
+        files_scanned: 0,
+        patterns_found: 0,
+        anti_patterns_found: 0,
+        findings: []
+    };
+
+    // Parse owner/repo from URL
+    const match = commit.repo_url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (!match) {
+        console.warn(`Cannot parse GitHub URL: ${commit.repo_url}`);
+        return result;
+    }
+
+    const [, owner, repoName] = match;
+
+    // Get commit details with file changes
+    const commitDetails = await fetchCommitDetails(owner, repoName, commit.commit_sha);
+    if (!commitDetails || !commitDetails.files) {
+        return result;
+    }
+
+    for (const file of commitDetails.files) {
+        // Skip non-code files
+        if (!isCodeFile(file.filename)) continue;
+
+        // Get file content
+        const content = await fetchFileContent(owner, repoName, commit.commit_sha, file.filename);
+        if (!content) continue;
+
+        result.files_scanned++;
+
+        // Detect language from extension
+        const language = detectLanguage(file.filename);
+
+        // Scan for patterns
+        const relevantPatterns = patterns.filter(p =>
+            p.language === language || p.language === 'any'
+        );
+
+        for (const pattern of relevantPatterns) {
+            try {
+                const regex = new RegExp(pattern.regex_pattern, 'gm');
+                const matches = content.match(regex);
+
+                if (matches && matches.length > 0) {
+                    if (pattern.pattern_type === 'standard') {
+                        result.patterns_found += matches.length;
+                    } else {
+                        result.anti_patterns_found += matches.length;
+                    }
+
+                    result.findings.push({
+                        file: file.filename,
+                        pattern_name: pattern.pattern_name,
+                        pattern_type: pattern.pattern_type,
+                        severity: pattern.severity,
+                        count: matches.length
+                    });
+                }
+            } catch (regexError) {
+                console.warn(`Invalid regex for pattern ${pattern.pattern_name}:`, regexError.message);
+            }
+        }
+    }
+
+    // Mark commit as scanned
+    await executeQuery(`
+        UPDATE rapport.commits
+        SET scanned_at = NOW(),
+            compliance_data = $2
+        WHERE commit_sha = $1
+    `, [commit.commit_sha, JSON.stringify(result.findings)]);
+
+    return result;
+}
+
+/**
+ * Fetch commit details from GitHub API
+ */
+async function fetchCommitDetails(owner, repo, sha) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: 'api.github.com',
+            path: `/repos/${owner}/${repo}/commits/${sha}`,
+            method: 'GET',
+            headers: {
+                'User-Agent': 'MindMeld-ComplianceScanner/1.0',
+                'Accept': 'application/vnd.github.v3+json',
+                'Authorization': `token ${process.env.GITHUB_TOKEN}`
+            },
+            timeout: 30000
+        };
+
+        const req = https.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    if (res.statusCode !== 200) {
+                        console.warn(`GitHub API returned ${res.statusCode} for commit ${sha}`);
+                        resolve(null);
+                        return;
+                    }
+                    resolve(JSON.parse(data));
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('GitHub API timeout'));
+        });
+
+        req.end();
+    });
+}
+
+/**
+ * Fetch file content from GitHub API
+ */
+async function fetchFileContent(owner, repo, sha, path) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: 'api.github.com',
+            path: `/repos/${owner}/${repo}/contents/${encodeURIComponent(path)}?ref=${sha}`,
+            method: 'GET',
+            headers: {
+                'User-Agent': 'MindMeld-ComplianceScanner/1.0',
+                'Accept': 'application/vnd.github.v3.raw',
+                'Authorization': `token ${process.env.GITHUB_TOKEN}`
+            },
+            timeout: 30000
+        };
+
+        const req = https.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode !== 200) {
+                    resolve(null);
+                    return;
+                }
+                resolve(data);
+            });
+        });
+
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(null);
+        });
+
+        req.end();
+    });
+}
+
+/**
+ * Check if file is a code file worth scanning
+ */
+function isCodeFile(filename) {
+    const codeExtensions = [
+        '.js', '.ts', '.tsx', '.jsx',
+        '.py', '.pyw',
+        '.go',
+        '.java',
+        '.rb',
+        '.php',
+        '.cs',
+        '.swift',
+        '.kt', '.kts',
+        '.rs',
+        '.c', '.cpp', '.h', '.hpp',
+        '.sql',
+        '.yaml', '.yml'
+    ];
+    return codeExtensions.some(ext => filename.endsWith(ext));
+}
+
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(filename) {
+    const ext = filename.split('.').pop().toLowerCase();
+    const languageMap = {
+        'js': 'javascript',
+        'jsx': 'javascript',
+        'ts': 'javascript',
+        'tsx': 'javascript',
+        'py': 'python',
+        'pyw': 'python',
+        'go': 'go',
+        'java': 'java',
+        'rb': 'ruby',
+        'php': 'php',
+        'cs': 'csharp',
+        'swift': 'swift',
+        'kt': 'kotlin',
+        'kts': 'kotlin',
+        'rs': 'rust',
+        'c': 'c',
+        'cpp': 'cpp',
+        'h': 'c',
+        'hpp': 'cpp',
+        'sql': 'sql',
+        'yaml': 'yaml',
+        'yml': 'yaml'
+    };
+    return languageMap[ext] || 'unknown';
+}
+
+/**
+ * Update developer metrics with compliance data
+ */
+async function updateComplianceMetrics(commit, scanResult) {
+    const isCompliant = scanResult.anti_patterns_found === 0 && scanResult.patterns_found > 0;
+
+    await executeQuery(`
+        UPDATE rapport.developer_metrics
+        SET
+            standards_compliant_commits = standards_compliant_commits + $3,
+            anti_pattern_commits = anti_pattern_commits + $4,
+            compliance_score = CASE
+                WHEN commit_count > 0 THEN
+                    (standards_compliant_commits + $3)::DECIMAL / commit_count * 100
+                ELSE 0
+            END
+        WHERE repo_id = $1
+        AND developer_email = $2
+        AND period_end >= CURRENT_DATE
+    `, [
+        commit.repo_id,
+        commit.author_email,
+        isCompliant ? 1 : 0,
+        scanResult.anti_patterns_found > 0 ? 1 : 0
+    ]);
+}
+
+// Removed manual success/failure helpers - using wrapHandler pattern

package/src/handlers/sessions/sessionEndPost.js

@@ -0,0 +1,180 @@
+/**
+ * Session End Handler
+ * Records session completion and outcomes
+ *
+ * POST /api/sessions/end
+ * Body: { session_id, project_id?, user_id?, patterns_used, patterns_learned, duration_seconds?, session_data? }
+ *
+ * Called by: pre-compact.js hook at end of session
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Record session end and update metrics
+ */
+async function recordSessionEnd({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext?.requestId || 'unknown';
+
+        const {
+            session_id,
+            project_id,
+            user_id,
+            patterns_used = 0,
+            patterns_learned = 0,
+            duration_seconds,
+            working_directory,
+            git_branch,
+            session_data = {}
+        } = requestBody;
+
+        // Validate required fields
+        if (!session_id) {
+            return createErrorResponse(400, 'session_id is required');
+        }
+
+        // Try to update existing session, or create if not exists
+        const upsertQuery = `
+            INSERT INTO rapport.sessions (
+                session_id,
+                project_id,
+                email_address,
+                started_at,
+                ended_at,
+                duration_seconds,
+                working_directory,
+                git_branch,
+                patterns_used,
+                patterns_learned,
+                session_data
+            ) VALUES (
+                $1, $2, $3,
+                NOW() - INTERVAL '1 second' * COALESCE($4, 0),
+                NOW(),
+                $4, $5, $6, $7, $8, $9
+            )
+            ON CONFLICT (session_id) DO UPDATE SET
+                ended_at = NOW(),
+                duration_seconds = COALESCE(EXCLUDED.duration_seconds,
+                    EXTRACT(EPOCH FROM (NOW() - rapport.sessions.started_at))::INTEGER),
+                working_directory = COALESCE(EXCLUDED.working_directory, rapport.sessions.working_directory),
+                git_branch = COALESCE(EXCLUDED.git_branch, rapport.sessions.git_branch),
+                patterns_used = EXCLUDED.patterns_used,
+                patterns_learned = EXCLUDED.patterns_learned,
+                session_data = rapport.sessions.session_data || EXCLUDED.session_data
+            RETURNING
+                session_id,
+                project_id,
+                email_address,
+                started_at,
+                ended_at,
+                duration_seconds,
+                patterns_used,
+                patterns_learned
+        `;
+
+        let result;
+        try {
+            result = await executeQuery(upsertQuery, [
+                session_id,
+                project_id || null,
+                user_id || 'anonymous',
+                duration_seconds || null,
+                working_directory || null,
+                git_branch || null,
+                patterns_used,
+                patterns_learned,
+                JSON.stringify(session_data)
+            ]);
+        } catch (insertError) {
+            // FK constraint likely failed (project_id or user doesn't exist)
+            console.error('[sessionEndPost] Session upsert failed:', insertError.message);
+
+            // Return success anyway - we tried
+            return createSuccessResponse(
+                {
+                    Records: [{
+                        session_id,
+                        recorded: false,
+                        error: 'Session record failed - project or user not found'
+                    }]
+                },
+                'Session end recorded (without DB record)',
+                {
+                    Request_ID,
+                    Timestamp: new Date().toISOString()
+                }
+            );
+        }
+
+        const session = result.rows[0];
+
+        // Update session_standards to mark followed (standards shown but not violated)
+        const updateFollowedQuery = `
+            UPDATE rapport.session_standards
+            SET followed = CASE WHEN violated IS NULL OR violated = false THEN true ELSE false END
+            WHERE session_id = $1 AND followed IS NULL
+        `;
+
+        try {
+            await executeQuery(updateFollowedQuery, [session_id]);
+        } catch (updateError) {
+            // Non-critical - just log
+            console.error('[sessionEndPost] Failed to update followed status:', updateError.message);
+        }
+
+        // Get summary of standards compliance for this session
+        const complianceQuery = `
+            SELECT
+                COUNT(*) as total_shown,
+                COUNT(*) FILTER (WHERE followed = true) as followed,
+                COUNT(*) FILTER (WHERE violated = true) as violated
+            FROM rapport.session_standards
+            WHERE session_id = $1
+        `;
+
+        let compliance = { total_shown: 0, followed: 0, violated: 0 };
+        try {
+            const complianceResult = await executeQuery(complianceQuery, [session_id]);
+            if (complianceResult.rows.length > 0) {
+                compliance = complianceResult.rows[0];
+            }
+        } catch (complianceError) {
+            // Non-critical
+        }
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    session_id: session.session_id,
+                    project_id: session.project_id,
+                    email_address: session.email_address,
+                    started_at: session.started_at,
+                    ended_at: session.ended_at,
+                    duration_seconds: session.duration_seconds,
+                    patterns_used: session.patterns_used,
+                    patterns_learned: session.patterns_learned,
+                    standards_compliance: {
+                        total_shown: parseInt(compliance.total_shown) || 0,
+                        followed: parseInt(compliance.followed) || 0,
+                        violated: parseInt(compliance.violated) || 0
+                    },
+                    recorded: true
+                }]
+            },
+            'Session end recorded',
+            {
+                Total_Records: 1,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(recordSessionEnd);

package/src/handlers/sessions/sessionStandardsPost.js

@@ -0,0 +1,135 @@
+/**
+ * Session Standards Handler
+ * Records which standards were shown during a Claude Code session
+ *
+ * POST /api/sessions/standards
+ * Body: { session_id, standards[], project_id?, user_id? }
+ *
+ * Called by: session-start.js hook (recordStandardsShown method)
+ * Fire-and-forget - should not block session start
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Record standards shown during session
+ * Creates session record if needed, then records standards
+ */
+async function recordSessionStandards({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext?.requestId || 'unknown';
+
+        const {
+            session_id,
+            standards = [],
+            project_id,
+            user_id
+        } = requestBody;
+
+        // Validate required fields
+        if (!session_id) {
+            return createErrorResponse(400, 'session_id is required');
+        }
+
+        if (!standards || standards.length === 0) {
+            // Not an error - just nothing to record
+            return createSuccessResponse(
+                { Records: [], recorded: 0 },
+                'No standards to record',
+                { Request_ID, Timestamp: new Date().toISOString() }
+            );
+        }
+
+        // Try to ensure session exists (upsert with minimal data)
+        // This may fail if project_id is not provided or invalid - that's OK
+        if (project_id && user_id) {
+            const sessionUpsertQuery = `
+                INSERT INTO rapport.sessions (
+                    session_id,
+                    project_id,
+                    email_address,
+                    started_at,
+                    session_data
+                ) VALUES (
+                    $1, $2, $3, NOW(), '{}'::jsonb
+                )
+                ON CONFLICT (session_id) DO NOTHING
+            `;
+
+            try {
+                await executeQuery(sessionUpsertQuery, [session_id, project_id, user_id]);
+            } catch (sessionError) {
+                // Session insert failed (FK constraint probably)
+                // Continue anyway - we'll try to record standards
+                console.error('[sessionStandardsPost] Session upsert failed:', sessionError.message);
+            }
+        }
+
+        // Record each standard shown
+        const recordedStandards = [];
+        let errors = 0;
+
+        for (const standard of standards) {
+            const standardId = standard.pattern_id || standard.element;
+            const relevanceScore = standard.relevance_score || standard.score || 0;
+
+            if (!standardId) {
+                errors++;
+                continue;
+            }
+
+            const insertQuery = `
+                INSERT INTO rapport.session_standards (
+                    session_id,
+                    standard_id,
+                    relevance_score,
+                    shown_at
+                ) VALUES (
+                    $1, $2, $3, NOW()
+                )
+                ON CONFLICT (session_id, standard_id) DO UPDATE SET
+                    relevance_score = EXCLUDED.relevance_score,
+                    shown_at = NOW()
+                RETURNING id
+            `;
+
+            try {
+                const result = await executeQuery(insertQuery, [
+                    session_id,
+                    standardId,
+                    relevanceScore
+                ]);
+
+                recordedStandards.push({
+                    id: result.rows[0]?.id,
+                    standard_id: standardId,
+                    relevance_score: relevanceScore
+                });
+            } catch (insertError) {
+                // Standard might not exist or FK constraint failed
+                console.error(`[sessionStandardsPost] Failed to record standard ${standardId}:`, insertError.message);
+                errors++;
+            }
+        }
+
+        return createSuccessResponse(
+            {
+                Records: recordedStandards,
+                recorded: recordedStandards.length,
+                errors: errors
+            },
+            `Recorded ${recordedStandards.length} standard(s)`,
+            {
+                Total_Records: recordedStandards.length,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(recordSessionStandards);