@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/core/AlertNotifier.js

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