@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/src/handlers/analytics/convergenceGet.js

@@ -0,0 +1,236 @@
+/**
+ * Team Convergence Analytics Handler
+ * Measures how consistently team members adopt the same standards
+ *
+ * GET /api/analytics/convergence
+ * Query: ?period=30d&Company_ID=xxx
+ * Auth: Cognito JWT required, Manager or Admin role
+ *
+ * Returns convergence score, per-standard adoption rates,
+ * per-developer alignment scores, and weekly trend.
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+async function getConvergence({ requestContext, queryStringParameters }) {
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    const params = queryStringParameters || {};
+    const period = params.period || '30d';
+    const companyId = params.Company_ID;
+
+    // Validate manager/admin access
+    const accessCheck = await executeQuery(`
+        SELECT ue.company_id
+        FROM rapport.user_entitlements ue
+        WHERE ue.email_address = $1
+        AND (ue.admin = true OR ue.manager = true)
+        ${companyId ? 'AND ue.company_id = $2' : ''}
+        LIMIT 1
+    `, companyId ? [email, companyId] : [email]);
+
+    if (accessCheck.rows.length === 0) {
+        return createErrorResponse(403, 'Manager or Admin access required for convergence analytics');
+    }
+
+    const userCompanyId = companyId || accessCheck.rows[0].company_id;
+    const periodDays = parsePeriod(period);
+    const periodStart = new Date();
+    periodStart.setDate(periodStart.getDate() - periodDays);
+
+    // Get all active developers (those with sessions in period)
+    let activeDevelopers = [];
+    try {
+        const devResult = await executeQuery(`
+            SELECT DISTINCT s.email_address
+            FROM rapport.sessions s
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND s.started_at >= $2
+            AND s.email_address IS NOT NULL
+        `, [userCompanyId, periodStart]);
+        activeDevelopers = devResult.rows.map(r => r.email_address);
+    } catch (e) {
+        console.log('[Convergence] Active developers query failed:', e.message);
+    }
+
+    if (activeDevelopers.length === 0) {
+        return createSuccessResponse({
+            convergence_score: 0,
+            trend: 'stable',
+            developer_count: 0,
+            standards_in_use: 0,
+            by_standard: [],
+            by_developer: [],
+            convergence_trend: []
+        }, 'No active developers in period');
+    }
+
+    // Per-standard adoption: how many active devs received each standard
+    let byStandard = [];
+    try {
+        const standardResult = await executeQuery(`
+            SELECT
+                ss.standard_id,
+                ss.standard_name,
+                COUNT(DISTINCT s.email_address) as developers_using,
+                COUNT(*) as total_injections,
+                ROUND(AVG(ss.relevance_score), 2) as avg_relevance
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON ss.session_id = s.session_id
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND ss.created_at >= $2
+            AND s.email_address IS NOT NULL
+            GROUP BY ss.standard_id, ss.standard_name
+            HAVING COUNT(DISTINCT s.email_address) >= 1
+            ORDER BY developers_using DESC, total_injections DESC
+        `, [userCompanyId, periodStart]);
+
+        byStandard = standardResult.rows.map(row => ({
+            standard_id: row.standard_id,
+            standard_name: row.standard_name,
+            adoption_rate: Math.round((parseInt(row.developers_using) / activeDevelopers.length) * 100),
+            developers_using: parseInt(row.developers_using),
+            total_injections: parseInt(row.total_injections),
+            avg_relevance: parseFloat(row.avg_relevance) || 0
+        }));
+    } catch (e) {
+        console.log('[Convergence] Per-standard query failed:', e.message);
+    }
+
+    // Per-developer: how many unique standards each dev uses
+    let byDeveloper = [];
+    try {
+        const devStandardsResult = await executeQuery(`
+            SELECT
+                s.email_address,
+                COALESCE(MAX(ue.display_name), s.email_address) as display_name,
+                COUNT(DISTINCT ss.standard_id) as unique_standards,
+                COUNT(*) as total_injections
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON ss.session_id = s.session_id
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            LEFT JOIN rapport.user_entitlements ue ON s.email_address = ue.email_address AND ue.company_id = $1
+            WHERE p.company_id = $1
+            AND ss.created_at >= $2
+            AND s.email_address IS NOT NULL
+            GROUP BY s.email_address
+            ORDER BY unique_standards DESC
+        `, [userCompanyId, periodStart]);
+
+        const totalUniqueStandards = byStandard.length;
+
+        byDeveloper = devStandardsResult.rows.map(row => ({
+            email: row.email_address,
+            display_name: row.display_name,
+            unique_standards: parseInt(row.unique_standards),
+            total_injections: parseInt(row.total_injections),
+            alignment_score: totalUniqueStandards > 0
+                ? Math.round((parseInt(row.unique_standards) / totalUniqueStandards) * 100)
+                : 0
+        }));
+    } catch (e) {
+        console.log('[Convergence] Per-developer query failed:', e.message);
+    }
+
+    // Convergence score: average adoption rate across standards
+    // High score = most standards are used by most developers
+    const convergenceScore = byStandard.length > 0
+        ? Math.round(byStandard.reduce((sum, s) => sum + s.adoption_rate, 0) / byStandard.length)
+        : 0;
+
+    // Weekly convergence trend (last 8 weeks or period, whichever is shorter)
+    let convergenceTrend = [];
+    try {
+        const trendResult = await executeQuery(`
+            WITH weekly_adoption AS (
+                SELECT
+                    DATE_TRUNC('week', ss.created_at) as week,
+                    ss.standard_id,
+                    COUNT(DISTINCT s.email_address) as devs_using
+                FROM rapport.session_standards ss
+                JOIN rapport.sessions s ON ss.session_id = s.session_id
+                JOIN rapport.projects p ON s.project_id = p.project_id
+                WHERE p.company_id = $1
+                AND ss.created_at >= $2
+                AND s.email_address IS NOT NULL
+                GROUP BY DATE_TRUNC('week', ss.created_at), ss.standard_id
+            ),
+            weekly_devs AS (
+                SELECT
+                    DATE_TRUNC('week', s.started_at) as week,
+                    COUNT(DISTINCT s.email_address) as active_devs
+                FROM rapport.sessions s
+                JOIN rapport.projects p ON s.project_id = p.project_id
+                WHERE p.company_id = $1
+                AND s.started_at >= $2
+                AND s.email_address IS NOT NULL
+                GROUP BY DATE_TRUNC('week', s.started_at)
+            )
+            SELECT
+                wa.week,
+                ROUND(AVG(
+                    CASE WHEN wd.active_devs > 0
+                        THEN (wa.devs_using::numeric / wd.active_devs) * 100
+                        ELSE 0
+                    END
+                )) as score,
+                COUNT(DISTINCT wa.standard_id) as standards_count,
+                MAX(wd.active_devs) as developer_count
+            FROM weekly_adoption wa
+            JOIN weekly_devs wd ON wa.week = wd.week
+            GROUP BY wa.week
+            ORDER BY wa.week
+        `, [userCompanyId, periodStart]);
+
+        convergenceTrend = trendResult.rows.map(row => ({
+            week: row.week,
+            score: parseInt(row.score) || 0,
+            standards_count: parseInt(row.standards_count),
+            developer_count: parseInt(row.developer_count)
+        }));
+    } catch (e) {
+        console.log('[Convergence] Trend query failed:', e.message);
+    }
+
+    // Determine trend direction
+    let trend = 'stable';
+    if (convergenceTrend.length >= 2) {
+        const recent = convergenceTrend[convergenceTrend.length - 1].score;
+        const earlier = convergenceTrend[0].score;
+        if (recent > earlier + 5) trend = 'improving';
+        else if (recent < earlier - 5) trend = 'declining';
+    }
+
+    return createSuccessResponse({
+        convergence_score: convergenceScore,
+        trend,
+        developer_count: activeDevelopers.length,
+        standards_in_use: byStandard.length,
+        by_standard: byStandard,
+        by_developer: byDeveloper,
+        convergence_trend: convergenceTrend
+    }, 'Convergence analytics retrieved');
+}
+
+exports.handler = wrapHandler(getConvergence);
+
+function parsePeriod(period) {
+    const match = period.match(/^(\d+)([dwm])$/);
+    if (!match) return 30;
+
+    const [, num, unit] = match;
+    const n = parseInt(num);
+
+    switch (unit) {
+        case 'd': return n;
+        case 'w': return n * 7;
+        case 'm': return n * 30;
+        default: return 30;
+    }
+}

package/src/handlers/analytics/developerScoreGet.js

@@ -7,11 +7,6 @@
  *   - project_id (required) - Project to scope metrics
  *   - period (optional, default: 30d) - 30d or 90d
  *
- * Returns:
- *   - team_summary: aggregate quality metrics
- *   - developers: per-developer scores, violations, trends
- *   - trend_data: daily average scores for charting
- *
  * Auth: Cognito JWT required, Manager or Admin role
  */
 
