@equilateral_ai/mindmeld 3.0.0

package/src/core/AlertNotifier.js

@@ -0,0 +1,363 @@
+/**
+ * Rapport v3 - Alert Notifier
+ *
+ * Purpose: Sends notifications when attention alerts are generated
+ *
+ * Integration: Called by generateAlerts scheduled handler
+ * Channels: Email and Slack based on user preferences
+ */
+
+// Note: When used in Lambda, executeQuery comes from helpers (injected via setExecuteQuery)
+// When used in CLI/scripts, it can be provided via constructor
+let executeQueryFn = null;
+
+function setExecuteQuery(queryFn) {
+    executeQueryFn = queryFn;
+}
+
+function getExecuteQuery() {
+    if (!executeQueryFn) {
+        // Try to require from database/dbOperations as fallback
+        try {
+            return require('../handlers/helpers/dbOperations').executeQuery;
+        } catch (e) {
+            throw new Error('AlertNotifier: executeQuery not initialized. Call setExecuteQuery() first.');
+        }
+    }
+    return executeQueryFn;
+}
+
+const { NotificationService } = require('./NotificationService');
+
+class AlertNotifier {
+    constructor(config = {}) {
+        this.config = {
+            notifyOnSeverity: config.notifyOnSeverity || ['concern', 'warning'], // Which severities trigger notifications
+            slackOnlyForCritical: config.slackOnlyForCritical !== false, // Only send Slack for critical/concern alerts
+            ...config
+        };
+
+        this.notificationService = config.notificationService || new NotificationService();
+    }
+
+    /**
+     * Notify managers about new alerts
+     *
+     * @param {Array} alerts - List of alert objects
+     * @returns {Promise<Object>} Notification results
+     */
+    async notifyForAlerts(alerts) {
+        if (!alerts || alerts.length === 0) {
+            return { notified: 0, skipped: 0, failed: 0 };
+        }
+
+        const results = {
+            notified: 0,
+            skipped: 0,
+            failed: 0,
+            errors: []
+        };
+
+        // Group alerts by company for batch processing
+        const alertsByCompany = this.groupAlertsByCompany(alerts);
+
+        for (const [companyId, companyAlerts] of Object.entries(alertsByCompany)) {
+            try {
+                // Get managers for this company
+                const managers = await this.getCompanyManagers(companyId);
+
+                if (managers.length === 0) {
+                    console.log(`[AlertNotifier] No managers found for company ${companyId}`);
+                    results.skipped += companyAlerts.length;
+                    continue;
+                }
+
+                // Send notifications to each manager
+                for (const manager of managers) {
+                    const preferences = await this.getUserPreferences(manager.email_address);
+
+                    for (const alert of companyAlerts) {
+                        // Check if alert severity warrants notification
+                        if (!this.config.notifyOnSeverity.includes(alert.severity)) {
+                            results.skipped++;
+                            continue;
+                        }
+
+                        try {
+                            const sendResult = await this.notificationService.sendNotification({
+                                type: 'team_alert',
+                                email: manager.email_address,
+                                preferences: preferences,
+                                data: {
+                                    alertId: alert.alert_id,
+                                    alertType: alert.alert_type,
+                                    severity: alert.severity,
+                                    userName: alert.user_name || alert.email_address,
+                                    details: alert.details,
+                                    message: this.getAlertMessage(alert.alert_type, alert.details),
+                                    referenceType: 'attention_alert',
+                                    referenceId: String(alert.alert_id)
+                                },
+                                projectId: null // Alerts are company-wide
+                            });
+
+                            if (sendResult.email?.sent || sendResult.slack?.sent) {
+                                results.notified++;
+
+                                // Log the notification
+                                await this.logNotification(
+                                    manager.email_address,
+                                    'team_alert',
+                                    sendResult.email?.sent ? 'email' : 'slack',
+                                    'sent',
+                                    alert
+                                );
+                            } else {
+                                results.skipped++;
+                            }
+                        } catch (error) {
+                            results.failed++;
+                            results.errors.push({
+                                alertId: alert.alert_id,
+                                manager: manager.email_address,
+                                error: error.message
+                            });
+
+                            // Log failed notification
+                            await this.logNotification(
+                                manager.email_address,
+                                'team_alert',
+                                'email',
+                                'failed',
+                                alert,
+                                error.message
+                            );
+                        }
+                    }
+                }
+            } catch (error) {
+                console.error(`[AlertNotifier] Error processing company ${companyId}:`, error);
+                results.failed += companyAlerts.length;
+            }
+        }
+
+        console.log(`[AlertNotifier] Results: ${results.notified} notified, ${results.skipped} skipped, ${results.failed} failed`);
+        return results;
+    }
+
+    /**
+     * Group alerts by company ID
+     */
+    groupAlertsByCompany(alerts) {
+        const grouped = {};
+        for (const alert of alerts) {
+            const companyId = alert.company_id || 'unknown';
+            if (!grouped[companyId]) {
+                grouped[companyId] = [];
+            }
+            grouped[companyId].push(alert);
+        }
+        return grouped;
+    }
+
+    /**
+     * Get managers for a company
+     */
+    async getCompanyManagers(companyId) {
+        const executeQuery = getExecuteQuery();
+        const query = `
+            SELECT DISTINCT
+                ue."Email_Address" as email_address,
+                u."User_Display_Name" as user_name
+            FROM "UserEntitlements" ue
+            JOIN "Users" u ON ue."Email_Address" = u."Email_Address"
+            WHERE ue."Company_ID" = $1
+                AND (ue."Manager" = true OR ue."Admin" = true OR u."Super_Admin" = true)
+                AND u."active" = true
+        `;
+
+        const result = await executeQuery(query, [companyId]);
+        return result.rows;
+    }
+
+    /**
+     * Get user notification preferences
+     */
+    async getUserPreferences(email) {
+        const executeQuery = getExecuteQuery();
+        const query = `SELECT rapport.get_notification_preferences($1) as preferences`;
+        const result = await executeQuery(query, [email]);
+        return result.rows[0]?.preferences || null;
+    }
+
+    /**
+     * Generate human-readable alert message
+     */
+    getAlertMessage(alertType, details) {
+        switch (alertType) {
+            case 'stale_commits':
+                return `No commits in ${details.days_since_commit} days`;
+            case 'low_conversion':
+                return `Low session-to-commit conversion: ${details.conversion_pct}%`;
+            case 'no_ai_usage':
+                return `Active committer not using AI assistance`;
+            case 'declining_activity':
+                return `Activity declining over past ${details.period || 'week'}`;
+            case 'blocked_developer':
+                return `Developer appears blocked - ${details.reason || 'multiple failed sessions'}`;
+            case 'pattern_violation':
+                return `Repeated pattern violations detected`;
+            default:
+                return `Alert: ${alertType}`;
+        }
+    }
+
+    /**
+     * Log notification to database
+     */
+    async logNotification(email, type, channel, status, alert, errorMessage = null) {
+        try {
+            const executeQuery = getExecuteQuery();
+            await executeQuery(`
+                SELECT rapport.log_notification($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+            `, [
+                email,
+                type,
+                channel,
+                status,
+                null, // project_id
+                'attention_alert',
+                String(alert.alert_id),
+                JSON.stringify({ alertType: alert.alert_type, severity: alert.severity }),
+                null, // message_id
+                errorMessage
+            ]);
+        } catch (error) {
+            console.error('[AlertNotifier] Failed to log notification:', error);
+        }
+    }
+
+    /**
+     * Send critical alert immediately (bypass preferences for critical issues)
+     *
+     * @param {Object} alert - Alert object
+     * @param {string} managerEmail - Manager email to notify
+     * @returns {Promise<Object>} Send result
+     */
+    async sendCriticalAlert(alert, managerEmail) {
+        // For critical alerts, always send both email and Slack
+        const preferences = {
+            email_enabled: true,
+            slack_enabled: true,
+            notification_types: {
+                team_alert: { email: true, slack: true }
+            }
+        };
+
+        return this.notificationService.sendNotification({
+            type: 'team_alert',
+            email: managerEmail,
+            preferences: preferences,
+            data: {
+                alertId: alert.alert_id,
+                alertType: alert.alert_type,
+                severity: 'critical',
+                userName: alert.user_name || alert.email_address,
+                details: alert.details,
+                message: this.getAlertMessage(alert.alert_type, alert.details),
+                referenceType: 'attention_alert',
+                referenceId: String(alert.alert_id)
+            }
+        });
+    }
+
+    /**
+     * Send daily digest of alerts to managers
+     *
+     * @param {string} companyId - Company ID
+     * @returns {Promise<Object>} Send results
+     */
+    async sendAlertDigest(companyId) {
+        const executeQuery = getExecuteQuery();
+
+        // Get active alerts for the company
+        const alerts = await executeQuery(`
+            SELECT
+                aa.alert_id,
+                aa.email_address,
+                u."User_Display_Name" as user_name,
+                aa.alert_type,
+                aa.severity,
+                aa.details,
+                aa.created_at
+            FROM rapport.attention_alerts aa
+            JOIN "Users" u ON aa.email_address = u."Email_Address"
+            WHERE aa.company_id = $1
+                AND aa.status = 'active'
+            ORDER BY
+                CASE aa.severity WHEN 'concern' THEN 1 WHEN 'warning' THEN 2 ELSE 3 END,
+                aa.created_at DESC
+            LIMIT 10
+        `, [companyId]);
+
+        if (alerts.rows.length === 0) {
+            return { sent: false, reason: 'no_active_alerts' };
+        }
+
+        // Get managers for this company
+        const managers = await this.getCompanyManagers(companyId);
+
+        const results = {
+            sent: 0,
+            failed: 0
+        };
+
+        for (const manager of managers) {
+            const preferences = await this.getUserPreferences(manager.email_address);
+
+            // Build digest data
+            const digestData = {
+                companyId: companyId,
+                alertCount: alerts.rows.length,
+                alerts: alerts.rows.map(a => ({
+                    userName: a.user_name,
+                    alertType: a.alert_type,
+                    severity: a.severity,
+                    message: this.getAlertMessage(a.alert_type, a.details),
+                    createdAt: a.created_at
+                })),
+                concernCount: alerts.rows.filter(a => a.severity === 'concern').length,
+                warningCount: alerts.rows.filter(a => a.severity === 'warning').length
+            };
+
+            try {
+                // Use weekly_digest type but with alert data
+                await this.notificationService.sendNotification({
+                    type: 'weekly_digest',
+                    email: manager.email_address,
+                    preferences: preferences,
+                    data: {
+                        userName: manager.user_name || manager.email_address,
+                        weekStart: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toLocaleDateString(),
+                        weekEnd: new Date().toLocaleDateString(),
+                        teamActivity: {
+                            activeAlerts: digestData.alertCount,
+                            concernAlerts: digestData.concernCount,
+                            warningAlerts: digestData.warningCount
+                        },
+                        alerts: digestData.alerts
+                    }
+                });
+
+                results.sent++;
+            } catch (error) {
+                console.error(`[AlertNotifier] Failed to send digest to ${manager.email_address}:`, error);
+                results.failed++;
+            }
+        }
+
+        return results;
+    }
+}
+
+module.exports = { AlertNotifier, setExecuteQuery };