@equilateral_ai/mindmeld 3.0.0

package/src/handlers/activity/activityGetTeam.js

@@ -0,0 +1,130 @@
+/**
+ * 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 "UserEntitlements" ue
+        JOIN "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
+    const summaryResult = await executeQuery(`
+        SELECT * FROM rapport.v_team_activity_summary
+        WHERE company_id = $1
+    `, [companyId]);
+
+    // Get individual developer activity
+    const developersResult = await executeQuery(`
+        SELECT
+            email_address,
+            display_name,
+            sessions_30d,
+            sessions_7d,
+            last_session,
+            commits_30d,
+            commits_7d,
+            last_commit,
+            days_since_commit,
+            prs_merged_30d,
+            session_to_commit_conversion_pct
+        FROM rapport.mv_developer_activity
+        WHERE company_id = $1
+        ORDER BY
+            CASE
+                WHEN days_since_commit IS NULL THEN 999
+                ELSE days_since_commit
+            END DESC,
+            sessions_30d DESC
+    `, [companyId]);
+
+    const summary = summaryResult.rows[0] || {
+        total_developers: 0,
+        active_developers: 0,
+        stale_developers: 0,
+        very_stale_developers: 0,
+        avg_sessions_30d: 0,
+        avg_commits_30d: 0,
+        avg_conversion_pct: 0
+    };
+
+    const developers = developersResult.rows.map(dev => ({
+        email_address: dev.email_address,
+        display_name: dev.display_name,
+        sessions: {
+            last_30_days: parseInt(dev.sessions_30d) || 0,
+            last_7_days: parseInt(dev.sessions_7d) || 0,
+            last_session: dev.last_session
+        },
+        commits: {
+            last_30_days: parseInt(dev.commits_30d) || 0,
+            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: parseFloat(dev.session_to_commit_conversion_pct) || 0,
+        status: getDevStatus(dev)
+    }));
+
+    return createSuccessResponse(
+        {
+            Records: [{
+                company_id: companyId,
+                summary: {
+                    total_developers: parseInt(summary.total_developers) || 0,
+                    active_developers: parseInt(summary.active_developers) || 0,
+                    stale_developers: parseInt(summary.stale_developers) || 0,
+                    very_stale_developers: parseInt(summary.very_stale_developers) || 0,
+                    avg_sessions_30d: parseFloat(summary.avg_sessions_30d)?.toFixed(1) || 0,
+                    avg_commits_30d: parseFloat(summary.avg_commits_30d)?.toFixed(1) || 0,
+                    avg_conversion_pct: parseFloat(summary.avg_conversion_pct)?.toFixed(1) || 0
+                },
+                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/alerts/alertsAcknowledge.js

@@ -0,0 +1,91 @@
+/**
+ * Alerts Acknowledge Handler
+ * Acknowledges or resolves an attention alert
+ *
+ * PUT /api/alerts/{alert_id}/acknowledge
+ * Auth: Cognito JWT required, Manager or Admin role
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+exports.handler = wrapHandler(async ({ requestContext, pathParameters, 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 = pathParameters?.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 "UserEntitlements" ue
+        JOIN "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() }
+    );
+});

package/src/handlers/alerts/alertsGet.js

@@ -0,0 +1,250 @@
+/**
+ * Alerts Get Handler
+ * Retrieves attention alerts (own alerts or team alerts for managers)
+ *
+ * GET /api/alerts
+ * Auth: Cognito JWT required
+ *
+ * Query Parameters:
+ * - status: 'active' (default), 'acknowledged', 'resolved', or 'all'
+ * - type: Filter by alert type (optional)
+ * - severity: Filter by severity (optional)
+ */
+
+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 user role
+    const userCheck = await executeQuery(`
+        SELECT
+            ue."Company_ID",
+            ue."Manager",
+            ue."Admin",
+            u."Super_Admin"
+        FROM "UserEntitlements" ue
+        JOIN "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;
+    const companyId = userRole.Company_ID;
+
+    // Parse query parameters
+    const status = queryStringParameters?.status || 'active';
+    const alertType = queryStringParameters?.type || null;
+    const severity = queryStringParameters?.severity || null;
+
+    let result;
+
+    if (isManager) {
+        // Get team alerts with optional filters
+        let query = `
+            SELECT
+                aa.alert_id,
+                aa.email_address,
+                u."User_Display_Name" as user_name,
+                aa.alert_type,
+                aa.severity,
+                aa.details,
+                aa.status,
+                aa.acknowledged_by,
+                aa.acknowledged_at,
+                aa.expires_at,
+                aa.created_at
+            FROM rapport.attention_alerts aa
+            JOIN "Users" u ON aa.email_address = u."Email_Address"
+            WHERE aa.company_id = $1
+        `;
+
+        const params = [companyId];
+        let paramIndex = 2;
+
+        // Status filter
+        if (status !== 'all') {
+            query += ` AND aa.status = $${paramIndex}`;
+            params.push(status);
+            paramIndex++;
+        }
+
+        // Alert type filter
+        if (alertType) {
+            query += ` AND aa.alert_type = $${paramIndex}`;
+            params.push(alertType);
+            paramIndex++;
+        }
+
+        // Severity filter
+        if (severity) {
+            query += ` AND aa.severity = $${paramIndex}`;
+            params.push(severity);
+            paramIndex++;
+        }
+
+        // Order by severity (critical > warning > info) then by date
+        query += `
+            ORDER BY
+                CASE aa.severity
+                    WHEN 'critical' THEN 1
+                    WHEN 'warning' THEN 2
+                    ELSE 3
+                END,
+                aa.created_at DESC
+        `;
+
+        result = await executeQuery(query, params);
+    } else {
+        // Get own alerts only
+        let query = `
+            SELECT
+                aa.alert_id,
+                aa.email_address,
+                aa.alert_type,
+                aa.severity,
+                aa.details,
+                aa.status,
+                aa.expires_at,
+                aa.created_at
+            FROM rapport.attention_alerts aa
+            WHERE aa.email_address = $1
+        `;
+
+        const params = [email];
+        let paramIndex = 2;
+
+        if (status !== 'all') {
+            query += ` AND aa.status = $${paramIndex}`;
+            params.push(status);
+            paramIndex++;
+        }
+
+        if (alertType) {
+            query += ` AND aa.alert_type = $${paramIndex}`;
+            params.push(alertType);
+            paramIndex++;
+        }
+
+        if (severity) {
+            query += ` AND aa.severity = $${paramIndex}`;
+            params.push(severity);
+            paramIndex++;
+        }
+
+        query += ` ORDER BY aa.created_at DESC`;
+
+        result = await executeQuery(query, params);
+    }
+
+    const alerts = result.rows.map(alert => ({
+        alert_id: alert.alert_id,
+        email_address: alert.email_address,
+        user_name: alert.user_name || null,
+        alert_type: alert.alert_type,
+        severity: alert.severity,
+        details: alert.details,
+        status: alert.status,
+        acknowledged_by: alert.acknowledged_by || null,
+        acknowledged_at: alert.acknowledged_at || null,
+        expires_at: alert.expires_at || null,
+        created_at: alert.created_at,
+        message: getAlertMessage(alert.alert_type, alert.details),
+        recommendation: getAlertRecommendation(alert.alert_type, alert.severity)
+    }));
+
+    // Calculate summary statistics
+    const summary = {
+        total: alerts.length,
+        by_severity: {
+            critical: alerts.filter(a => a.severity === 'critical').length,
+            warning: alerts.filter(a => a.severity === 'warning').length,
+            info: alerts.filter(a => a.severity === 'info').length
+        },
+        by_type: {}
+    };
+
+    for (const alert of alerts) {
+        summary.by_type[alert.alert_type] = (summary.by_type[alert.alert_type] || 0) + 1;
+    }
+
+    return createSuccessResponse(
+        { Records: alerts, summary, is_manager_view: isManager },
+        'Alerts retrieved',
+        { Total_Records: alerts.length, Request_ID, Timestamp: new Date().toISOString() }
+    );
+});
+
+/**
+ * Generate human-readable message for alert
+ */
+function 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 (${details.commits_30d} commits, 0 sessions)`;
+
+        case 'high_violation_rate':
+            return `High standards violation rate: ${details.violation_rate}% (${details.violations}/${details.standards_shown})`;
+
+        case 'stalled_patterns':
+            return `Stalled patterns: ${details.stale_patterns} patterns unused, ${details.provisional_patterns} stuck in provisional`;
+
+        case 'declining_activity':
+            const decline = details.decline_pct || 0;
+            return `Activity declined ${decline}% (was ${details.avg_previous_weeks} sessions/week, now ${details.current_week})`;
+
+        default:
+            return `Alert: ${alertType}`;
+    }
+}
+
+/**
+ * Generate actionable recommendation for alert
+ */
+function getAlertRecommendation(alertType, severity) {
+    const recommendations = {
+        stale_commits: {
+            critical: 'Schedule a 1:1 to check in on progress and identify blockers',
+            warning: 'Consider reaching out to offer assistance',
+            info: 'Monitor for continued inactivity'
+        },
+        low_conversion: {
+            critical: 'Review session recordings to identify workflow issues',
+            warning: 'Check if developer needs additional training on AI tools',
+            info: 'Provide tips for effective AI-assisted development'
+        },
+        no_ai_usage: {
+            info: 'Share AI adoption resources and success stories from team'
+        },
+        high_violation_rate: {
+            critical: 'Schedule standards review session with developer',
+            warning: 'Share relevant standards documentation',
+            info: 'Consider adding standards to onboarding materials'
+        },
+        stalled_patterns: {
+            warning: 'Review patterns for promotion or deprecation',
+            info: 'Encourage pattern documentation and sharing'
+        },
+        declining_activity: {
+            warning: 'Check in on workload and well-being',
+            info: 'Monitor for continued decline'
+        }
+    };
+
+    return recommendations[alertType]?.[severity] || recommendations[alertType]?.info || 'Monitor and follow up as needed';
+}