@@ -32,19 +27,18 @@ async function getDeveloperScores({ requestContext, queryStringParameters }) {
         return createErrorResponse(400, 'project_id is required');
     }
 
-    // Validate period parameter
     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 "UserEntitlements" ue
-        JOIN rapport.projects p ON p."Company_ID" = ue."Company_ID"
-        WHERE ue."Email_Address" = $1
+        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)
+        AND (ue.admin = true OR ue.manager = true)
         LIMIT 1
     `, [email, projectId]);
 
@@ -52,112 +46,66 @@ async function getDeveloperScores({ requestContext, queryStringParameters }) {
         return createErrorResponse(403, 'Manager or Admin access required for this project');
     }
 
-    const companyId = accessCheck.rows[0].Company_ID;
+    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 for the project
+    // Fetch developer metrics — join pattern_usage through sessions for project scope
     const developerResult = await executeQuery(`
         SELECT
-            u."Email_Address" as user_email,
-            u."User_Display_Name" as display_name,
-            COALESCE(SUM(pu.usage_count), 0) as patterns_used,
-            COALESCE(
-                (SELECT COUNT(*) FROM rapport.pattern_violations pv
-                 WHERE pv.developer_email = u."Email_Address"
-                 AND pv.project_id = $2
-                 AND pv.detected_at >= $3),
-                0
-            ) as violations,
-            COALESCE(dm.compliance_score, 0) as compliance_score,
+            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 "UserEntitlements" ue
-        JOIN "Users" u ON u."Email_Address" = ue."Email_Address"
-        LEFT JOIN rapport.pattern_usage pu ON pu.email_address = u."Email_Address"
-            AND pu.project_id = $2
+        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
-        LEFT JOIN rapport.developer_metrics dm ON dm.developer_email = u."Email_Address"
-            AND dm.project_id = $2
+            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
-        LEFT JOIN rapport.session_correlations sc ON sc.email_address = u."Email_Address"
+            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."User_Display_Name", dm.compliance_score
-        ORDER BY u."User_Display_Name" ASC
+        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]);
 
