@equilateral_ai/mindmeld 3.5.3 → 4.0.2

package/src/handlers/analytics/developerScoreGet.js

@@ -1,137 +0,0 @@
-/**
- * Developer Score Analytics Handler
- * Quality scoring and standards adherence metrics per developer
- *
- * GET /api/analytics/developer-scores
- * Query params:
- *   - project_id (required) - Project to scope metrics
- *   - period (optional, default: 30d) - 30d or 90d
- *
- * Auth: Cognito JWT required, Manager or Admin role
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-async function getDeveloperScores({ requestContext, queryStringParameters }) {
-    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-    if (!email) {
-        return createErrorResponse(401, 'Unauthorized');
-    }
-
-    const params = queryStringParameters || {};
-    const projectId = params.project_id;
-    const period = params.period || '30d';
-
-    if (!projectId) {
-        return createErrorResponse(400, 'project_id is required');
-    }
-
-    if (!['30d', '90d'].includes(period)) {
-        return createErrorResponse(400, 'period must be 30d or 90d');
-    }
-
-    // Validate access - must be manager/admin with access to this project
-    const accessCheck = await executeQuery(`
-        SELECT ue.company_id
-        FROM rapport.user_entitlements ue
-        JOIN rapport.projects p ON p.company_id = ue.company_id
-        WHERE ue.email_address = $1
-        AND p.project_id = $2
-        AND (ue.admin = true OR ue.manager = true)
-        LIMIT 1
-    `, [email, projectId]);
-
-    if (accessCheck.rows.length === 0) {
-        return createErrorResponse(403, 'Manager or Admin access required for this project');
-    }
-
-    const companyId = accessCheck.rows[0].company_id;
-    const periodDays = period === '90d' ? 90 : 30;
-    const periodStart = new Date();
-    periodStart.setDate(periodStart.getDate() - periodDays);
-
-    // Fetch developer metrics — join pattern_usage through sessions for project scope
-    const developerResult = await executeQuery(`
-        SELECT
-            u.email_address as user_email,
-            CONCAT(u.first_name, ' ', u.last_name) as display_name,
-            COALESCE(pu_counts.patterns_used, 0) as patterns_used,
-            COALESCE(dm_scores.compliance_score, 0) as compliance_score,
-            MAX(sc.session_started_at) as last_active
-        FROM rapport.user_entitlements ue
-        JOIN rapport.users u ON u.email_address = ue.email_address
-        LEFT JOIN (
-            SELECT pu.email_address, COUNT(*) as patterns_used
-            FROM rapport.pattern_usage pu
-            JOIN rapport.sessions s ON pu.session_id = s.session_id
-            WHERE s.project_id = $2
-            AND pu.used_at >= $3
-            GROUP BY pu.email_address
-        ) pu_counts ON pu_counts.email_address = u.email_address
-        LEFT JOIN (
-            SELECT dm.developer_email, AVG(dm.compliance_score) as compliance_score
-            FROM rapport.developer_metrics dm
-            JOIN rapport.git_repositories r ON dm.repo_id = r.repo_id
-            JOIN rapport.projects p ON p.repo_url = r.repo_url
-            WHERE p.project_id = $2
-            AND dm.period_start >= $3
-            GROUP BY dm.developer_email
-        ) dm_scores ON dm_scores.developer_email = u.email_address
-        LEFT JOIN rapport.session_correlations sc ON sc.email_address = u.email_address
-            AND sc.project_id = $2
-            AND sc.session_started_at >= $3
-        WHERE ue.company_id = $1
-        GROUP BY u.email_address, u.first_name, u.last_name,
-                 pu_counts.patterns_used, dm_scores.compliance_score
-        ORDER BY u.first_name ASC, u.last_name ASC
-    `, [companyId, projectId, periodStart]);
-
-    // Build developer list with quality scores
-    const developers = developerResult.rows.map(row => {
-        const patternsUsed = parseInt(row.patterns_used) || 0;
-        const complianceScore = parseFloat(row.compliance_score) || 0;
-        const standardsAdherence = complianceScore / 100;
-
-        // Quality score: patterns used + standards adherence, capped 0-100
-        const rawScore = (patternsUsed * 2) + (standardsAdherence * 50);
-        const qualityScore = Math.max(0, Math.min(100, Math.round(rawScore)));
-
-        return {
-            user_email: row.user_email,
-            display_name: row.display_name || row.user_email.split('@')[0],
-            quality_score: qualityScore,
-            standards_adherence: parseFloat(standardsAdherence.toFixed(2)),
-            patterns_used: patternsUsed,
-            violations: 0,
-            violations_by_category: {},
-            trend: 'stable',
-            last_active: row.last_active
-                ? new Date(row.last_active).toISOString().split('T')[0]
-                : null
-        };
-    });
-
-    // Calculate team summary
-    const totalDevelopers = developers.length;
-    const avgQualityScore = totalDevelopers > 0
-        ? Math.round(developers.reduce((sum, d) => sum + d.quality_score, 0) / totalDevelopers)
-        : 0;
-    const avgAdherence = totalDevelopers > 0
-        ? parseFloat((developers.reduce((sum, d) => sum + d.standards_adherence, 0) / totalDevelopers).toFixed(2))
-        : 0;
-
-    return createSuccessResponse({
-        team_summary: {
-            total_developers: totalDevelopers,
-            avg_quality_score: avgQualityScore,
-            standards_adherence: avgAdherence,
-            total_violations: 0,
-            period
-        },
-        developers,
-        trend_data: []
-    }, 'Developer scores retrieved successfully');
-}
-
-exports.handler = wrapHandler(getDeveloperScores);

package/src/handlers/collaborators/collaboratorAdd.js

@@ -1,200 +0,0 @@
-/**
- * Collaborator Add Handler
- * Adds a collaborator to a project
- *
- * POST /api/collaborators
- * Body: { project_id, 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({ body: requestBody = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const inviterEmail = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        const { project_id: projectId, 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);

package/src/handlers/collaborators/collaboratorInvite.js

@@ -1,219 +0,0 @@
-/**
- * Collaborator Invite Handler
- * Sends invitation email to a collaborator
- *
- * POST /api/collaborators/invite
- * Body: { project_id, email }
- * Auth: Cognito JWT required
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-const { SESClient, SendEmailCommand } = require('@aws-sdk/client-ses');
-
-const ses = new SESClient({ region: process.env.AWS_REGION || 'us-east-2' });
-
-/**
- * Send invitation email to collaborator
- * Requires owner or admin role on project
- */
-async function inviteCollaborator({ body: requestBody = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const inviterEmail = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        const { project_id: projectId, email: collaboratorEmail } = requestBody;
-
-        if (!inviterEmail) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        if (!projectId || !collaboratorEmail) {
-            return createErrorResponse(400, 'project_id and email are required');
-        }
-
-        const targetEmail = collaboratorEmail;
-
-        // Check inviter has permission and get project details
-        const accessQuery = `
-            SELECT
-                pc.role as inviter_role,
-                p.project_name,
-                p.description,
-                tc.email_address as target_email,
-                tc.role as target_role,
-                tc.invited_at,
-                tc.accepted_at,
-                u.full_name as inviter_name
-            FROM rapport.projects p
-            JOIN rapport.project_collaborators pc
-                ON p.project_id = pc.project_id
-                AND pc.email_address = $1
-            JOIN rapport.project_collaborators tc
-                ON p.project_id = tc.project_id
-                AND tc.email_address = $3
-            LEFT JOIN rapport.users u ON u.email_address = $1
-            WHERE p.project_id = $2
-        `;
-        const accessCheck = await executeQuery(accessQuery, [inviterEmail, projectId, targetEmail]);
-
-        if (accessCheck.rowCount === 0) {
-            return createErrorResponse(404, 'Project or collaborator not found');
-        }
-
-        const data = accessCheck.rows[0];
-
-        // Check permissions
-        if (data.inviter_role !== 'owner' && data.inviter_role !== 'admin') {
-            return createErrorResponse(403, 'Only project owners and admins can send invites');
-        }
-
-        // Check if already accepted
-        if (data.accepted_at) {
-            return createErrorResponse(400, 'Collaborator has already accepted the invitation');
-        }
-
-        // Generate invite token (simple UUID-based token)
-        const inviteToken = `inv_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
-
-        // Store invite token
-        await executeQuery(`
-            UPDATE rapport.project_collaborators
-            SET invite_token = $1, invited_at = NOW()
-            WHERE project_id = $2 AND email_address = $3
-        `, [inviteToken, projectId, targetEmail]);
-
-        // Build invite URL
-        const appUrl = process.env.APP_URL || 'https://app.mindmeld.dev';
-        const inviteUrl = `${appUrl}/invite/accept?token=${inviteToken}`;
-
-        // Send email
-        const inviterName = data.inviter_name || inviterEmail;
-        const emailParams = {
-            Source: process.env.EMAIL_FROM || 'noreply@mindmeld.dev',
-            Destination: {
-                ToAddresses: [targetEmail]
-            },
-            Message: {
-                Subject: {
-                    Data: `You've been invited to collaborate on ${data.project_name}`,
-                    Charset: 'UTF-8'
-                },
-                Body: {
-                    Html: {
-                        Data: `
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="utf-8">
-    <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; }
-        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
-        .header { text-align: center; margin-bottom: 30px; }
-        .logo { font-size: 24px; font-weight: bold; color: #2563eb; }
-        .content { background: #f8fafc; border-radius: 8px; padding: 30px; margin-bottom: 20px; }
-        .button { display: inline-block; background: #2563eb; color: white; padding: 12px 24px; border-radius: 6px; text-decoration: none; font-weight: 500; }
-        .button:hover { background: #1d4ed8; }
-        .footer { text-align: center; color: #64748b; font-size: 14px; }
-        .project-name { font-size: 20px; font-weight: 600; color: #1e293b; }
-        .role-badge { display: inline-block; background: #e0e7ff; color: #3730a3; padding: 4px 12px; border-radius: 20px; font-size: 14px; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <div class="logo">MindMeld</div>
-        </div>
-        <div class="content">
-            <p>Hi there,</p>
-            <p><strong>${inviterName}</strong> has invited you to collaborate on a project:</p>
-            <p class="project-name">${data.project_name}</p>
-            ${data.description ? `<p style="color: #64748b;">${data.description}</p>` : ''}
-            <p>Your role: <span class="role-badge">${data.target_role}</span></p>
-            <p style="margin-top: 30px;">
-                <a href="${inviteUrl}" class="button">Accept Invitation</a>
-            </p>
-            <p style="margin-top: 20px; font-size: 14px; color: #64748b;">
-                Or copy this link: ${inviteUrl}
-            </p>
-        </div>
-        <div class="footer">
-            <p>MindMeld - Collaboration memory that compounds</p>
-            <p>Powered by Equilateral AI</p>
-        </div>
-    </div>
-</body>
-</html>
-                        `,
-                        Charset: 'UTF-8'
-                    },
-                    Text: {
-                        Data: `
-You've been invited to collaborate on ${data.project_name}
-
-${inviterName} has invited you to join their project on MindMeld.
-
-Project: ${data.project_name}
-${data.description ? `Description: ${data.description}` : ''}
-Your role: ${data.target_role}
-
-Accept the invitation: ${inviteUrl}
-
----
-MindMeld - Collaboration memory that compounds
-Powered by Equilateral AI
-                        `,
-                        Charset: 'UTF-8'
-                    }
-                }
-            }
-        };
-
-        try {
-            await ses.send(new SendEmailCommand(emailParams));
-        } catch (sesError) {
-            console.error('SES Error:', sesError);
-            // Don't fail the request, just note that email failed
-            return createSuccessResponse(
-                {
-                    Records: [{
-                        email: targetEmail,
-                        project_id: projectId,
-                        invite_url: inviteUrl,
-                        email_sent: false,
-                        email_error: 'Failed to send email. Share the invite link manually.'
-                    }]
-                },
-                'Invite created but email failed to send',
-                {
-                    Total_Records: 1,
-                    Request_ID,
-                    Timestamp: new Date().toISOString()
-                }
-            );
-        }
-
-        return createSuccessResponse(
-            {
-                Records: [{
-                    email: targetEmail,
-                    project_id: projectId,
-                    project_name: data.project_name,
-                    role: data.target_role,
-                    invite_url: inviteUrl,
-                    email_sent: true
-                }]
-            },
-            'Invitation sent successfully',
-            {
-                Total_Records: 1,
-                Request_ID,
-                Timestamp: new Date().toISOString()
-            }
-        );
-
-    } catch (error) {
-        console.error('Handler Error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(inviteCollaborator);

package/src/handlers/collaborators/collaboratorList.js

@@ -1,82 +0,0 @@
-/**
- * Collaborator List Handler
- * Lists all collaborators for a project
- *
- * GET /api/collaborators?project_id=xxx
- * Auth: Cognito JWT required
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, verifyProjectAccess } = require('./helpers');
-
-/**
- * List project collaborators
- * Requires collaborator access to project
- */
-async function listCollaborators({ queryStringParameters: queryParams = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-        const projectId = queryParams.project_id;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        if (!projectId) {
-            return createErrorResponse(400, 'projectId is required');
-        }
-
-        // Verify user has access to project (collaborator or company member)
-        const projectAccess = await verifyProjectAccess(projectId, email);
-        if (!projectAccess) {
-            return createErrorResponse(403, 'You do not have access to this project');
-        }
-
-        // Get all collaborators
-        const query = `
-            SELECT
-                pc.email_address,
-                pc.role,
-                pc.invited_by,
-                pc.invited_at,
-                pc.accepted_at,
-                pc.is_external,
-                u.full_name,
-                CASE
-                    WHEN pc.accepted_at IS NOT NULL THEN 'active'
-                    WHEN pc.invited_at IS NOT NULL THEN 'pending'
-                    ELSE 'unknown'
-                END as status
-            FROM rapport.project_collaborators pc
-            LEFT JOIN rapport.users u ON u.email_address = pc.email_address
-            WHERE pc.project_id = $1
-            ORDER BY
-                CASE pc.role
-                    WHEN 'owner' THEN 1
-                    WHEN 'admin' THEN 2
-                    WHEN 'collaborator' THEN 3
-                    WHEN 'viewer' THEN 4
-                    ELSE 5
-                END,
-                pc.invited_at ASC
-        `;
-
-        const result = await executeQuery(query, [projectId]);
-
-        return createSuccessResponse(
-            { Records: result.rows },
-            'Collaborators retrieved',
-            {
-                Total_Records: result.rowCount,
-                Request_ID,
-                Timestamp: new Date().toISOString()
-            }
-        );
-
-    } catch (error) {
-        console.error('Handler Error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(listCollaborators);