@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/handlers/activity/activityGetTeam.js

@@ -1,175 +0,0 @@
-/**
- * Activity Get Team Handler
- * Retrieves team activity summary (managers only)
- *
- * GET /api/activity/team
- * Auth: Cognito JWT required, Manager or Admin role
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-exports.handler = wrapHandler(async ({ requestContext, queryStringParameters }) => {
-    const Request_ID = requestContext.requestId;
-    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-    if (!email) {
-        return createErrorResponse(401, 'Authentication required');
-    }
-
-    // Check if user is a manager or admin
-    const managerCheck = await executeQuery(`
-        SELECT ue.company_id, ue.manager, ue.admin, u.super_admin
-        FROM rapport.user_entitlements ue
-        JOIN rapport.users u ON ue.email_address = u.email_address
-        WHERE ue.email_address = $1
-    `, [email]);
-
-    if (managerCheck.rowCount === 0) {
-        return createErrorResponse(403, 'Access denied');
-    }
-
-    const userRole = managerCheck.rows[0];
-    const isAuthorized = userRole.manager || userRole.admin || userRole.super_admin;
-
-    if (!isAuthorized) {
-        return createErrorResponse(403, 'Manager or Admin access required');
-    }
-
-    const companyId = queryStringParameters?.company_id || userRole.company_id;
-
-    // Get team summary directly from base tables
-    const summaryResult = await executeQuery(`
-        SELECT
-            COUNT(DISTINCT ue.email_address) as total_developers,
-            COUNT(DISTINCT ue.email_address) FILTER (
-                WHERE EXISTS (
-                    SELECT 1 FROM rapport.sessions s
-                    WHERE s.email_address = ue.email_address
-                    AND s.started_at > NOW() - INTERVAL '30 days'
-                )
-            ) as active_developers
-        FROM rapport.user_entitlements ue
-        JOIN rapport.users u ON ue.email_address = u.email_address
-        WHERE ue.company_id = $1
-        AND u.active = true
-    `, [companyId]);
-
-    // Get individual developer activity
-    const developersResult = await executeQuery(`
-        SELECT
-            ue.email_address,
-            u.first_name || ' ' || u.last_name as display_name,
-            COALESCE(sess.sessions_30d, 0) as sessions_30d,
-            COALESCE(sess.sessions_7d, 0) as sessions_7d,
-            sess.last_session,
-            COALESCE(comm.commits_30d, 0) as commits_30d,
-            COALESCE(comm.commits_7d, 0) as commits_7d,
-            comm.last_commit,
-            CASE WHEN comm.last_commit IS NOT NULL
-                THEN EXTRACT(DAY FROM NOW() - comm.last_commit)::INTEGER
-                ELSE NULL
-            END as days_since_commit,
-            COALESCE(pr_data.prs_merged_30d, 0) as prs_merged_30d
-        FROM rapport.user_entitlements ue
-        JOIN rapport.users u ON ue.email_address = u.email_address
-        LEFT JOIN (
-            SELECT email_address,
-                COUNT(*) FILTER (WHERE started_at > NOW() - INTERVAL '30 days') as sessions_30d,
-                COUNT(*) FILTER (WHERE started_at > NOW() - INTERVAL '7 days') as sessions_7d,
-                MAX(started_at) as last_session
-            FROM rapport.sessions
-            GROUP BY email_address
-        ) sess ON sess.email_address = ue.email_address
-        LEFT JOIN (
-            SELECT author_email,
-                COUNT(*) FILTER (WHERE commit_timestamp > NOW() - INTERVAL '30 days') as commits_30d,
-                COUNT(*) FILTER (WHERE commit_timestamp > NOW() - INTERVAL '7 days') as commits_7d,
-                MAX(commit_timestamp) as last_commit
-            FROM rapport.commits
-            GROUP BY author_email
-        ) comm ON comm.author_email = ue.email_address
-        LEFT JOIN (
-            SELECT pr.author_email,
-                COUNT(*) as prs_merged_30d
-            FROM rapport.pull_requests pr
-            WHERE pr.merged_at > NOW() - INTERVAL '30 days'
-            GROUP BY pr.author_email
-        ) pr_data ON pr_data.author_email = ue.email_address
-        WHERE ue.company_id = $1
-        AND u.active = true
-        ORDER BY
-            CASE WHEN comm.last_commit IS NULL THEN 999
-                 ELSE EXTRACT(DAY FROM NOW() - comm.last_commit)
-            END DESC,
-            COALESCE(sess.sessions_30d, 0) DESC
-    `, [companyId]);
-
-    const summary = summaryResult.rows[0] || {
-        total_developers: 0,
-        active_developers: 0
-    };
-
-    const developers = developersResult.rows.map(dev => {
-        const sessions30d = parseInt(dev.sessions_30d) || 0;
-        const commits30d = parseInt(dev.commits_30d) || 0;
-        const conversionPct = sessions30d > 0 ? Math.round((commits30d / sessions30d) * 100) : 0;
-
-        return {
-            email_address: dev.email_address,
-            display_name: dev.display_name,
-            sessions: {
-                last_30_days: sessions30d,
-                last_7_days: parseInt(dev.sessions_7d) || 0,
-                last_session: dev.last_session
-            },
-            commits: {
-                last_30_days: commits30d,
-                last_7_days: parseInt(dev.commits_7d) || 0,
-                last_commit: dev.last_commit,
-                days_since_commit: parseInt(dev.days_since_commit) || null
-            },
-            prs_merged_30d: parseInt(dev.prs_merged_30d) || 0,
-            session_to_commit_conversion_pct: conversionPct,
-            status: getDevStatus(dev)
-        };
-    });
-
-    const totalSessions = developers.reduce((sum, d) => sum + d.sessions.last_30_days, 0);
-    const totalCommits = developers.reduce((sum, d) => sum + d.commits.last_30_days, 0);
-    const devCount = developers.length || 1;
-    const avgConversion = developers.length > 0
-        ? developers.reduce((sum, d) => sum + d.session_to_commit_conversion_pct, 0) / developers.length
-        : 0;
-
-    return createSuccessResponse(
-        {
-            Records: [{
-                company_id: companyId,
-                summary: {
-                    total_developers: parseInt(summary.total_developers) || 0,
-                    active_developers: parseInt(summary.active_developers) || 0,
-                    stale_developers: developers.filter(d => d.status === 'stale').length,
-                    very_stale_developers: developers.filter(d => d.status === 'very_stale').length,
-                    avg_sessions_30d: parseFloat((totalSessions / devCount).toFixed(1)),
-                    avg_commits_30d: parseFloat((totalCommits / devCount).toFixed(1)),
-                    avg_conversion_pct: parseFloat(avgConversion.toFixed(1))
-                },
-                developers
-            }]
-        },
-        'Team activity retrieved',
-        { Total_Records: developers.length, Request_ID, Timestamp: new Date().toISOString() }
-    );
-});
-
-function getDevStatus(dev) {
-    const daysSinceCommit = parseInt(dev.days_since_commit);
-    const sessions30d = parseInt(dev.sessions_30d) || 0;
-    const commits30d = parseInt(dev.commits_30d) || 0;
-
-    if (daysSinceCommit > 14) return 'very_stale';
-    if (daysSinceCommit > 7) return 'stale';
-    if (sessions30d === 0 && commits30d > 0) return 'no_ai_usage';
-    if (sessions30d > 0 && commits30d === 0) return 'low_output';
-    return 'active';
-}

package/src/handlers/admin/adminSetup.js

@@ -1,216 +0,0 @@
-/**
- * Admin Setup Handler
- * One-time setup for enterprise clients via Lambda invocation
- *
- * Invoke via AWS CLI:
- *   aws lambda invoke --function-name rapport-api-prod-AdminSetup \
- *     --payload '{"action":"setup-equilateral"}' \
- *     --profile production-sso response.json
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('../helpers');
-
-const SETUP_CONFIGS = {
-    'setup-equilateral': {
-        client: {
-            client_id: 'EQUILATERAL_MAIN',
-            client_name: 'Equilateral AI',
-            client_type: 'ENTERPRISE',
-            subscription_tier: 'enterprise',
-            seat_count: 25,
-            billing_type: 'internal'
-        },
-        company: {
-            company_id: 'EQUILATERAL_MAIN',
-            company_name: 'Equilateral AI'
-        },
-        admin_email: 'james.ford@happyhippo.ai',
-        invitations: [
-            { email: 'adeel@equilateral.ai', name: 'Adeel', role: 'member' },
-            { email: 'satish@equilateral.ai', name: 'Satish', role: 'member' }
-        ]
-    }
-};
-
-async function adminSetup({ body }) {
-    try {
-        const action = body?.action;
-
-        // Special action: list-tables
-        if (action === 'list-tables') {
-            const result = await executeQuery(`
-                SELECT table_name
-                FROM information_schema.tables
-                WHERE table_schema = 'rapport'
-                ORDER BY table_name
-            `);
-            return createSuccessResponse({
-                tables: result.rows.map(r => r.table_name)
-            }, `Found ${result.rows.length} tables`);
-        }
-
-        // Special action: run-sql (for migrations)
-        if (action === 'run-sql') {
-            const sql = body?.sql;
-            if (!sql) {
-                return createErrorResponse(400, 'sql parameter required');
-            }
-            try {
-                await executeQuery(sql);
-                return createSuccessResponse({ executed: true }, 'SQL executed successfully');
-            } catch (err) {
-                return createErrorResponse(500, `SQL error: ${err.message}`);
-            }
-        }
-
-        // Special action: query (returns results)
-        if (action === 'query') {
-            const sql = body?.sql;
-            if (!sql) {
-                return createErrorResponse(400, 'sql parameter required');
-            }
-            try {
-                const result = await executeQuery(sql);
-                return createSuccessResponse({ rows: result.rows, rowCount: result.rowCount }, `Query returned ${result.rowCount} rows`);
-            } catch (err) {
-                return createErrorResponse(500, `Query error: ${err.message}`);
-            }
-        }
-
-        if (!action || !SETUP_CONFIGS[action]) {
-            return createErrorResponse(400, `Invalid action. Available: ${Object.keys(SETUP_CONFIGS).join(', ')}, list-tables, run-sql`);
-        }
-
-        const config = SETUP_CONFIGS[action];
-        const results = [];
-
-        // 1. Create client
-        const existingClient = await executeQuery(
-            'SELECT client_id FROM rapport.clients WHERE client_id = $1',
-            [config.client.client_id]
-        );
-
-        if (existingClient.rows.length > 0) {
-            results.push({ step: 'client', status: 'exists', client_id: config.client.client_id });
-        } else {
-            await executeQuery(`
-                INSERT INTO rapport.clients (
-                    client_id, client_name, client_type, client_status, active,
-                    subscription_tier, subscription_status, billing_type, seat_count
-                )
-                VALUES ($1, $2, $3, 'Active', true, $4, 'active', $5, $6)
-            `, [
-                config.client.client_id,
-                config.client.client_name,
-                config.client.client_type,
-                config.client.subscription_tier,
-                config.client.billing_type,
-                config.client.seat_count
-            ]);
-            results.push({ step: 'client', status: 'created', client_id: config.client.client_id });
-        }
-
-        // 2. Create company
-        const existingCompany = await executeQuery(
-            'SELECT company_id FROM rapport.companies WHERE company_id = $1',
-            [config.company.company_id]
-        );
-
-        if (existingCompany.rows.length > 0) {
-            results.push({ step: 'company', status: 'exists', company_id: config.company.company_id });
-        } else {
-            await executeQuery(`
-                INSERT INTO rapport.companies (
-                    company_id, client_id, company_name, company_status
-                )
-                VALUES ($1, $2, $3, 'Active')
-            `, [config.company.company_id, config.client.client_id, config.company.company_name]);
-            results.push({ step: 'company', status: 'created', company_id: config.company.company_id });
-        }
-
-        // 3. Create admin entitlement
-        const existingEntitlement = await executeQuery(
-            'SELECT * FROM rapport.user_entitlements WHERE email_address = $1 AND company_id = $2',
-            [config.admin_email, config.company.company_id]
-        );
-
-        if (existingEntitlement.rows.length > 0) {
-            results.push({ step: 'admin_entitlement', status: 'exists', email: config.admin_email });
-        } else {
-            await executeQuery(`
-                INSERT INTO rapport.user_entitlements (
-                    email_address, client_id, company_id, admin, member
-                )
-                VALUES ($1, $2, $3, true, true)
-            `, [config.admin_email, config.client.client_id, config.company.company_id]);
-            results.push({ step: 'admin_entitlement', status: 'created', email: config.admin_email });
-        }
-
-        // 4. Create invitations (skip if table doesn't exist)
-        let invitationsSkipped = false;
-        for (const inv of config.invitations) {
-            if (invitationsSkipped) {
-                results.push({ step: 'invitation', status: 'skipped', email: inv.email, reason: 'table not found' });
-                continue;
-            }
-            try {
-                await executeQuery(`
-                    INSERT INTO rapport.enterprise_invitations
-                        (client_id, company_id, email, role, invited_by, status, created_at)
-                    VALUES ($1, $2, $3, $4, $5, 'pending', NOW())
-                    ON CONFLICT (company_id, email) DO UPDATE SET
-                        role = EXCLUDED.role,
-                        invited_by = EXCLUDED.invited_by,
-                        status = 'pending',
-                        created_at = NOW()
-                `, [config.client.client_id, config.company.company_id, inv.email.toLowerCase(), inv.role, config.admin_email]);
-                results.push({ step: 'invitation', status: 'created', email: inv.email, role: inv.role });
-            } catch (err) {
-                if (err.code === '42P01') { // relation does not exist
-                    invitationsSkipped = true;
-                    results.push({ step: 'invitation', status: 'skipped', email: inv.email, reason: 'enterprise_invitations table not found' });
-                } else {
-                    results.push({ step: 'invitation', status: 'error', email: inv.email, error: err.message });
-                }
-            }
-        }
-
-        // 5. Get final state
-        const clientInfo = await executeQuery(
-            'SELECT client_id, client_name, subscription_tier, seat_count FROM rapport.clients WHERE client_id = $1',
-            [config.client.client_id]
-        );
-
-        const entitlements = await executeQuery(
-            'SELECT email_address, admin, member FROM rapport.user_entitlements WHERE company_id = $1',
-            [config.company.company_id]
-        );
-
-        let invitationsList = [];
-        try {
-            const invitations = await executeQuery(
-                'SELECT email, role, status FROM rapport.enterprise_invitations WHERE company_id = $1',
-                [config.company.company_id]
-            );
-            invitationsList = invitations.rows;
-        } catch (err) {
-            if (err.code !== '42P01') throw err; // rethrow if not "relation does not exist"
-        }
-
-        return createSuccessResponse({
-            action,
-            results,
-            final_state: {
-                client: clientInfo.rows[0],
-                entitlements: entitlements.rows,
-                invitations: invitationsList
-            }
-        }, 'Setup complete');
-
-    } catch (error) {
-        console.error('Admin setup error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(adminSetup);

package/src/handlers/alerts/alertsAcknowledge.js

@@ -1,92 +0,0 @@
-/**
- * Alerts Acknowledge Handler
- * Acknowledges or resolves an attention alert
- *
- * POST /api/alerts/acknowledge
- * Body: { alert_id, action }
- * Auth: Cognito JWT required, Manager or Admin role
- */
-
-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');
-    }
-
-    const alertId = body?.alert_id;
-    if (!alertId) {
-        return createErrorResponse(400, 'Alert ID required');
-    }
-
-    // Check user role
-    const userCheck = await executeQuery(`
-        SELECT ue.company_id, ue.manager, ue.admin, u.super_admin
-        FROM rapport.user_entitlements ue
-        JOIN rapport.users u ON ue.email_address = u.email_address
-        WHERE ue.email_address = $1
-    `, [email]);
-
-    if (userCheck.rowCount === 0) {
-        return createErrorResponse(403, 'Access denied');
-    }
-
-    const userRole = userCheck.rows[0];
-    const isManager = userRole.manager || userRole.admin || userRole.super_admin;
-
-    if (!isManager) {
-        return createErrorResponse(403, 'Manager or Admin access required');
-    }
-
-    const action = body?.action || 'acknowledge'; // acknowledge or resolve
-
-    // Verify alert exists and belongs to user's company
-    const alertCheck = await executeQuery(`
-        SELECT alert_id, company_id, status
-        FROM rapport.attention_alerts
-        WHERE alert_id = $1
-    `, [alertId]);
-
-    if (alertCheck.rowCount === 0) {
-        return createErrorResponse(404, 'Alert not found');
-    }
-
-    const alert = alertCheck.rows[0];
-    if (alert.company_id !== userRole.company_id && !userRole.super_admin) {
-        return createErrorResponse(403, 'Access denied to this alert');
-    }
-
-    // Update alert
-    let result;
-    if (action === 'resolve') {
-        result = await executeQuery(`
-            UPDATE rapport.attention_alerts
-            SET
-                status = 'resolved',
-                acknowledged_by = $1,
-                acknowledged_at = COALESCE(acknowledged_at, NOW()),
-                resolved_at = NOW()
-            WHERE alert_id = $2
-            RETURNING *
-        `, [email, alertId]);
-    } else {
-        result = await executeQuery(`
-            UPDATE rapport.attention_alerts
-            SET
-                status = 'acknowledged',
-                acknowledged_by = $1,
-                acknowledged_at = NOW()
-            WHERE alert_id = $2
-            RETURNING *
-        `, [email, alertId]);
-    }
-
-    return createSuccessResponse(
-        { Records: result.rows },
-        `Alert ${action}d`,
-        { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
-    );
-});