@equilateral_ai/mindmeld 3.0.0

package/src/core/CorrelationAnalyzer.js

@@ -0,0 +1,774 @@
+/**
+ * Rapport v3 - Correlation Analyzer
+ *
+ * Purpose: Correlates Claude Code sessions with git commits to measure productivity
+ *
+ * Key Metrics:
+ * - Session-to-commit conversion rate (sessions that produce commits)
+ * - Time between session and commit (latency)
+ * - Pattern success correlation (which patterns lead to commits)
+ * - Struggle detection (sessions without commits)
+ *
+ * Correlation Algorithm:
+ * 1. Find commits within a time window after session end
+ * 2. Match by email address (session user = commit author)
+ * 3. Consider branch/project alignment if available
+ * 4. Handle async commit behavior (commits hours/days after session)
+ *
+ * Based on: Phase 7 Engineering Intelligence
+ */
+
+const { executeQuery } = require('../handlers/helpers/dbOperations');
+
+/**
+ * Default configuration for correlation analysis
+ */
+const DEFAULT_CONFIG = {
+    // Time window for matching sessions to commits (hours)
+    correlationWindowHours: 4,
+
+    // Extended window for async commits (hours)
+    asyncWindowHours: 24,
+
+    // Minimum session duration to consider (seconds)
+    minSessionDuration: 60,
+
+    // Weight factors for correlation scoring
+    weights: {
+        timeProximity: 0.4,    // Closer in time = higher weight
+        branchMatch: 0.3,      // Same branch = higher weight
+        projectMatch: 0.2,     // Same project = higher weight
+        patternSuccess: 0.1    // Successful patterns = higher weight
+    },
+
+    // Thresholds for classification
+    thresholds: {
+        // Sessions without commits within window are "unproductive"
+        unproductiveWindowHours: 8,
+
+        // Conversion rate thresholds
+        lowConversionRate: 0.2,   // Below 20% = low
+        highConversionRate: 0.7,  // Above 70% = high
+
+        // Minimum sessions for statistical significance
+        minSessionsForStats: 5
+    }
+};
+
+class CorrelationAnalyzer {
+    constructor(config = {}) {
+        this.config = this.mergeConfig(DEFAULT_CONFIG, config);
+    }
+
+    /**
+     * Deep merge configuration
+     */
+    mergeConfig(defaults, overrides) {
+        const result = { ...defaults };
+        for (const key of Object.keys(overrides)) {
+            if (typeof overrides[key] === 'object' && !Array.isArray(overrides[key])) {
+                result[key] = { ...defaults[key], ...overrides[key] };
+            } else {
+                result[key] = overrides[key];
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Analyze correlations for all uncorrelated sessions
+     *
+     * @param {Object} options - Analysis options
+     * @param {string} options.projectId - Optional project filter
+     * @param {string} options.companyId - Optional company filter
+     * @param {number} options.lookbackDays - Days to look back (default: 30)
+     * @returns {Promise<Object>} Analysis summary
+     */
+    async analyzeCorrelations(options = {}) {
+        const lookbackDays = options.lookbackDays || 30;
+        const projectId = options.projectId;
+        const companyId = options.companyId;
+
+        const summary = {
+            startedAt: new Date().toISOString(),
+            sessionsAnalyzed: 0,
+            correlationsCreated: 0,
+            uncorrelatedSessions: 0,
+            patternCorrelations: 0,
+            errors: []
+        };
+
+        try {
+            console.log('[CorrelationAnalyzer] Starting correlation analysis...');
+
+            // Get uncorrelated sessions
+            const sessions = await this.getUncorrelatedSessions(lookbackDays, projectId, companyId);
+            summary.sessionsAnalyzed = sessions.length;
+
+            if (sessions.length === 0) {
+                console.log('[CorrelationAnalyzer] No uncorrelated sessions found');
+                summary.completedAt = new Date().toISOString();
+                return summary;
+            }
+
+            console.log(`[CorrelationAnalyzer] Found ${sessions.length} sessions to analyze`);
+
+            // Process each session
+            for (const session of sessions) {
+                try {
+                    const correlation = await this.correlateSession(session);
+
+                    if (correlation.hasCommits) {
+                        await this.saveCorrelation(correlation);
+                        summary.correlationsCreated++;
+
+                        // Update pattern success rates
+                        if (correlation.patternsUsed && correlation.patternsUsed.length > 0) {
+                            await this.updatePatternSuccess(correlation);
+                            summary.patternCorrelations++;
+                        }
+                    } else {
+                        // Mark session as analyzed but uncorrelated
+                        await this.markSessionAnalyzed(session.session_id, false);
+                        summary.uncorrelatedSessions++;
+                    }
+                } catch (error) {
+                    console.error(`[CorrelationAnalyzer] Error correlating session ${session.session_id}:`, error);
+                    summary.errors.push({
+                        sessionId: session.session_id,
+                        error: error.message
+                    });
+                }
+            }
+
+            // Calculate aggregate metrics
+            await this.calculateAggregateMetrics(projectId, companyId);
+
+            summary.completedAt = new Date().toISOString();
+            console.log(`[CorrelationAnalyzer] Analysis complete: ${summary.correlationsCreated} correlations, ${summary.uncorrelatedSessions} uncorrelated`);
+
+        } catch (error) {
+            console.error('[CorrelationAnalyzer] Error in correlation analysis:', error);
+            summary.errors.push(error.message);
+        }
+
+        return summary;
+    }
+
+    /**
+     * Get sessions that haven't been correlated yet
+     *
+     * @param {number} lookbackDays - Days to look back
+     * @param {string} projectId - Optional project filter
+     * @param {string} companyId - Optional company filter
+     * @returns {Promise<Array>} Uncorrelated sessions
+     */
+    async getUncorrelatedSessions(lookbackDays, projectId = null, companyId = null) {
+        const query = `
+            SELECT
+                s.session_id,
+                s.project_id,
+                s.email_address,
+                s.started_at,
+                s.ended_at,
+                s.duration_seconds,
+                s.git_branch,
+                s.patterns_used,
+                s.session_data,
+                p.company_id,
+                p.repo_url
+            FROM rapport.sessions s
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE s.started_at > NOW() - INTERVAL '${lookbackDays} days'
+            AND s.ended_at IS NOT NULL
+            AND s.duration_seconds >= $1
+            AND NOT EXISTS (
+                SELECT 1 FROM rapport.session_correlations sc
+                WHERE sc.session_id = s.session_id
+            )
+            ${projectId ? 'AND s.project_id = $2' : ''}
+            ${companyId ? `AND p.company_id = ${projectId ? '$3' : '$2'}` : ''}
+            ORDER BY s.started_at ASC
+            LIMIT 500
+        `;
+
+        const params = [this.config.minSessionDuration];
+        if (projectId) params.push(projectId);
+        if (companyId) params.push(companyId);
+
+        const result = await executeQuery(query, params);
+        return result.rows;
+    }
+
+    /**
+     * Correlate a single session with commits
+     *
+     * @param {Object} session - Session to correlate
+     * @returns {Promise<Object>} Correlation result
+     */
+    async correlateSession(session) {
+        const correlation = {
+            sessionId: session.session_id,
+            projectId: session.project_id,
+            emailAddress: session.email_address,
+            sessionStarted: session.started_at,
+            sessionEnded: session.ended_at,
+            sessionDuration: session.duration_seconds,
+            hasCommits: false,
+            commitCount: 0,
+            commits: [],
+            totalInsertions: 0,
+            totalDeletions: 0,
+            totalFilesChanged: 0,
+            avgCommitLatencyMinutes: null,
+            patternsUsed: session.patterns_used || 0,
+            correlationScore: 0,
+            correlationType: 'none'
+        };
+
+        // Find commits within the correlation window
+        const commits = await this.findRelatedCommits(session);
+
+        if (commits.length === 0) {
+            return correlation;
+        }
+
+        correlation.hasCommits = true;
+        correlation.commitCount = commits.length;
+        correlation.commits = commits.map(c => c.commit_id);
+
+        // Calculate metrics
+        let totalLatency = 0;
+        for (const commit of commits) {
+            correlation.totalInsertions += commit.insertions || 0;
+            correlation.totalDeletions += commit.deletions || 0;
+            correlation.totalFilesChanged += commit.files_changed || 0;
+
+            // Calculate latency from session end to commit
+            const commitTime = new Date(commit.commit_timestamp);
+            const sessionEnd = new Date(session.ended_at);
+            const latencyMinutes = (commitTime - sessionEnd) / (1000 * 60);
+            totalLatency += Math.max(0, latencyMinutes);
+        }
+
+        correlation.avgCommitLatencyMinutes = commits.length > 0
+            ? Math.round(totalLatency / commits.length)
+            : null;
+
+        // Calculate correlation score
+        correlation.correlationScore = this.calculateCorrelationScore(session, commits);
+
+        // Determine correlation type
+        correlation.correlationType = this.determineCorrelationType(correlation);
+
+        return correlation;
+    }
+
+    /**
+     * Find commits related to a session
+     *
+     * @param {Object} session - Session to find commits for
+     * @returns {Promise<Array>} Related commits
+     */
+    async findRelatedCommits(session) {
+        const asyncWindowHours = this.config.asyncWindowHours;
+
+        // Find commits by the same author within the time window
+        const query = `
+            SELECT
+                c.commit_id,
+                c.commit_hash,
+                c.commit_timestamp,
+                c.insertions,
+                c.deletions,
+                c.files_changed,
+                c.branch,
+                c.message
+            FROM rapport.commits c
+            WHERE c.author_email = $1
+            AND c.commit_timestamp >= $2
+            AND c.commit_timestamp <= $3::timestamp + INTERVAL '${asyncWindowHours} hours'
+            ${session.repo_url ? `AND c.repo_url = $4` : ''}
+            ORDER BY c.commit_timestamp ASC
+        `;
+
+        const params = [
+            session.email_address,
+            session.started_at,
+            session.ended_at
+        ];
+        if (session.repo_url) params.push(session.repo_url);
+
+        const result = await executeQuery(query, params);
+        return result.rows;
+    }
+
+    /**
+     * Calculate correlation score based on various factors
+     *
+     * @param {Object} session - Session data
+     * @param {Array} commits - Related commits
+     * @returns {number} Correlation score (0.0 - 1.0)
+     */
+    calculateCorrelationScore(session, commits) {
+        if (commits.length === 0) return 0;
+
+        const weights = this.config.weights;
+        let score = 0;
+
+        // Time proximity score (closer = higher)
+        const sessionEnd = new Date(session.ended_at);
+        const avgLatency = commits.reduce((sum, c) => {
+            const commitTime = new Date(c.commit_timestamp);
+            return sum + Math.max(0, (commitTime - sessionEnd) / (1000 * 60 * 60)); // hours
+        }, 0) / commits.length;
+
+        // Exponential decay: closer commits get higher score
+        const timeScore = Math.exp(-avgLatency / this.config.correlationWindowHours);
+        score += timeScore * weights.timeProximity;
+
+        // Branch match score
+        if (session.git_branch) {
+            const branchMatches = commits.filter(c => c.branch === session.git_branch).length;
+            const branchScore = branchMatches / commits.length;
+            score += branchScore * weights.branchMatch;
+        } else {
+            // No branch info, give partial credit
+            score += 0.5 * weights.branchMatch;
+        }
+
+        // Project match (always 1.0 since we filter by repo_url)
+        score += 1.0 * weights.projectMatch;
+
+        // Pattern success (if patterns were used in session)
+        if (session.patterns_used > 0) {
+            score += 1.0 * weights.patternSuccess;
+        }
+
+        return Math.min(1.0, score);
+    }
+
+    /**
+     * Determine the type of correlation
+     *
+     * @param {Object} correlation - Correlation data
+     * @returns {string} Correlation type
+     */
+    determineCorrelationType(correlation) {
+        if (!correlation.hasCommits) {
+            return 'none';
+        }
+
+        // Immediate: commits within standard window
+        if (correlation.avgCommitLatencyMinutes <= this.config.correlationWindowHours * 60) {
+            return 'immediate';
+        }
+
+        // Async: commits within extended window
+        if (correlation.avgCommitLatencyMinutes <= this.config.asyncWindowHours * 60) {
+            return 'async';
+        }
+
+        return 'delayed';
+    }
+
+    /**
+     * Save correlation result to database
+     *
+     * @param {Object} correlation - Correlation data
+     */
+    async saveCorrelation(correlation) {
+        const query = `
+            INSERT INTO rapport.session_correlations (
+                session_id,
+                project_id,
+                email_address,
+                session_started_at,
+                session_ended_at,
+                session_duration_seconds,
+                has_commits,
+                commit_count,
+                commit_ids,
+                total_insertions,
+                total_deletions,
+                total_files_changed,
+                avg_commit_latency_minutes,
+                patterns_used,
+                correlation_score,
+                correlation_type,
+                analyzed_at
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, NOW())
+            ON CONFLICT (session_id) DO UPDATE SET
+                has_commits = EXCLUDED.has_commits,
+                commit_count = EXCLUDED.commit_count,
+                commit_ids = EXCLUDED.commit_ids,
+                total_insertions = EXCLUDED.total_insertions,
+                total_deletions = EXCLUDED.total_deletions,
+                total_files_changed = EXCLUDED.total_files_changed,
+                avg_commit_latency_minutes = EXCLUDED.avg_commit_latency_minutes,
+                correlation_score = EXCLUDED.correlation_score,
+                correlation_type = EXCLUDED.correlation_type,
+                analyzed_at = NOW()
+        `;
+
+        await executeQuery(query, [
+            correlation.sessionId,
+            correlation.projectId,
+            correlation.emailAddress,
+            correlation.sessionStarted,
+            correlation.sessionEnded,
+            correlation.sessionDuration,
+            correlation.hasCommits,
+            correlation.commitCount,
+            correlation.commits,
+            correlation.totalInsertions,
+            correlation.totalDeletions,
+            correlation.totalFilesChanged,
+            correlation.avgCommitLatencyMinutes,
+            correlation.patternsUsed,
+            correlation.correlationScore,
+            correlation.correlationType
+        ]);
+    }
+
+    /**
+     * Mark session as analyzed without commits
+     *
+     * @param {string} sessionId - Session ID
+     * @param {boolean} hasCommits - Whether commits were found
+     */
+    async markSessionAnalyzed(sessionId, hasCommits) {
+        const query = `
+            INSERT INTO rapport.session_correlations (
+                session_id,
+                has_commits,
+                correlation_type,
+                analyzed_at
+            )
+            SELECT
+                s.session_id,
+                $2,
+                'none',
+                NOW()
+            FROM rapport.sessions s
+            WHERE s.session_id = $1
+            ON CONFLICT (session_id) DO UPDATE SET
+                analyzed_at = NOW()
+        `;
+
+        await executeQuery(query, [sessionId, hasCommits]);
+    }
+
+    /**
+     * Update pattern success rates based on correlation
+     *
+     * @param {Object} correlation - Correlation with commits
+     */
+    async updatePatternSuccess(correlation) {
+        // Get patterns used in the session
+        const patternsQuery = `
+            SELECT pattern_id
+            FROM rapport.pattern_usage
+            WHERE session_id = $1
+        `;
+
+        const result = await executeQuery(patternsQuery, [correlation.sessionId]);
+
+        for (const row of result.rows) {
+            // Record successful pattern usage (session led to commits)
+            await executeQuery(`
+                UPDATE rapport.patterns
+                SET
+                    successful_handoffs = successful_handoffs + 1,
+                    handoff_count = handoff_count + 1,
+                    last_used = NOW()
+                WHERE pattern_id = $1
+            `, [row.pattern_id]);
+        }
+    }
+
+    /**
+     * Calculate aggregate metrics for dashboards
+     *
+     * @param {string} projectId - Optional project filter
+     * @param {string} companyId - Optional company filter
+     */
+    async calculateAggregateMetrics(projectId = null, companyId = null) {
+        // Refresh the developer activity view if it exists
+        try {
+            await executeQuery('SELECT rapport.refresh_developer_activity()');
+        } catch (error) {
+            // View might not exist, that's OK
+            console.log('[CorrelationAnalyzer] Could not refresh activity view:', error.message);
+        }
+    }
+
+    /**
+     * Get productivity metrics for a developer
+     *
+     * @param {string} emailAddress - Developer email
+     * @param {number} lookbackDays - Days to analyze
+     * @returns {Promise<Object>} Productivity metrics
+     */
+    async getDeveloperProductivity(emailAddress, lookbackDays = 30) {
+        const query = `
+            SELECT
+                COUNT(*) as total_sessions,
+                COUNT(*) FILTER (WHERE has_commits = true) as productive_sessions,
+                ROUND(
+                    COUNT(*) FILTER (WHERE has_commits = true)::decimal /
+                    NULLIF(COUNT(*), 0) * 100,
+                    1
+                ) as conversion_rate,
+                SUM(commit_count) as total_commits,
+                ROUND(AVG(commit_count) FILTER (WHERE has_commits = true), 1) as avg_commits_per_session,
+                SUM(total_insertions) as total_insertions,
+                SUM(total_deletions) as total_deletions,
+                SUM(total_files_changed) as total_files_changed,
+                ROUND(AVG(avg_commit_latency_minutes) FILTER (WHERE has_commits = true), 0) as avg_latency_minutes,
+                ROUND(AVG(correlation_score) FILTER (WHERE has_commits = true), 2) as avg_correlation_score,
+                SUM(session_duration_seconds)::integer as total_session_seconds,
+                COUNT(DISTINCT DATE(session_started_at)) as active_days
+            FROM rapport.session_correlations
+            WHERE email_address = $1
+            AND session_started_at > NOW() - INTERVAL '${lookbackDays} days'
+        `;
+
+        const result = await executeQuery(query, [emailAddress]);
+        const row = result.rows[0];
+
+        return {
+            email: emailAddress,
+            period: `${lookbackDays} days`,
+            totalSessions: parseInt(row.total_sessions) || 0,
+            productiveSessions: parseInt(row.productive_sessions) || 0,
+            conversionRate: parseFloat(row.conversion_rate) || 0,
+            totalCommits: parseInt(row.total_commits) || 0,
+            avgCommitsPerSession: parseFloat(row.avg_commits_per_session) || 0,
+            totalInsertions: parseInt(row.total_insertions) || 0,
+            totalDeletions: parseInt(row.total_deletions) || 0,
+            totalFilesChanged: parseInt(row.total_files_changed) || 0,
+            avgLatencyMinutes: parseInt(row.avg_latency_minutes) || 0,
+            avgCorrelationScore: parseFloat(row.avg_correlation_score) || 0,
+            totalSessionHours: Math.round((parseInt(row.total_session_seconds) || 0) / 3600 * 10) / 10,
+            activeDays: parseInt(row.active_days) || 0
+        };
+    }
+
+    /**
+     * Get project productivity metrics
+     *
+     * @param {string} projectId - Project ID
+     * @param {number} lookbackDays - Days to analyze
+     * @returns {Promise<Object>} Project metrics
+     */
+    async getProjectProductivity(projectId, lookbackDays = 30) {
+        const query = `
+            SELECT
+                COUNT(*) as total_sessions,
+                COUNT(*) FILTER (WHERE has_commits = true) as productive_sessions,
+                ROUND(
+                    COUNT(*) FILTER (WHERE has_commits = true)::decimal /
+                    NULLIF(COUNT(*), 0) * 100,
+                    1
+                ) as conversion_rate,
+                SUM(commit_count) as total_commits,
+                SUM(total_insertions) as total_insertions,
+                SUM(total_deletions) as total_deletions,
+                SUM(total_files_changed) as total_files_changed,
+                COUNT(DISTINCT email_address) as unique_developers,
+                ROUND(AVG(correlation_score) FILTER (WHERE has_commits = true), 2) as avg_correlation_score
+            FROM rapport.session_correlations
+            WHERE project_id = $1
+            AND session_started_at > NOW() - INTERVAL '${lookbackDays} days'
+        `;
+
+        const result = await executeQuery(query, [projectId]);
+        const row = result.rows[0];
+
+        return {
+            projectId,
+            period: `${lookbackDays} days`,
+            totalSessions: parseInt(row.total_sessions) || 0,
+            productiveSessions: parseInt(row.productive_sessions) || 0,
+            conversionRate: parseFloat(row.conversion_rate) || 0,
+            totalCommits: parseInt(row.total_commits) || 0,
+            totalInsertions: parseInt(row.total_insertions) || 0,
+            totalDeletions: parseInt(row.total_deletions) || 0,
+            totalFilesChanged: parseInt(row.total_files_changed) || 0,
+            uniqueDevelopers: parseInt(row.unique_developers) || 0,
+            avgCorrelationScore: parseFloat(row.avg_correlation_score) || 0
+        };
+    }
+
+    /**
+     * Get pattern effectiveness metrics
+     *
+     * @param {string} projectId - Optional project filter
+     * @param {number} lookbackDays - Days to analyze
+     * @returns {Promise<Array>} Pattern effectiveness data
+     */
+    async getPatternEffectiveness(projectId = null, lookbackDays = 30) {
+        const query = `
+            SELECT
+                p.pattern_id,
+                p.intent,
+                p.maturity,
+                COUNT(DISTINCT pu.session_id) as sessions_used,
+                COUNT(DISTINCT sc.session_id) FILTER (WHERE sc.has_commits = true) as sessions_with_commits,
+                ROUND(
+                    COUNT(DISTINCT sc.session_id) FILTER (WHERE sc.has_commits = true)::decimal /
+                    NULLIF(COUNT(DISTINCT pu.session_id), 0) * 100,
+                    1
+                ) as pattern_conversion_rate,
+                ROUND(AVG(sc.commit_count) FILTER (WHERE sc.has_commits = true), 1) as avg_commits
+            FROM rapport.patterns p
+            JOIN rapport.pattern_usage pu ON p.pattern_id = pu.pattern_id
+            LEFT JOIN rapport.session_correlations sc ON pu.session_id = sc.session_id
+            WHERE pu.used_at > NOW() - INTERVAL '${lookbackDays} days'
+            ${projectId ? 'AND p.project_id = $1' : ''}
+            GROUP BY p.pattern_id, p.intent, p.maturity
+            HAVING COUNT(DISTINCT pu.session_id) >= 3
+            ORDER BY pattern_conversion_rate DESC NULLS LAST
+            LIMIT 20
+        `;
+
+        const params = projectId ? [projectId] : [];
+        const result = await executeQuery(query, params);
+
+        return result.rows.map(row => ({
+            patternId: row.pattern_id,
+            intent: row.intent,
+            maturity: row.maturity,
+            sessionsUsed: parseInt(row.sessions_used) || 0,
+            sessionsWithCommits: parseInt(row.sessions_with_commits) || 0,
+            patternConversionRate: parseFloat(row.pattern_conversion_rate) || 0,
+            avgCommits: parseFloat(row.avg_commits) || 0
+        }));
+    }
+
+    /**
+     * Identify struggling developers (sessions without commits)
+     *
+     * @param {string} companyId - Company ID
+     * @param {number} lookbackDays - Days to analyze
+     * @returns {Promise<Array>} Struggling developer data
+     */
+    async identifyStrugglingDevelopers(companyId, lookbackDays = 30) {
+        const thresholds = this.config.thresholds;
+
+        const query = `
+            SELECT
+                sc.email_address,
+                u."User_Display_Name" as display_name,
+                COUNT(*) as total_sessions,
+                COUNT(*) FILTER (WHERE has_commits = false) as unproductive_sessions,
+                ROUND(
+                    COUNT(*) FILTER (WHERE has_commits = false)::decimal /
+                    NULLIF(COUNT(*), 0) * 100,
+                    1
+                ) as unproductive_rate,
+                MAX(sc.session_started_at) FILTER (WHERE has_commits = true) as last_productive_session,
+                ROUND(AVG(sc.session_duration_seconds) / 60, 0) as avg_session_minutes
+            FROM rapport.session_correlations sc
+            JOIN rapport.projects p ON sc.project_id = p.project_id
+            JOIN "Users" u ON sc.email_address = u."Email_Address"
+            WHERE p.company_id = $1
+            AND sc.session_started_at > NOW() - INTERVAL '${lookbackDays} days'
+            GROUP BY sc.email_address, u."User_Display_Name"
+            HAVING COUNT(*) >= $2
+            AND ROUND(
+                COUNT(*) FILTER (WHERE has_commits = false)::decimal /
+                NULLIF(COUNT(*), 0) * 100,
+                1
+            ) >= (100 - $3 * 100)
+            ORDER BY unproductive_rate DESC
+        `;
+
+        const result = await executeQuery(query, [
+            companyId,
+            thresholds.minSessionsForStats,
+            thresholds.lowConversionRate
+        ]);
+
+        return result.rows.map(row => ({
+            email: row.email_address,
+            displayName: row.display_name,
+            totalSessions: parseInt(row.total_sessions),
+            unproductiveSessions: parseInt(row.unproductive_sessions),
+            unproductiveRate: parseFloat(row.unproductive_rate),
+            lastProductiveSession: row.last_productive_session,
+            avgSessionMinutes: parseInt(row.avg_session_minutes) || 0
+        }));
+    }
+
+    /**
+     * Get correlation summary for dashboard
+     *
+     * @param {string} companyId - Company ID
+     * @param {number} lookbackDays - Days to analyze
+     * @returns {Promise<Object>} Summary data
+     */
+    async getCorrelationSummary(companyId, lookbackDays = 30) {
+        const query = `
+            SELECT
+                COUNT(*) as total_sessions,
+                COUNT(*) FILTER (WHERE has_commits = true) as productive_sessions,
+                ROUND(
+                    COUNT(*) FILTER (WHERE has_commits = true)::decimal /
+                    NULLIF(COUNT(*), 0) * 100,
+                    1
+                ) as overall_conversion_rate,
+                SUM(commit_count) as total_commits,
+                COUNT(DISTINCT email_address) as unique_developers,
+                COUNT(DISTINCT sc.project_id) as active_projects,
+                SUM(total_insertions) as total_insertions,
+                SUM(total_deletions) as total_deletions,
+                SUM(total_files_changed) as total_files_changed,
+                ROUND(AVG(session_duration_seconds) / 60, 0) as avg_session_minutes,
+                ROUND(AVG(correlation_score) FILTER (WHERE has_commits = true), 2) as avg_correlation_score,
+                COUNT(*) FILTER (WHERE correlation_type = 'immediate') as immediate_correlations,
+                COUNT(*) FILTER (WHERE correlation_type = 'async') as async_correlations,
+                COUNT(*) FILTER (WHERE correlation_type = 'delayed') as delayed_correlations,
+                COUNT(*) FILTER (WHERE correlation_type = 'none') as no_correlations
+            FROM rapport.session_correlations sc
+            JOIN rapport.projects p ON sc.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND sc.session_started_at > NOW() - INTERVAL '${lookbackDays} days'
+        `;
+
+        const result = await executeQuery(query, [companyId]);
+        const row = result.rows[0];
+
+        return {
+            companyId,
+            period: `${lookbackDays} days`,
+            totalSessions: parseInt(row.total_sessions) || 0,
+            productiveSessions: parseInt(row.productive_sessions) || 0,
+            overallConversionRate: parseFloat(row.overall_conversion_rate) || 0,
+            totalCommits: parseInt(row.total_commits) || 0,
+            uniqueDevelopers: parseInt(row.unique_developers) || 0,
+            activeProjects: parseInt(row.active_projects) || 0,
+            totalInsertions: parseInt(row.total_insertions) || 0,
+            totalDeletions: parseInt(row.total_deletions) || 0,
+            totalFilesChanged: parseInt(row.total_files_changed) || 0,
+            avgSessionMinutes: parseInt(row.avg_session_minutes) || 0,
+            avgCorrelationScore: parseFloat(row.avg_correlation_score) || 0,
+            correlationTypes: {
+                immediate: parseInt(row.immediate_correlations) || 0,
+                async: parseInt(row.async_correlations) || 0,
+                delayed: parseInt(row.delayed_correlations) || 0,
+                none: parseInt(row.no_correlations) || 0
+            }
+        };
+    }
+
+    /**
+     * Get configuration (for debugging/admin)
+     */
+    getConfiguration() {
+        return this.config;
+    }
+}
+
+module.exports = { CorrelationAnalyzer, DEFAULT_CONFIG };