package/src/handlers/collaborators/collaboratorAdd.js

@@ -0,0 +1,201 @@
+/**
+ * Collaborator Add Handler
+ * Adds a collaborator to a project
+ *
+ * POST /api/projects/{projectId}/collaborators
+ * Body: { email, role }
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, checkCollaboratorBillingLimits, checkEnterpriseSeatLimits } = require('./helpers');
+
+/**
+ * Add collaborator to project
+ * Requires owner or admin role on project
+ */
+async function addCollaborator({ pathParameters = {}, body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const inviterEmail = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        const { projectId } = pathParameters;
+        const { email, role = 'collaborator' } = requestBody;
+
+        if (!inviterEmail) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        if (!projectId) {
+            return createErrorResponse(400, 'projectId is required');
+        }
+
+        if (!email) {
+            return createErrorResponse(400, 'email is required');
+        }
+
+        // Validate role
+        const validRoles = ['admin', 'collaborator', 'viewer'];
+        if (!validRoles.includes(role)) {
+            return createErrorResponse(400, `Invalid role. Must be one of: ${validRoles.join(', ')}`);
+        }
+
+        // Check inviter has permission (owner or admin)
+        const accessQuery = `
+            SELECT
+                pc.role,
+                p.company_id,
+                c.client_id,
+                c.subscription_tier,
+                c.billing_type,
+                c.billable_users,
+                c.seat_count,
+                c.enterprise_package
+            FROM rapport.projects p
+            JOIN rapport.project_collaborators pc
+                ON p.project_id = pc.project_id
+                AND pc.email_address = $1
+            JOIN rapport.clients c ON p.company_id = c.client_id
+            WHERE p.project_id = $2
+        `;
+        const accessCheck = await executeQuery(accessQuery, [inviterEmail, projectId]);
+
+        if (accessCheck.rowCount === 0) {
+            return createErrorResponse(403, 'You do not have access to this project');
+        }
+
+        const access = accessCheck.rows[0];
+        if (access.role !== 'owner' && access.role !== 'admin') {
+            return createErrorResponse(403, 'Only project owners and admins can add collaborators');
+        }
+
+        // Check billing/subscription limits based on billing type
+        const collaboratorCountQuery = `
+            SELECT COUNT(*) as count
+            FROM rapport.project_collaborators
+            WHERE project_id = $1
+        `;
+        const countResult = await executeQuery(collaboratorCountQuery, [projectId]);
+        const currentCount = parseInt(countResult.rows[0].count) || 0;
+
+        // For enterprise tier, check seat limits
+        if (access.subscription_tier === 'enterprise') {
+            // Count total users across all projects for this client
+            const totalUsersQuery = `
+                SELECT COUNT(DISTINCT pc.email_address) as total_users
+                FROM rapport.project_collaborators pc
+                JOIN rapport.projects p ON pc.project_id = p.project_id
+                WHERE p.company_id = $1
+            `;
+            const totalUsersResult = await executeQuery(totalUsersQuery, [access.client_id]);
+            const totalUsers = parseInt(totalUsersResult.rows[0].total_users) || 0;
+
+            const seatCheck = checkEnterpriseSeatLimits(
+                {
+                    subscription_tier: access.subscription_tier,
+                    seat_count: access.seat_count
+                },
+                totalUsers
+            );
+
+            if (!seatCheck.allowed) {
+                return createErrorResponse(403, seatCheck.message, {
+                    code: 'ENTERPRISE_SEAT_LIMIT',
+                    seatsUsed: seatCheck.seatsUsed,
+                    seatCount: seatCheck.seatCount,
+                    billingAction: seatCheck.billingAction
+                });
+            }
+        }
+
+        const billingCheck = checkCollaboratorBillingLimits(
+            {
+                subscription_tier: access.subscription_tier,
+                billing_type: access.billing_type
+            },
+            currentCount
+        );
+
+        if (!billingCheck.allowed) {
+            return createErrorResponse(403, billingCheck.message, {
+                code: 'SUBSCRIPTION_LIMIT',
+                current: currentCount,
+                limit: billingCheck.limit
+            });
+        }
+
+        // Check if collaborator already exists
+        const existsQuery = `
+            SELECT email_address FROM rapport.project_collaborators
+            WHERE project_id = $1 AND email_address = $2
+        `;
+        const existsCheck = await executeQuery(existsQuery, [projectId, email]);
+
+        if (existsCheck.rowCount > 0) {
+            return createErrorResponse(409, 'User is already a collaborator on this project');
+        }
+
+        // Check if user exists in system (internal) or is external
+        const userQuery = `SELECT email_address FROM rapport.users WHERE email_address = $1`;
+        const userCheck = await executeQuery(userQuery, [email]);
+        const isExternal = userCheck.rowCount === 0;
+
+        // Add collaborator
+        const insertQuery = `
+            INSERT INTO rapport.project_collaborators
+                (project_id, email_address, role, invited_by, invited_at, is_external, accepted_at)
+            VALUES
+                ($1, $2, $3, $4, NOW(), $5, ${isExternal ? 'NULL' : 'NOW()'})
+            RETURNING
+                project_id,
+                email_address,
+                role,
+                invited_by,
+                invited_at,
+                is_external,
+                accepted_at
+        `;
+
+        const result = await executeQuery(insertQuery, [
+            projectId,
+            email,
+            role,
+            inviterEmail,
+            isExternal
+        ]);
+
+        const collaborator = result.rows[0];
+
+        // For enterprise invoice billing, increment billable_users count
+        if (billingCheck.billingAction === 'increment_billable_users') {
+            await executeQuery(`
+                UPDATE rapport.clients
+                SET billable_users = COALESCE(billable_users, 0) + 1,
+                    last_updated = NOW()
+                WHERE client_id = $1
+            `, [access.client_id]);
+        }
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    ...collaborator,
+                    status: isExternal ? 'pending_invite' : 'active',
+                    message: isExternal
+                        ? 'Collaborator added. Send invite to complete setup.'
+                        : 'Collaborator added successfully.'
+                }]
+            },
+            isExternal ? 'Collaborator added (pending invite)' : 'Collaborator added',
+            {
+                Total_Records: 1,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(addCollaborator);