@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/handlers/notifications/updatePreferences.js

@@ -1,316 +0,0 @@
-/**
- * Update Notification Preferences Handler
- * Updates user's notification preferences
- *
- * PUT /api/notifications/preferences
- * Auth: Cognito JWT required
- *
- * Body:
- * {
- *   "email_enabled": true,
- *   "slack_enabled": true,
- *   "notification_types": {
- *     "pattern_promotion": { "email": true, "slack": true },
- *     "weekly_digest": { "email": true, "slack": false },
- *     "critical_violation": { "email": true, "slack": true },
- *     "team_alert": { "email": true, "slack": true },
- *     "curation_candidate": { "email": true, "slack": true }
- *   },
- *   "project_overrides": {
- *     "prj_xxx": { "email_enabled": false, "notification_types": {...} }
- *   },
- *   "digest_frequency": "weekly",
- *   "digest_day": 1,
- *   "quiet_hours_enabled": false,
- *   "quiet_hours_start": "22:00",
- *   "quiet_hours_end": "08:00",
- *   "quiet_hours_timezone": "America/New_York",
- *   "slack_channel": "#my-channel",
- *   "slack_dm_enabled": true
- * }
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-exports.handler = wrapHandler(async ({ requestContext, body }) => {
-    const Request_ID = requestContext.requestId;
-    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-    if (!email) {
-        return createErrorResponse(401, 'Authentication required');
-    }
-
-    // Validate and sanitize input
-    const validatedPrefs = validatePreferences(body);
-    if (validatedPrefs.error) {
-        return createErrorResponse(400, validatedPrefs.error);
-    }
-
-    // Default notification types for new users
-    const defaultNotificationTypes = {
-        pattern_promotion: { email: true, slack: true },
-        weekly_digest: { email: true, slack: false },
-        critical_violation: { email: true, slack: true },
-        team_alert: { email: true, slack: true },
-        curation_candidate: { email: true, slack: true }
-    };
-
-    const {
-        email_enabled = true,
-        slack_enabled = true,
-        notification_types = defaultNotificationTypes,
-        project_overrides = {},
-        digest_frequency = 'weekly',
-        digest_day = 1,
-        quiet_hours_enabled = false,
-        quiet_hours_start,
-        quiet_hours_end,
-        quiet_hours_timezone = 'America/New_York',
-        slack_channel,
-        slack_dm_enabled = true
-    } = validatedPrefs;
-
-    // Upsert preferences
-    const result = await executeQuery(`
-        INSERT INTO rapport.notification_preferences (
-            email_address,
-            email_enabled,
-            slack_enabled,
-            notification_types,
-            project_overrides,
-            digest_frequency,
-            digest_day,
-            quiet_hours_enabled,
-            quiet_hours_start,
-            quiet_hours_end,
-            quiet_hours_timezone,
-            slack_channel,
-            slack_dm_enabled
-        ) VALUES (
-            $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13
-        )
-        ON CONFLICT (email_address) DO UPDATE SET
-            email_enabled = COALESCE($2, rapport.notification_preferences.email_enabled),
-            slack_enabled = COALESCE($3, rapport.notification_preferences.slack_enabled),
-            notification_types = COALESCE($4, rapport.notification_preferences.notification_types),
-            project_overrides = COALESCE($5, rapport.notification_preferences.project_overrides),
-            digest_frequency = COALESCE($6, rapport.notification_preferences.digest_frequency),
-            digest_day = COALESCE($7, rapport.notification_preferences.digest_day),
-            quiet_hours_enabled = COALESCE($8, rapport.notification_preferences.quiet_hours_enabled),
-            quiet_hours_start = $9,
-            quiet_hours_end = $10,
-            quiet_hours_timezone = COALESCE($11, rapport.notification_preferences.quiet_hours_timezone),
-            slack_channel = $12,
-            slack_dm_enabled = COALESCE($13, rapport.notification_preferences.slack_dm_enabled),
-            updated_at = NOW()
-        RETURNING *
-    `, [
-        email,
-        email_enabled,
-        slack_enabled,
-        notification_types ? JSON.stringify(notification_types) : null,
-        project_overrides ? JSON.stringify(project_overrides) : null,
-        digest_frequency,
-        digest_day,
-        quiet_hours_enabled,
-        quiet_hours_start,
-        quiet_hours_end,
-        quiet_hours_timezone,
-        slack_channel,
-        slack_dm_enabled
-    ]);
-
-    // If digest frequency changed, update the digest queue
-    if (digest_frequency) {
-        await updateDigestQueue(email, digest_frequency, digest_day);
-    }
-
-    return createSuccessResponse(
-        {
-            preferences: {
-                email_enabled: result.rows[0].email_enabled,
-                slack_enabled: result.rows[0].slack_enabled,
-                notification_types: result.rows[0].notification_types,
-                project_overrides: result.rows[0].project_overrides,
-                digest_frequency: result.rows[0].digest_frequency,
-                digest_day: result.rows[0].digest_day,
-                quiet_hours_enabled: result.rows[0].quiet_hours_enabled,
-                quiet_hours_start: result.rows[0].quiet_hours_start,
-                quiet_hours_end: result.rows[0].quiet_hours_end,
-                quiet_hours_timezone: result.rows[0].quiet_hours_timezone,
-                slack_channel: result.rows[0].slack_channel,
-                slack_dm_enabled: result.rows[0].slack_dm_enabled
-            },
-            updated_at: result.rows[0].updated_at
-        },
-        'Preferences updated',
-        { Request_ID, Timestamp: new Date().toISOString() }
-    );
-});
-
-/**
- * Validate and sanitize preferences input
- */
-function validatePreferences(body) {
-    const result = {};
-
-    // Validate boolean fields
-    if (body.email_enabled !== undefined) {
-        if (typeof body.email_enabled !== 'boolean') {
-            return { error: 'email_enabled must be a boolean' };
-        }
-        result.email_enabled = body.email_enabled;
-    }
-
-    if (body.slack_enabled !== undefined) {
-        if (typeof body.slack_enabled !== 'boolean') {
-            return { error: 'slack_enabled must be a boolean' };
-        }
-        result.slack_enabled = body.slack_enabled;
-    }
-
-    if (body.quiet_hours_enabled !== undefined) {
-        if (typeof body.quiet_hours_enabled !== 'boolean') {
-            return { error: 'quiet_hours_enabled must be a boolean' };
-        }
-        result.quiet_hours_enabled = body.quiet_hours_enabled;
-    }
-
-    if (body.slack_dm_enabled !== undefined) {
-        if (typeof body.slack_dm_enabled !== 'boolean') {
-            return { error: 'slack_dm_enabled must be a boolean' };
-        }
-        result.slack_dm_enabled = body.slack_dm_enabled;
-    }
-
-    // Validate notification_types
-    if (body.notification_types !== undefined) {
-        if (typeof body.notification_types !== 'object') {
-            return { error: 'notification_types must be an object' };
-        }
-
-        const validTypes = ['pattern_promotion', 'weekly_digest', 'critical_violation', 'team_alert', 'curation_candidate'];
-        for (const type of Object.keys(body.notification_types)) {
-            if (!validTypes.includes(type)) {
-                return { error: `Invalid notification type: ${type}` };
-            }
-            const typePrefs = body.notification_types[type];
-            if (typeof typePrefs !== 'object') {
-                return { error: `notification_types.${type} must be an object` };
-            }
-            if (typePrefs.email !== undefined && typeof typePrefs.email !== 'boolean') {
-                return { error: `notification_types.${type}.email must be a boolean` };
-            }
-            if (typePrefs.slack !== undefined && typeof typePrefs.slack !== 'boolean') {
-                return { error: `notification_types.${type}.slack must be a boolean` };
-            }
-        }
-        result.notification_types = body.notification_types;
-    }
-
-    // Validate project_overrides
-    if (body.project_overrides !== undefined) {
-        if (typeof body.project_overrides !== 'object') {
-            return { error: 'project_overrides must be an object' };
-        }
-        result.project_overrides = body.project_overrides;
-    }
-
-    // Validate digest_frequency
-    if (body.digest_frequency !== undefined) {
-        const validFrequencies = ['daily', 'weekly', 'monthly', 'never'];
-        if (!validFrequencies.includes(body.digest_frequency)) {
-            return { error: `Invalid digest_frequency. Valid values: ${validFrequencies.join(', ')}` };
-        }
-        result.digest_frequency = body.digest_frequency;
-    }
-
-    // Validate digest_day
-    if (body.digest_day !== undefined) {
-        if (typeof body.digest_day !== 'number' || body.digest_day < 0 || body.digest_day > 31) {
-            return { error: 'digest_day must be a number between 0 and 31' };
-        }
-        result.digest_day = body.digest_day;
-    }
-
-    // Validate quiet hours
-    if (body.quiet_hours_start !== undefined) {
-        if (!/^\d{2}:\d{2}$/.test(body.quiet_hours_start)) {
-            return { error: 'quiet_hours_start must be in HH:MM format' };
-        }
-        result.quiet_hours_start = body.quiet_hours_start;
-    }
-
-    if (body.quiet_hours_end !== undefined) {
-        if (!/^\d{2}:\d{2}$/.test(body.quiet_hours_end)) {
-            return { error: 'quiet_hours_end must be in HH:MM format' };
-        }
-        result.quiet_hours_end = body.quiet_hours_end;
-    }
-
-    if (body.quiet_hours_timezone !== undefined) {
-        result.quiet_hours_timezone = body.quiet_hours_timezone;
-    }
-
-    // Validate slack_channel
-    if (body.slack_channel !== undefined) {
-        if (body.slack_channel !== null && typeof body.slack_channel !== 'string') {
-            return { error: 'slack_channel must be a string or null' };
-        }
-        result.slack_channel = body.slack_channel;
-    }
-
-    return result;
-}
-
-/**
- * Update digest queue when frequency changes
- */
-async function updateDigestQueue(email, frequency, digestDay) {
-    // Remove existing pending digests
-    await executeQuery(`
-        DELETE FROM rapport.digest_queue
-        WHERE email_address = $1 AND status = 'pending'
-    `, [email]);
-
-    // If frequency is 'never', don't schedule anything
-    if (frequency === 'never') {
-        return;
-    }
-
-    // Calculate next scheduled time
-    const now = new Date();
-    let scheduledFor;
-
-    switch (frequency) {
-        case 'daily':
-            scheduledFor = new Date(now);
-            scheduledFor.setDate(scheduledFor.getDate() + 1);
-            scheduledFor.setHours(9, 0, 0, 0); // 9 AM next day
-            break;
-
-        case 'weekly':
-            scheduledFor = new Date(now);
-            const daysUntilNextDigestDay = (digestDay - now.getDay() + 7) % 7 || 7;
-            scheduledFor.setDate(scheduledFor.getDate() + daysUntilNextDigestDay);
-            scheduledFor.setHours(9, 0, 0, 0); // 9 AM
-            break;
-
-        case 'monthly':
-            scheduledFor = new Date(now);
-            scheduledFor.setMonth(scheduledFor.getMonth() + 1);
-            scheduledFor.setDate(digestDay || 1);
-            scheduledFor.setHours(9, 0, 0, 0); // 9 AM
-            break;
-
-        default:
-            return;
-    }
-
-    // Insert new digest into queue
-    await executeQuery(`
-        INSERT INTO rapport.digest_queue (email_address, digest_type, scheduled_for, status, digest_data)
-        VALUES ($1, $2, $3, 'pending', '{}'::jsonb)
-        ON CONFLICT (email_address, digest_type, scheduled_for) DO NOTHING
-    `, [email, frequency, scheduledFor.toISOString()]);
-}

