@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/handlers/reports/standardsRoi.js

@@ -1,254 +0,0 @@
-/**
- * Standards ROI Report Handler
- * Our key differentiator - correlation between standards and code quality
- *
- * GET /api/reports/standards-roi
- * Query: ?period=7d|30d|90d&Company_ID=xxx
- * Auth: Cognito JWT required, Manager or Admin role
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-exports.handler = wrapHandler(async ({ requestContext, queryStringParameters }) => {
-    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-    if (!email) {
-        return createErrorResponse(401, 'Unauthorized');
-    }
-
-    const params = queryStringParameters || {};
-    const period = params.period || '30d';
-    const companyId = params.Company_ID;
-
-    // Validate access - must be manager/admin
-    const accessCheck = await executeQuery(`
-        SELECT ue.company_id
-        FROM rapport.user_entitlements ue
-        WHERE ue.email_address = $1
-        AND (ue.admin = true OR ue.manager = true)
-        ${companyId ? 'AND ue.company_id = $2' : ''}
-        LIMIT 1
-    `, companyId ? [email, companyId] : [email]);
-
-    if (accessCheck.rows.length === 0) {
-        return createErrorResponse(403, 'Manager or Admin access required');
-    }
-
-    const userCompanyId = companyId || accessCheck.rows[0].company_id;
-    const periodDays = parsePeriod(period);
-    const periodStart = new Date();
-    periodStart.setDate(periodStart.getDate() - periodDays);
-
-    // Standards compliance by developer (from developer_metrics)
-    let compliance = { rows: [] };
-    try {
-        compliance = await executeQuery(`
-            SELECT
-                dm.developer_email,
-                dm.developer_name,
-                SUM(dm.commit_count) as total_commits,
-                SUM(dm.standards_compliant_commits) as compliant_commits,
-                AVG(dm.compliance_score) as avg_compliance_score,
-                SUM(dm.anti_pattern_commits) as anti_pattern_commits
-            FROM rapport.developer_metrics dm
-            JOIN rapport.git_repositories r ON dm.repo_id = r.repo_id
-            WHERE r.company_id = $1
-            AND dm.period_start >= $2
-            GROUP BY dm.developer_email, dm.developer_name
-            HAVING SUM(dm.commit_count) > 0
-            ORDER BY avg_compliance_score DESC NULLS LAST
-        `, [userCompanyId, periodStart]);
-    } catch (e) {
-        // Table might not have data yet
-    }
-
-    // Code patterns detected
-    let patterns = { rows: [] };
-    try {
-        patterns = await executeQuery(`
-            SELECT
-                cp.pattern_name,
-                cp.pattern_type,
-                cp.severity,
-                cp.language,
-                cp.description
-            FROM rapport.code_patterns cp
-            WHERE cp.enabled = true
-            ORDER BY cp.pattern_type, cp.severity
-            LIMIT 20
-        `, []);
-    } catch (e) {
-        // Table might not exist
-    }
-
-    // Calculate summary metrics
-    const complianceData = compliance.rows;
-    const avgCompliance = complianceData.length > 0
-        ? complianceData.reduce((sum, r) => sum + parseFloat(r.avg_compliance_score || 0), 0) / complianceData.length
-        : 0;
-
-    const totalCommits = complianceData.reduce((sum, r) => sum + parseInt(r.total_commits || 0), 0);
-    const compliantCommits = complianceData.reduce((sum, r) => sum + parseInt(r.compliant_commits || 0), 0);
-    const antiPatternCommits = complianceData.reduce((sum, r) => sum + parseInt(r.anti_pattern_commits || 0), 0);
-
-    // Get standards shown count from session_standards
-    let standardsShown = 0;
-    try {
-        const shownResult = await executeQuery(`
-            SELECT COUNT(*) as total
-            FROM rapport.session_standards ss
-            JOIN rapport.sessions s ON ss.session_id = s.session_id
-            JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE p.company_id = $1
-            AND s.started_at >= $2
-        `, [userCompanyId, periodStart]);
-        standardsShown = parseInt(shownResult.rows[0]?.total) || 0;
-    } catch (e) {
-        // Table might not have data
-    }
-
-    // Adoption trend — standards injected per day
-    let adoptionTrend = [];
-    try {
-        const trendResult = await executeQuery(`
-            SELECT
-                DATE(ss.created_at) as date,
-                COUNT(*) as standards_shown,
-                COUNT(DISTINCT ss.session_id) as sessions,
-                COUNT(CASE WHEN ss.followed = true THEN 1 END) as followed,
-                COUNT(CASE WHEN ss.violated = true THEN 1 END) as violated
-            FROM rapport.session_standards ss
-            JOIN rapport.sessions s ON ss.session_id = s.session_id
-            JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE p.company_id = $1
-            AND ss.created_at >= $2
-            GROUP BY DATE(ss.created_at)
-            ORDER BY date
-        `, [userCompanyId, periodStart]);
-        adoptionTrend = trendResult.rows;
-    } catch (e) {
-        // Table might not have data
-    }
-
-    // Top standards — most frequently injected
-    let topStandards = [];
-    try {
-        const topResult = await executeQuery(`
-            SELECT
-                ss.standard_id,
-                ss.standard_name,
-                COUNT(*) as times_shown,
-                COUNT(DISTINCT ss.session_id) as unique_sessions,
-                ROUND(AVG(ss.relevance_score), 2) as avg_relevance,
-                COUNT(CASE WHEN ss.followed = true THEN 1 END) as times_followed,
-                COUNT(CASE WHEN ss.violated = true THEN 1 END) as times_violated
-            FROM rapport.session_standards ss
-            JOIN rapport.sessions s ON ss.session_id = s.session_id
-            JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE p.company_id = $1
-            AND ss.created_at >= $2
-            GROUP BY ss.standard_id, ss.standard_name
-            ORDER BY times_shown DESC
-            LIMIT 10
-        `, [userCompanyId, periodStart]);
-        topStandards = topResult.rows;
-    } catch (e) {
-        // Table might not have data
-    }
-
-    // Anti-patterns detected — standards that were violated
-    let antiPatternsDetected = [];
-    try {
-        const violationResult = await executeQuery(`
-            SELECT
-                ss.standard_id,
-                ss.standard_name,
-                COUNT(*) as violation_count,
-                MAX(ss.created_at) as last_violated
-            FROM rapport.session_standards ss
-            JOIN rapport.sessions s ON ss.session_id = s.session_id
-            JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE p.company_id = $1
-            AND ss.created_at >= $2
-            AND ss.violated = true
-            GROUP BY ss.standard_id, ss.standard_name
-            ORDER BY violation_count DESC
-            LIMIT 10
-        `, [userCompanyId, periodStart]);
-        antiPatternsDetected = violationResult.rows;
-    } catch (e) {
-        // Table might not have data
-    }
-
-    return createSuccessResponse({
-        report_type: 'standards_roi',
-        period: period,
-        period_start: periodStart.toISOString(),
-        period_end: new Date().toISOString(),
-        summary: {
-            avg_compliance_score: avgCompliance.toFixed(1),
-            total_commits: totalCommits,
-            compliant_commits: compliantCommits,
-            compliance_rate: totalCommits > 0 ? ((compliantCommits / totalCommits) * 100).toFixed(1) : '0',
-            anti_pattern_commits: antiPatternCommits,
-            anti_pattern_rate: totalCommits > 0 ? ((antiPatternCommits / totalCommits) * 100).toFixed(1) : '0',
-            standards_shown: standardsShown
-        },
-        adoption_trend: adoptionTrend,
-        compliance_by_developer: complianceData,
-        top_standards: topStandards,
-        anti_patterns_detected: antiPatternsDetected,
-        configured_patterns: patterns.rows.filter(p => p.pattern_type === 'standard'),
-        anti_patterns: patterns.rows.filter(p => p.pattern_type === 'anti_pattern'),
-        insights: generateInsights(complianceData)
-    });
-});
-
-function generateInsights(compliance) {
-    const insights = [];
-
-    if (compliance.length === 0) {
-        insights.push({
-            type: 'info',
-            message: 'No developer metrics available yet. Connect a git repository to start tracking.'
-        });
-        return insights;
-    }
-
-    // Compliance insights
-    const highPerformers = compliance.filter(d => parseFloat(d.avg_compliance_score || 0) >= 80);
-    const lowPerformers = compliance.filter(d => parseFloat(d.avg_compliance_score || 0) < 50 && parseInt(d.total_commits) > 5);
-
-    if (highPerformers.length > 0) {
-        insights.push({
-            type: 'positive',
-            message: `${highPerformers.length} developer(s) maintaining >80% compliance score`,
-            developers: highPerformers.map(d => d.developer_name || d.developer_email)
-        });
-    }
-
-    if (lowPerformers.length > 0) {
-        insights.push({
-            type: 'attention',
-            message: `${lowPerformers.length} developer(s) below 50% compliance - may benefit from standards training`,
-            developers: lowPerformers.map(d => d.developer_name || d.developer_email)
-        });
-    }
-
-    return insights;
-}
-
-function parsePeriod(period) {
-    const match = period.match(/^(\d+)([dwm])$/);
-    if (!match) return 30;
-
-    const [, num, unit] = match;
-    const n = parseInt(num);
-
-    switch (unit) {
-        case 'd': return n;
-        case 'w': return n * 7;
-        case 'm': return n * 30;
-        default: return 30;
-    }
-}

package/src/handlers/scheduled/analyzeCorrelations.js

@@ -1,178 +0,0 @@
-/**
- * Analyze Correlations Scheduled Job
- * Correlates Claude Code sessions with git commits
- *
- * Schedule: Every 2 hours (or triggered via API)
- * Auth: None (Lambda scheduled event)
- *
- * Features:
- * - Session-to-commit correlation by timestamp proximity
- * - Pattern success tracking
- * - Struggle detection (sessions without commits)
- * - Aggregate productivity metrics
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
-
-/**
- * Main handler - wrapped with wrapHandler for consistent error handling
- */
-exports.handler = wrapHandler(async (event, context) => {
-    console.log('[AnalyzeCorrelations] Starting correlation analysis job...');
-
-    // Parse options from event (allows manual triggering with specific parameters)
-    const options = parseEventOptions(event);
-
-    // Initialize analyzer with default config
-    const analyzer = new CorrelationAnalyzer();
-
-    // Run correlation analysis
-    const summary = await analyzer.analyzeCorrelations(options);
-
-    // Log results
-    console.log('[AnalyzeCorrelations] Analysis summary:', JSON.stringify(summary, null, 2));
-
-    // If running for specific company, also generate struggling developer alerts
-    if (options.companyId && summary.uncorrelatedSessions > 0) {
-        const strugglingDevs = await analyzer.identifyStrugglingDevelopers(
-            options.companyId,
-            options.lookbackDays || 30
-        );
-
-        if (strugglingDevs.length > 0) {
-            console.log(`[AnalyzeCorrelations] Found ${strugglingDevs.length} potentially struggling developers`);
-
-            // Create alerts for struggling developers
-            await createStrugglingDeveloperAlerts(options.companyId, strugglingDevs);
-        }
-    }
-
-    return createSuccessResponse({
-        sessionsAnalyzed: summary.sessionsAnalyzed,
-        correlationsCreated: summary.correlationsCreated,
-        uncorrelatedSessions: summary.uncorrelatedSessions,
-        patternCorrelations: summary.patternCorrelations,
-        errors: summary.errors.length,
-        duration: calculateDuration(summary.startedAt, summary.completedAt)
-    }, 'Correlation analysis complete');
-});
-
-/**
- * Parse options from Lambda event
- *
- * @param {Object} event - Lambda event
- * @returns {Object} Parsed options
- */
-function parseEventOptions(event) {
-    const options = {
-        lookbackDays: 30
-    };
-
-    // Support both direct invocation and API Gateway trigger
-    if (event.body) {
-        try {
-            const body = typeof event.body === 'string' ? JSON.parse(event.body) : event.body;
-            options.projectId = body.projectId;
-            options.companyId = body.companyId;
-            options.lookbackDays = body.lookbackDays || 30;
-        } catch (e) {
-            console.log('[AnalyzeCorrelations] Could not parse event body:', e.message);
-        }
-    } else if (event.projectId || event.companyId) {
-        // Direct invocation with parameters
-        options.projectId = event.projectId;
-        options.companyId = event.companyId;
-        options.lookbackDays = event.lookbackDays || 30;
-    }
-
-    return options;
-}
-
-/**
- * Create alerts for struggling developers
- *
- * @param {string} companyId - Company ID
- * @param {Array} developers - Struggling developers list
- */
-async function createStrugglingDeveloperAlerts(companyId, developers) {
-    const cooldownHours = 24;
-
-    for (const dev of developers) {
-        try {
-            // Check if alert already exists within cooldown period
-            const existingCheck = await executeQuery(`
-                SELECT 1 FROM rapport.attention_alerts
-                WHERE email_address = $1
-                AND alert_type = 'low_conversion'
-                AND (status = 'active' OR created_at > NOW() - $2 * INTERVAL '1 hour')
-                LIMIT 1
-            `, [dev.email, cooldownHours]);
-
-            if (existingCheck.rows.length > 0) {
-                console.log(`[AnalyzeCorrelations] Skipping alert for ${dev.email} - already exists`);
-                continue;
-            }
-
-            // Determine severity based on unproductive rate
-            let severity = 'info';
-            if (dev.unproductiveRate >= 80) {
-                severity = 'critical';
-            } else if (dev.unproductiveRate >= 60) {
-                severity = 'warning';
-            }
-
-            // Create alert
-            await executeQuery(`
-                INSERT INTO rapport.attention_alerts (
-                    email_address,
-                    company_id,
-                    alert_type,
-                    severity,
-                    details,
-                    expires_at
-                ) VALUES ($1, $2, 'low_conversion', $3, $4, NOW() + INTERVAL '7 days')
-            `, [
-                dev.email,
-                companyId,
-                severity,
-                JSON.stringify({
-                    total_sessions: dev.totalSessions,
-                    unproductive_sessions: dev.unproductiveSessions,
-                    unproductive_rate: dev.unproductiveRate,
-                    last_productive_session: dev.lastProductiveSession,
-                    avg_session_minutes: dev.avgSessionMinutes,
-                    generated_by: 'CorrelationAnalyzer'
-                })
-            ]);
-
-            console.log(`[AnalyzeCorrelations] Created ${severity} alert for ${dev.email}`);
-
-        } catch (error) {
-            console.error(`[AnalyzeCorrelations] Error creating alert for ${dev.email}:`, error.message);
-        }
-    }
-}
-
-/**
- * Calculate duration between two ISO timestamps
- *
- * @param {string} start - Start timestamp
- * @param {string} end - End timestamp
- * @returns {string} Duration string
- */
-function calculateDuration(start, end) {
-    if (!start || !end) return 'unknown';
-
-    const startTime = new Date(start);
-    const endTime = new Date(end);
-    const durationMs = endTime - startTime;
-
-    if (durationMs < 1000) {
-        return `${durationMs}ms`;
-    } else if (durationMs < 60000) {
-        return `${Math.round(durationMs / 1000)}s`;
-    } else {
-        return `${Math.round(durationMs / 60000)}m ${Math.round((durationMs % 60000) / 1000)}s`;
-    }
-}