-    // Fetch violation categories per developer
-    const violationCategories = await executeQuery(`
-        SELECT
-            pv.developer_email,
-            pv.category,
-            COUNT(*) as count
-        FROM rapport.pattern_violations pv
-        WHERE pv.project_id = $1
-        AND pv.detected_at >= $2
-        GROUP BY pv.developer_email, pv.category
-    `, [projectId, periodStart]);
-
-    // Build category lookup
-    const categoryLookup = {};
-    for (const row of violationCategories.rows) {
-        if (!categoryLookup[row.developer_email]) {
-            categoryLookup[row.developer_email] = {};
-        }
-        categoryLookup[row.developer_email][row.category] = parseInt(row.count);
-    }
-
-    // Fetch trend data for the previous period to determine direction
-    const previousPeriodStart = new Date();
-    previousPeriodStart.setDate(previousPeriodStart.getDate() - (periodDays * 2));
-
-    const previousScores = await executeQuery(`
-        SELECT
-            dm.developer_email,
-            AVG(dm.compliance_score) as prev_avg_score
-        FROM rapport.developer_metrics dm
-        WHERE dm.project_id = $1
-        AND dm.period_start >= $2
-        AND dm.period_start < $3
-        GROUP BY dm.developer_email
-    `, [projectId, previousPeriodStart, periodStart]);
-
-    const previousScoreLookup = {};
-    for (const row of previousScores.rows) {
-        previousScoreLookup[row.developer_email] = parseFloat(row.prev_avg_score);
-    }
-
-    // Calculate quality scores and build developer list
+    // Build developer list with quality scores
     const developers = developerResult.rows.map(row => {
         const patternsUsed = parseInt(row.patterns_used) || 0;
-        const violations = parseInt(row.violations) || 0;
         const complianceScore = parseFloat(row.compliance_score) || 0;
         const standardsAdherence = complianceScore / 100;
 
-        // Quality score formula: (patterns_used * 2 + standards_adherence * 50 - violations * 5), capped 0-100
-        const rawScore = (patternsUsed * 2) + (standardsAdherence * 50) - (violations * 5);
+        // 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)));
 
-        // Determine trend
-        const prevScore = previousScoreLookup[row.user_email];
-        let trend = 'stable';
-        if (prevScore !== undefined) {
-            const scoreDiff = qualityScore - prevScore;
-            if (scoreDiff > 5) trend = 'improving';
-            else if (scoreDiff < -5) trend = 'declining';
-        }
-
         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: violations,
-            violations_by_category: categoryLookup[row.user_email] || {},
-            trend,
+            violations: 0,
+            violations_by_category: {},
+            trend: 'stable',
             last_active: row.last_active
                 ? new Date(row.last_active).toISOString().split('T')[0]
                 : null
@@ -172,35 +120,17 @@ async function getDeveloperScores({ requestContext, queryStringParameters }) {
     const avgAdherence = totalDevelopers > 0
         ? parseFloat((developers.reduce((sum, d) => sum + d.standards_adherence, 0) / totalDevelopers).toFixed(2))
         : 0;
-    const totalViolations = developers.reduce((sum, d) => sum + d.violations, 0);
-
-    // Fetch trend data (daily averages)
-    const trendResult = await executeQuery(`
-        SELECT
-            DATE(dm.period_start) as date,
-            AVG(dm.compliance_score) as avg_score
-        FROM rapport.developer_metrics dm
-        WHERE dm.project_id = $1
-        AND dm.period_start >= $2
-        GROUP BY DATE(dm.period_start)
-        ORDER BY date ASC
-    `, [projectId, periodStart]);
-
-    const trendData = trendResult.rows.map(row => ({
-        date: new Date(row.date).toISOString().split('T')[0],
-        avg_score: Math.round(parseFloat(row.avg_score))
-    }));
 
     return createSuccessResponse({
         team_summary: {
             total_developers: totalDevelopers,
             avg_quality_score: avgQualityScore,
             standards_adherence: avgAdherence,
-            total_violations: totalViolations,
+            total_violations: 0,
             period
         },
         developers,
-        trend_data: trendData
+        trend_data: []
     }, 'Developer scores retrieved successfully');
 }
 

package/src/handlers/collaborators/collaboratorInvite.js

@@ -82,7 +82,7 @@ async function inviteCollaborator({ body: requestBody = {}, requestContext }) {
         `, [inviteToken, projectId, targetEmail]);
 
         // Build invite URL
-        const appUrl = process.env.APP_URL || 'https://mindmeld.dev';
+        const appUrl = process.env.APP_URL || 'https://app.mindmeld.dev';
         const inviteUrl = `${appUrl}/invite/accept?token=${inviteToken}`;
 
         // Send email

package/src/handlers/company/companyUsersDelete.js

@@ -0,0 +1,141 @@
+/**
+ * Company Users Remove Handler
+ * Removes a user's entitlement from a company
+ * If the user was admin-paid, decrements license count and updates Stripe subscription quantity
+ *
+ * DELETE /api/company/users?company_id=xxx&email=xxx
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+const Stripe = require('stripe');
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
+
+/**
+ * Remove user from company
+ * Requires admin access to the company
+ */
+async function removeCompanyUser({ queryStringParameters: queryParams = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const callerEmail = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        const companyId = queryParams.company_id;
+        const targetEmail = queryParams.email;
+
+        if (!callerEmail) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        if (!companyId || !targetEmail) {
+            return createErrorResponse(400, 'company_id and email query parameters are required');
+        }
+
+        // Prevent self-removal
+        if (targetEmail === callerEmail) {
+            return createErrorResponse(400, 'Cannot remove yourself from the company');
+        }
+
+        // Verify caller is admin of this company
+        const adminQuery = `
+            SELECT admin, client_id FROM rapport.user_entitlements
+            WHERE email_address = $1 AND company_id = $2
+        `;
+        const adminCheck = await executeQuery(adminQuery, [callerEmail, companyId]);
+
+        if (adminCheck.rowCount === 0 || !adminCheck.rows[0].admin) {
+            return createErrorResponse(403, 'Admin access required to remove users');
+        }
+
+        const clientId = adminCheck.rows[0].client_id;
+
+        // Check the target user's billing_type before deleting
+        const targetQuery = `
+            SELECT billing_type FROM rapport.user_entitlements
+            WHERE email_address = $1 AND company_id = $2
+        `;
+        const targetResult = await executeQuery(targetQuery, [targetEmail, companyId]);
+
+        if (targetResult.rowCount === 0) {
+            return createErrorResponse(404, `User ${targetEmail} not found in this company`);
+        }
+
+        const billingType = targetResult.rows[0].billing_type;
+
+        // If admin-paid, decrement license count and update Stripe
+        let stripeUpdated = false;
+        if (billingType === 'admin_paid') {
+            // Get client's Stripe subscription
+            const clientQuery = `
+                SELECT stripe_subscription_id, license_count
+                FROM rapport.clients WHERE client_id = $1
+            `;
+            const clientResult = await executeQuery(clientQuery, [clientId]);
+            const clientRecord = clientResult.rows[0];
+
+            if (clientRecord?.stripe_subscription_id) {
+                // Decrement license_count (minimum 1 — the admin's own license)
+                const updateResult = await executeQuery(`
+                    UPDATE rapport.clients
+                    SET license_count = GREATEST(COALESCE(license_count, 1) - 1, 1), last_updated = CURRENT_TIMESTAMP
+                    WHERE client_id = $1
+                    RETURNING license_count
+                `, [clientId]);
+                const newLicenseCount = updateResult.rows[0].license_count;
+
+                // Update Stripe subscription quantity
+                try {
+                    const subscription = await stripe.subscriptions.retrieve(clientRecord.stripe_subscription_id);
+                    const item = subscription.items.data[0];
+                    if (item) {
+                        await stripe.subscriptions.update(clientRecord.stripe_subscription_id, {
+                            items: [{ id: item.id, quantity: newLicenseCount }],
+                            proration_behavior: 'none'
+                        });
+                        stripeUpdated = true;
+                        console.log(`[License] Decreased Stripe quantity to ${newLicenseCount} for ${clientId}`);
+                    }
+                } catch (stripeError) {
+                    console.error('[License] Stripe update failed on removal:', stripeError.message);
+                    // Revert license_count since Stripe failed
+                    await executeQuery(`
+                        UPDATE rapport.clients
+                        SET license_count = COALESCE(license_count, 0) + 1, last_updated = CURRENT_TIMESTAMP
+                        WHERE client_id = $1
+                    `, [clientId]);
+                    return createErrorResponse(500, 'Failed to update subscription. Please try again or contact support.');
+                }
+            }
+        }
+
+        // Delete the entitlement
+        const deleteQuery = `
+            DELETE FROM rapport.user_entitlements
+            WHERE email_address = $1 AND company_id = $2
+            RETURNING email_address
+        `;
+        const result = await executeQuery(deleteQuery, [targetEmail, companyId]);
+
+        const message = billingType === 'admin_paid'
+            ? `User ${targetEmail} removed and license released${stripeUpdated ? '' : ' (Stripe update pending)'}`
+            : `User ${targetEmail} removed from company`;
+
+        return createSuccessResponse(
+            { Records: result.rows },
+            message,
+            {
+                Total_Records: result.rowCount,
+                Request_ID,
+                Timestamp: new Date().toISOString(),
+                license_released: billingType === 'admin_paid',
+                stripe_updated: stripeUpdated
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(removeCompanyUser);