package/src/handlers/patterns/patternEvaluatePromotionPost.js

@@ -1,173 +0,0 @@
-/**
- * Pattern Evaluate Promotion Handler
- * Checks if a pattern meets promotion thresholds for becoming a standard
- *
- * POST /api/patterns/evaluate-promotion
- * Body: { pattern, project_id, evaluate_only }
- *
- * Called by: pre-compact.js hook (evaluateForPromotion method)
- *
- * Promotion Criteria:
- * - handoff_count >= 10 (used 10+ times)
- * - success_rate >= 0.70 (70% success)
- * - developer_count >= 3 (used by 3+ developers)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-/**
- * Evaluate pattern for promotion to standard
- */
-async function evaluatePatternPromotion({ body: requestBody = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext?.requestId || 'unknown';
-
-        const {
-            pattern,
-            project_id,
-            evaluate_only = true
-        } = requestBody;
-
-        // Validate required fields
-        if (!pattern || !pattern.element) {
-            return createErrorResponse(400, 'pattern.element is required');
-        }
-
-        // Generate pattern_id from element
-        const patternId = pattern.pattern_id || `pat_${pattern.element.toLowerCase().replace(/\s+/g, '_').substring(0, 50)}`;
-
-        // Look up pattern in rapport.patterns
-        const patternQuery = `
-            SELECT
-                p.pattern_id,
-                p.intent,
-                p.maturity,
-                p.handoff_count,
-                p.successful_handoffs,
-                p.failed_handoffs,
-                p.discovered_at,
-                p.last_used
-            FROM rapport.patterns p
-            WHERE p.pattern_id = $1
-        `;
-
-        const patternResult = await executeQuery(patternQuery, [patternId]);
-
-        if (patternResult.rows.length === 0) {
-            return createSuccessResponse(
-                {
-                    Records: [{
-                        pattern_id: patternId,
-                        eligible: false,
-                        reason: 'not_found',
-                        message: 'Pattern not found in patterns table'
-                    }]
-                },
-                'Pattern not found',
-                { Total_Records: 0, Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        const pat = patternResult.rows[0];
-
-        // Query usage metrics
-        const metricsQuery = `
-            SELECT
-                COUNT(DISTINCT pu.email_address) as developer_count,
-                COUNT(DISTINCT pu.session_id) as session_count,
-                COUNT(*) FILTER (WHERE pu.success = true) as successes,
-                COUNT(*) as total_uses
-            FROM rapport.pattern_usage pu
-            WHERE pu.pattern_id = $1
-        `;
-
-        const metricsResult = await executeQuery(metricsQuery, [patternId]);
-        const metrics = metricsResult.rows[0];
-
-        const handoffCount = parseInt(pat.handoff_count) || 0;
-        const successRate = handoffCount > 0
-            ? (parseInt(pat.successful_handoffs) || 0) / handoffCount
-            : 0;
-        const developerCount = parseInt(metrics.developer_count) || 0;
-        const sessionCount = parseInt(metrics.session_count) || 0;
-
-        // Check promotion thresholds
-        const eligible =
-            handoffCount >= 10 &&
-            successRate >= 0.70 &&
-            developerCount >= 3;
-
-        const response = {
-            pattern_id: patternId,
-            eligible: eligible,
-            metrics: {
-                handoff_count: handoffCount,
-                success_rate: parseFloat(successRate.toFixed(3)),
-                developer_count: developerCount,
-                session_count: sessionCount,
-                maturity: pat.maturity,
-                success_correlation: parseFloat(successRate.toFixed(3))
-            },
-            thresholds: {
-                min_handoffs: 10,
-                min_success_rate: 0.70,
-                min_developers: 3
-            },
-            proposed_category: pattern.category || null
-        };
-
-        // If eligible and not evaluate_only, create curation candidate
-        if (eligible && !evaluate_only) {
-            const candidateQuery = `
-                INSERT INTO rapport.curation_candidates (
-                    pattern_id,
-                    proposed_category,
-                    evidence,
-                    status,
-                    created_at
-                ) VALUES ($1, $2, $3, 'pending', NOW())
-                ON CONFLICT (pattern_id) WHERE status = 'pending'
-                DO UPDATE SET
-                    evidence = EXCLUDED.evidence,
-                    created_at = NOW()
-                RETURNING candidate_id
-            `;
-
-            const evidence = {
-                handoff_count: handoffCount,
-                success_rate: successRate,
-                developer_count: developerCount,
-                session_count: sessionCount,
-                maturity: pat.maturity,
-                evaluated_at: new Date().toISOString()
-            };
-
-            try {
-                const candidateResult = await executeQuery(candidateQuery, [
-                    patternId,
-                    pattern.category || 'uncategorized',
-                    JSON.stringify(evidence)
-                ]);
-
-                if (candidateResult.rows.length > 0) {
-                    response.candidate_id = candidateResult.rows[0].candidate_id;
-                }
-            } catch (candidateError) {
-                // Candidate creation failed — still return eligibility result
-                console.error('[patternEvaluatePromotionPost] Candidate creation failed:', candidateError.message);
-            }
-        }
-
-        return createSuccessResponse(
-            { Records: [response] },
-            eligible ? 'Pattern eligible for promotion' : 'Pattern does not meet promotion criteria',
-            { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
-        );
-
-    } catch (error) {
-        console.error('Handler Error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(evaluatePatternPromotion);

package/src/handlers/patterns/patternUsagePost.js

@@ -1,182 +0,0 @@
-/**
- * Pattern Usage Handler
- * Records pattern usage (success/failure) from Claude Code sessions
- *
- * POST /api/patterns/usage
- * Body: { pattern, session_id, user_id, project_id, success, context, timestamp }
- *
- * Called by: pre-compact.js hook (reinforcePattern method)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-/**
- * Record pattern usage
- * Updates usage count and maturity level based on success
- */
-async function recordPatternUsage({ body: requestBody = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext?.requestId || 'unknown';
-
-        const {
-            pattern,
-            session_id,
-            user_id,
-            project_id,
-            success = true,
-            context = {},
-            timestamp
-        } = requestBody;
-
-        // Validate required fields
-        if (!pattern || !pattern.element) {
-            return createErrorResponse(400, 'pattern.element is required');
-        }
-
-        if (!session_id) {
-            return createErrorResponse(400, 'session_id is required');
-        }
-
-        // Generate pattern_id from element if not provided
-        const patternId = pattern.pattern_id || `pat_${pattern.element.toLowerCase().replace(/\s+/g, '_').substring(0, 50)}`;
-
-        // If no project_id, we can't create a pattern record (FK constraint)
-        // Return success anyway - hooks should not fail
-        if (!project_id) {
-            console.log('[patternUsagePost] No project_id provided, skipping pattern record');
-            return createSuccessResponse(
-                {
-                    Records: [{
-                        pattern_id: patternId,
-                        recorded: false,
-                        reason: 'no_project_id',
-                        message: 'Pattern usage logged but not recorded (no project context)'
-                    }]
-                },
-                'Pattern usage acknowledged (no project context)',
-                {
-                    Total_Records: 0,
-                    Request_ID,
-                    Timestamp: new Date().toISOString()
-                }
-            );
-        }
-
-        // First, ensure the pattern exists in rapport.patterns (upsert)
-        const upsertPatternQuery = `
-            INSERT INTO rapport.patterns (
-                pattern_id,
-                project_id,
-                intent,
-                constraints,
-                outcome_criteria,
-                maturity,
-                handoff_count,
-                successful_handoffs,
-                failed_handoffs,
-                discovered_by,
-                discovered_at,
-                last_used,
-                pattern_data
-            ) VALUES (
-                $1, $2, $3, $4, $5, 'provisional', 1,
-                CASE WHEN $6 THEN 1 ELSE 0 END,
-                CASE WHEN $6 THEN 0 ELSE 1 END,
-                $7, NOW(), NOW(), $8
-            )
-            ON CONFLICT (pattern_id) DO UPDATE SET
-                handoff_count = rapport.patterns.handoff_count + 1,
-                successful_handoffs = rapport.patterns.successful_handoffs + CASE WHEN $6 THEN 1 ELSE 0 END,
-                failed_handoffs = rapport.patterns.failed_handoffs + CASE WHEN $6 THEN 0 ELSE 1 END,
-                last_used = NOW(),
-                maturity = CASE
-                    WHEN rapport.patterns.handoff_count >= 9 AND
-                         (rapport.patterns.successful_handoffs + CASE WHEN $6 THEN 1 ELSE 0 END)::float /
-                         (rapport.patterns.handoff_count + 1) >= 0.7
-                    THEN 'reinforced'
-                    WHEN rapport.patterns.handoff_count >= 4 AND
-                         (rapport.patterns.successful_handoffs + CASE WHEN $6 THEN 1 ELSE 0 END)::float /
-                         (rapport.patterns.handoff_count + 1) >= 0.6
-                    THEN 'validated'
-                    ELSE rapport.patterns.maturity
-                END
-            RETURNING pattern_id, maturity, handoff_count, successful_handoffs, failed_handoffs
-        `;
-
-        const patternResult = await executeQuery(upsertPatternQuery, [
-            patternId,
-            project_id || null,
-            pattern.intent || pattern.element,
-            JSON.stringify(pattern.constraints || []),
-            JSON.stringify(pattern.outcome_criteria || []),
-            success,
-            user_id || 'anonymous',
-            JSON.stringify({
-                type: pattern.type,
-                category: pattern.category,
-                file: pattern.file,
-                confidence: pattern.confidence,
-                evidence: pattern.evidence
-            })
-        ]);
-
-        const updatedPattern = patternResult.rows[0];
-
-        // Record the individual usage in pattern_usage table
-        const usageQuery = `
-            INSERT INTO rapport.pattern_usage (
-                pattern_id,
-                email_address,
-                session_id,
-                success,
-                context,
-                used_at
-            ) VALUES (
-                $1, $2, $3, $4, $5, $6
-            )
-            RETURNING usage_id
-        `;
-
-        const usageResult = await executeQuery(usageQuery, [
-            patternId,
-            user_id || 'anonymous',
-            session_id,
-            success,
-            JSON.stringify({
-                working_directory: context.working_directory,
-                source: context.source,
-                file: pattern.file,
-                category: pattern.category
-            }),
-            timestamp ? new Date(timestamp) : new Date()
-        ]);
-
-        // Calculate success rate
-        const successRate = updatedPattern.successful_handoffs / updatedPattern.handoff_count;
-
-        return createSuccessResponse(
-            {
-                Records: [{
-                    usage_id: usageResult.rows[0]?.usage_id,
-                    pattern_id: updatedPattern.pattern_id,
-                    maturity: updatedPattern.maturity,
-                    usage_count: updatedPattern.handoff_count,
-                    success_rate: successRate.toFixed(2),
-                    recorded: true
-                }]
-            },
-            success ? 'Pattern usage recorded (success)' : 'Pattern usage recorded (failure)',
-            {
-                Total_Records: 1,
-                Request_ID,
-                Timestamp: new Date().toISOString()
-            }
-        );
-
-    } catch (error) {
-        console.error('Handler Error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(recordPatternUsage);