@equilateral_ai/mindmeld 3.0.0

package/src/handlers/reports/standardsRoi.js

@@ -0,0 +1,162 @@
+/**
+ * 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 (boolean columns in Tim-Combo schema)
+    const accessCheck = await executeQuery(`
+        SELECT ue."Company_ID"
+        FROM "UserEntitlements" 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);
+
+    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',
+            patterns_configured: patterns.rows.length
+        },
+        compliance_by_developer: complianceData,
+        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

@@ -0,0 +1,178 @@
+/**
+ * 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() - INTERVAL '${cooldownHours} hours')
+                LIMIT 1
+            `, [dev.email]);
+
+            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`;
+    }
+}