@equilateral_ai/mindmeld 3.5.3 → 4.0.2

package/src/handlers/scheduled/maturityUpdateJob.js

@@ -1,166 +0,0 @@
-/**
- * Maturity Update Scheduled Job
- * Auto-progresses/demotes standards maturity based on 30-day compliance evidence
- *
- * Schedule: Daily
- * Auth: None (Lambda scheduled event)
- *
- * Maturity progression rules (based on session_standards compliance data):
- * - >90% followed + >50 sessions → enforced
- * - >70% followed + >20 sessions → validated
- * - <30% followed + >20 sessions → demote to provisional
- *
- * Records all transitions in standards_audit_trail for traceability
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
-
-/**
- * Main handler
- */
-exports.handler = wrapHandler(async (event, context) => {
-    console.log('[MaturityUpdateJob] Starting maturity auto-progression...');
-
-    const lookbackDays = (event && event.lookbackDays) || 30;
-    const dryRun = (event && event.dryRun) || false;
-
-    const summary = {
-        startedAt: new Date().toISOString(),
-        standardsEvaluated: 0,
-        promotions: 0,
-        demotions: 0,
-        unchanged: 0,
-        transitions: [],
-        errors: []
-    };
-
-    try {
-        // Query 30-day compliance rates per standard from session_standards
-        const complianceQuery = `
-            SELECT
-                ss.standard_id,
-                ss.standard_name,
-                COUNT(*) as total_sessions,
-                COUNT(*) FILTER (WHERE ss.followed = true) as followed_count,
-                COUNT(*) FILTER (WHERE ss.violated = true) as violated_count,
-                ROUND(
-                    COUNT(*) FILTER (WHERE ss.followed = true)::decimal /
-                    NULLIF(COUNT(*), 0),
-                    3
-                ) as follow_rate,
-                sp.maturity as current_maturity
-            FROM rapport.session_standards ss
-            LEFT JOIN rapport.standards_patterns sp ON sp.pattern_id = ss.standard_id
-            WHERE ss.shown_at > NOW() - INTERVAL '${lookbackDays} days'
-            GROUP BY ss.standard_id, ss.standard_name, sp.maturity
-            HAVING COUNT(*) >= 10
-            ORDER BY total_sessions DESC
-        `;
-
-        const complianceResult = await executeQuery(complianceQuery);
-        const standards = complianceResult.rows;
-
-        summary.standardsEvaluated = standards.length;
-        console.log(`[MaturityUpdateJob] Evaluating ${standards.length} standards with sufficient data`);
-
-        for (const standard of standards) {
-            const totalSessions = parseInt(standard.total_sessions);
-            const followRate = parseFloat(standard.follow_rate) || 0;
-            const currentMaturity = standard.current_maturity || 'provisional';
-
-            // Determine target maturity
-            let targetMaturity = currentMaturity;
-
-            if (followRate > 0.90 && totalSessions >= 50) {
-                targetMaturity = 'enforced';
-            } else if (followRate > 0.70 && totalSessions >= 20) {
-                targetMaturity = 'validated';
-            } else if (followRate < 0.30 && totalSessions >= 20) {
-                targetMaturity = 'provisional';
-            }
-
-            if (targetMaturity === currentMaturity) {
-                summary.unchanged++;
-                continue;
-            }
-
-            // Determine if this is a promotion or demotion
-            const maturityOrder = { provisional: 0, validated: 1, reinforced: 2, enforced: 3 };
-            const isPromotion = (maturityOrder[targetMaturity] || 0) > (maturityOrder[currentMaturity] || 0);
-
-            const transition = {
-                standard_id: standard.standard_id,
-                standard_name: standard.standard_name,
-                from: currentMaturity,
-                to: targetMaturity,
-                direction: isPromotion ? 'promotion' : 'demotion',
-                follow_rate: followRate,
-                total_sessions: totalSessions
-            };
-
-            summary.transitions.push(transition);
-
-            if (dryRun) {
-                console.log(`[MaturityUpdateJob] DRY RUN: Would ${transition.direction} ${standard.standard_id}: ${currentMaturity} → ${targetMaturity} (${(followRate * 100).toFixed(1)}% followed, ${totalSessions} sessions)`);
-                if (isPromotion) summary.promotions++;
-                else summary.demotions++;
-                continue;
-            }
-
-            try {
-                // Update standards_patterns maturity
-                await executeQuery(`
-                    UPDATE rapport.standards_patterns
-                    SET maturity = $1, last_updated = NOW()
-                    WHERE pattern_id = $2
-                `, [targetMaturity, standard.standard_id]);
-
-                // Record in audit trail
-                await executeQuery(`
-                    INSERT INTO rapport.standards_audit_trail (
-                        standard_id, action, old_state, new_state,
-                        user_email, reason, metadata, created_at
-                    ) VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())
-                `, [
-                    standard.standard_id,
-                    isPromotion ? 'auto_promote' : 'auto_demote',
-                    currentMaturity,
-                    targetMaturity,
-                    'system@mindmeld.dev',
-                    `Auto-${transition.direction}: ${(followRate * 100).toFixed(1)}% follow rate across ${totalSessions} sessions (30-day window)`,
-                    JSON.stringify({
-                        follow_rate: followRate,
-                        total_sessions: totalSessions,
-                        followed_count: parseInt(standard.followed_count),
-                        violated_count: parseInt(standard.violated_count),
-                        lookback_days: lookbackDays
-                    })
-                ]);
-
-                if (isPromotion) summary.promotions++;
-                else summary.demotions++;
-
-                console.log(`[MaturityUpdateJob] ${transition.direction}: ${standard.standard_id} ${currentMaturity} → ${targetMaturity}`);
-
-            } catch (error) {
-                console.error(`[MaturityUpdateJob] Error updating ${standard.standard_id}:`, error.message);
-                summary.errors.push({
-                    standard_id: standard.standard_id,
-                    error: error.message
-                });
-            }
-        }
-
-    } catch (error) {
-        console.error('[MaturityUpdateJob] Job failed:', error);
-        summary.errors.push({ step: 'main', error: error.message });
-    }
-
-    summary.completedAt = new Date().toISOString();
-    console.log(`[MaturityUpdateJob] Complete: ${summary.promotions} promotions, ${summary.demotions} demotions, ${summary.unchanged} unchanged`);
-
-    return createSuccessResponse(
-        summary,
-        `Maturity update complete: ${summary.promotions} promotions, ${summary.demotions} demotions`
-    );
-});

package/src/handlers/scheduled/refreshActivity.js

@@ -1,21 +0,0 @@
-/**
- * Refresh Activity Scheduled Job
- * Refreshes materialized views for developer and project activity
- *
- * Schedule: Every 15 minutes
- * Auth: None (Lambda scheduled event)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
-
-exports.handler = wrapHandler(async (event, context) => {
-    // Refresh developer activity view
-    await executeQuery('SELECT rapport.refresh_developer_activity()');
-
-    // Refresh project activity view
-    await executeQuery('SELECT rapport.refresh_project_activity()');
-
-    return createSuccessResponse({
-        views_refreshed: ['developer_activity', 'project_activity']
-    }, 'Activity views refreshed');
-});

package/src/handlers/scheduled/scanCompliance.js

@@ -1,334 +0,0 @@
-/**
- * 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

@@ -1,180 +0,0 @@
-/**
- * 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);