@equilateral_ai/mindmeld 3.5.3 → 4.0.2

package/src/handlers/context/purposeGet.js

@@ -1,78 +0,0 @@
-/**
- * Purpose Get Handler
- * Retrieves relationship purpose for a scope
- *
- * GET /api/context/purpose?scope=jarvis
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, checkSuperAdmin } = require('./helpers');
-
-/**
- * Get relationship purpose
- */
-async function getPurpose({ queryStringParameters: queryParams = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext.requestId;
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Unauthorized');
-        }
-
-        // Gate to super admins only (internal/beta endpoint)
-        await checkSuperAdmin.requireSuperAdmin(email);
-
-        const scope = queryParams.scope || 'jarvis';
-
-        const query = `
-            SELECT
-                purpose_text,
-                confidence,
-                confirmed,
-                maturity,
-                evolution,
-                created_at,
-                updated_at
-            FROM rapport.relationship_purpose
-            WHERE email_address = $1
-              AND scope = $2
-        `;
-        const result = await executeQuery(query, [email, scope]);
-
-        if (result.rowCount === 0) {
-            return createSuccessResponse(
-                {
-                    scope,
-                    purpose: null,
-                    message: 'No purpose defined for this scope'
-                },
-                'No purpose found',
-                { Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        const row = result.rows[0];
-
-        return createSuccessResponse(
-            {
-                scope,
-                purpose: row.purpose_text,
-                confidence: parseFloat(row.confidence),
-                confirmed: row.confirmed,
-                maturity: row.maturity,
-                evolution: row.evolution || []
-            },
-            row.purpose_text,
-            {
-                Request_ID,
-                Timestamp: new Date().toISOString()
-            }
-        );
-
-    } catch (error) {
-        console.error('Handler Error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(getPurpose);

package/src/handlers/correlations/correlationsDeveloperGet.js

@@ -1,227 +0,0 @@
-/**
- * Get Developer Correlations Handler
- * Returns session-to-commit correlation data for a specific developer
- *
- * GET /api/correlations/developer?email=xxx
- * Query params:
- *   - email (required)
- *   - lookbackDays (optional, default: 30)
- *
- * Returns:
- *   - Developer productivity metrics
- *   - Session history with commit correlation
- *   - Trend analysis
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
-
-exports.handler = wrapHandler(async (event, context) => {
-    // Extract user email from Cognito claims
-    const requestingEmail = event.requestContext?.authorizer?.claims?.email;
-    if (!requestingEmail) {
-        return createErrorResponse(401, 'Unauthorized - no email in claims');
-    }
-
-    // Get target developer email from query parameters
-    const targetEmail = decodeURIComponent(event.queryStringParameters?.email || '');
-    if (!targetEmail) {
-        return createErrorResponse(400, 'Developer email is required');
-    }
-
-    // Parse query parameters
-    const queryParams = event.queryStringParameters || {};
-    const lookbackDays = parseInt(queryParams.lookbackDays) || 30;
-
-    // Check if requesting own data or if admin
-    const isSelf = requestingEmail.toLowerCase() === targetEmail.toLowerCase();
-
-    if (!isSelf) {
-        // Verify requesting user is admin in a shared company
-        const accessResult = await executeQuery(`
-            SELECT DISTINCT ue1.company_id
-            FROM rapport.user_entitlements ue1
-            JOIN rapport.user_entitlements ue2 ON ue1.company_id = ue2.company_id
-            WHERE ue1.email_address = $1
-            AND ue2.email_address = $2
-            AND (ue1.admin = true OR ue1.manager = true)
-        `, [requestingEmail, targetEmail]);
-
-        if (accessResult.rows.length === 0) {
-            return createErrorResponse(403, 'Access denied - admin privileges required to view other developers');
-        }
-    }
-
-    // Get developer info
-    const developerResult = await executeQuery(`
-        SELECT
-            u.email_address as email,
-            CONCAT(u.first_name, ' ', u.last_name) as display_name,
-            u.first_name,
-            u.last_name
-        FROM rapport.users u
-        WHERE u.email_address = $1
-    `, [targetEmail]);
-
-    if (developerResult.rows.length === 0) {
-        return createErrorResponse(404, 'Developer not found');
-    }
-
-    const developer = developerResult.rows[0];
-
-    // Initialize analyzer
-    const analyzer = new CorrelationAnalyzer();
-
-    // Get developer productivity metrics
-    const productivity = await analyzer.getDeveloperProductivity(targetEmail, lookbackDays);
-
-    // Get session history
-    const sessionHistory = await getSessionHistory(targetEmail, lookbackDays, 20);
-
-    // Get weekly trend
-    const weeklyTrend = await getWeeklyTrend(targetEmail, lookbackDays);
-
-    // Get pattern usage
-    const patternUsage = await getPatternUsage(targetEmail, lookbackDays);
-
-    return createSuccessResponse({
-        developer: {
-            email: developer.email,
-            displayName: developer.display_name,
-            firstName: developer.first_name,
-            lastName: developer.last_name
-        },
-        productivity,
-        sessionHistory,
-        weeklyTrend,
-        patternUsage
-    });
-});
-
-/**
- * Get session history for a developer
- */
-async function getSessionHistory(email, lookbackDays, limit) {
-    const query = `
-        SELECT
-            sc.session_id,
-            sc.project_id,
-            p.project_name,
-            sc.session_started_at,
-            sc.session_ended_at,
-            sc.session_duration_seconds,
-            sc.has_commits,
-            sc.commit_count,
-            sc.total_insertions,
-            sc.total_deletions,
-            sc.total_files_changed,
-            sc.avg_commit_latency_minutes,
-            sc.patterns_used,
-            sc.correlation_type,
-            sc.correlation_score
-        FROM rapport.session_correlations sc
-        LEFT JOIN rapport.projects p ON sc.project_id = p.project_id
-        WHERE sc.email_address = $1
-        AND sc.session_started_at > NOW() - $2 * INTERVAL '1 day'
-        ORDER BY sc.session_started_at DESC
-        LIMIT $3
-    `;
-
-    const result = await executeQuery(query, [email, lookbackDays, limit]);
-
-    return result.rows.map(row => ({
-        sessionId: row.session_id,
-        projectId: row.project_id,
-        projectName: row.project_name,
-        startedAt: row.session_started_at,
-        endedAt: row.session_ended_at,
-        durationMinutes: Math.round((row.session_duration_seconds || 0) / 60),
-        hasCommits: row.has_commits,
-        commitCount: row.commit_count,
-        insertions: row.total_insertions,
-        deletions: row.total_deletions,
-        filesChanged: row.total_files_changed,
-        commitLatencyMinutes: row.avg_commit_latency_minutes,
-        patternsUsed: row.patterns_used,
-        correlationType: row.correlation_type,
-        correlationScore: parseFloat(row.correlation_score) || 0
-    }));
-}
-
-/**
- * Get weekly productivity trend for a developer
- */
-async function getWeeklyTrend(email, lookbackDays) {
-    const query = `
-        SELECT
-            DATE_TRUNC('week', sc.session_started_at) as week,
-            COUNT(*) as total_sessions,
-            COUNT(*) FILTER (WHERE sc.has_commits = true) as productive_sessions,
-            ROUND(
-                COUNT(*) FILTER (WHERE sc.has_commits = true)::decimal /
-                NULLIF(COUNT(*), 0) * 100,
-                1
-            ) as conversion_rate,
-            SUM(sc.commit_count) as total_commits,
-            SUM(sc.total_insertions) as total_insertions,
-            SUM(sc.total_deletions) as total_deletions,
-            SUM(sc.session_duration_seconds) / 3600.0 as session_hours
-        FROM rapport.session_correlations sc
-        WHERE sc.email_address = $1
-        AND sc.session_started_at > NOW() - $2 * INTERVAL '1 day'
-        GROUP BY DATE_TRUNC('week', sc.session_started_at)
-        ORDER BY week DESC
-    `;
-
-    const result = await executeQuery(query, [email, lookbackDays]);
-
-    return result.rows.map(row => ({
-        week: row.week,
-        totalSessions: parseInt(row.total_sessions) || 0,
-        productiveSessions: parseInt(row.productive_sessions) || 0,
-        conversionRate: parseFloat(row.conversion_rate) || 0,
-        totalCommits: parseInt(row.total_commits) || 0,
-        totalInsertions: parseInt(row.total_insertions) || 0,
-        totalDeletions: parseInt(row.total_deletions) || 0,
-        sessionHours: parseFloat(row.session_hours) || 0
-    }));
-}
-
-/**
- * Get pattern usage statistics for a developer
- */
-async function getPatternUsage(email, lookbackDays) {
-    const query = `
-        SELECT
-            p.pattern_id,
-            p.intent,
-            p.maturity,
-            COUNT(DISTINCT pu.session_id) as sessions_used,
-            COUNT(DISTINCT sc.session_id) FILTER (WHERE sc.has_commits = true) as sessions_with_commits,
-            ROUND(
-                COUNT(DISTINCT sc.session_id) FILTER (WHERE sc.has_commits = true)::decimal /
-                NULLIF(COUNT(DISTINCT pu.session_id), 0) * 100,
-                1
-            ) as pattern_conversion_rate
-        FROM rapport.pattern_usage pu
-        JOIN rapport.patterns p ON pu.pattern_id = p.pattern_id
-        LEFT JOIN rapport.session_correlations sc ON pu.session_id = sc.session_id
-        WHERE pu.email_address = $1
-        AND pu.used_at > NOW() - $2 * INTERVAL '1 day'
-        GROUP BY p.pattern_id, p.intent, p.maturity
-        HAVING COUNT(DISTINCT pu.session_id) >= 2
-        ORDER BY sessions_used DESC
-        LIMIT 10
-    `;
-
-    const result = await executeQuery(query, [email, lookbackDays]);
-
-    return result.rows.map(row => ({
-        patternId: row.pattern_id,
-        intent: row.intent,
-        maturity: row.maturity,
-        sessionsUsed: parseInt(row.sessions_used) || 0,
-        sessionsWithCommits: parseInt(row.sessions_with_commits) || 0,
-        patternConversionRate: parseFloat(row.pattern_conversion_rate) || 0
-    }));
-}

package/src/handlers/correlations/correlationsGet.js

@@ -1,93 +0,0 @@
-/**
- * Get Correlations Handler
- * Returns session-to-commit correlation summary for a company
- *
- * GET /api/correlations
- * Query params:
- *   - lookbackDays (optional, default: 30)
- *
- * Returns:
- *   - Overall correlation summary
- *   - Conversion rate metrics
- *   - Correlation type distribution
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
-
-exports.handler = wrapHandler(async (event, context) => {
-    // Extract user email from Cognito claims
-    const email = event.requestContext?.authorizer?.claims?.email;
-    if (!email) {
-        return createErrorResponse(401, 'Unauthorized - no email in claims');
-    }
-
-    // Parse query parameters
-    const queryParams = event.queryStringParameters || {};
-    const lookbackDays = parseInt(queryParams.lookbackDays) || 30;
-
-    // Get user's company
-    const companyResult = await executeQuery(`
-        SELECT ue.company_id
-        FROM rapport.user_entitlements ue
-        WHERE ue.email_address = $1
-        LIMIT 1
-    `, [email]);
-
-    if (companyResult.rows.length === 0) {
-        return createErrorResponse(403, 'User not associated with any company');
-    }
-
-    const companyId = companyResult.rows[0].company_id;
-
-    // Initialize analyzer
-    const analyzer = new CorrelationAnalyzer();
-
-    // Get correlation summary
-    let summary = null;
-    let patternEffectiveness = [];
-    let strugglingDevelopers = [];
-
-    try {
-        summary = await analyzer.getCorrelationSummary(companyId, lookbackDays);
-    } catch (err) {
-        console.error('Error getting correlation summary:', err.message);
-        summary = { error: err.message };
-    }
-
-    try {
-        patternEffectiveness = await analyzer.getPatternEffectiveness(null, lookbackDays);
-    } catch (err) {
-        console.error('Error getting pattern effectiveness:', err.message);
-    }
-
-    // Get struggling developers (for admins only)
-    try {
-        const isAdmin = await checkIsAdmin(email, companyId);
-        if (isAdmin) {
-            strugglingDevelopers = await analyzer.identifyStrugglingDevelopers(companyId, lookbackDays);
-        }
-    } catch (err) {
-        console.error('Error getting struggling developers:', err.message);
-    }
-
-    return createSuccessResponse({
-        summary,
-        patternEffectiveness,
-        strugglingDevelopers
-    });
-});
-
-/**
- * Check if user is admin for the company
- */
-async function checkIsAdmin(email, companyId) {
-    const result = await executeQuery(`
-        SELECT admin, manager
-        FROM rapport.user_entitlements
-        WHERE email_address = $1 AND company_id = $2
-    `, [email, companyId]);
-
-    if (result.rows.length === 0) return false;
-    return result.rows[0].admin || result.rows[0].manager;
-}

package/src/handlers/correlations/correlationsProjectGet.js

@@ -1,153 +0,0 @@
-/**
- * Get Project Correlations Handler
- * Returns session-to-commit correlation data for a specific project
- *
- * GET /api/correlations/project?project_id=xxx
- * Query params:
- *   - project_id (required)
- *   - lookbackDays (optional, default: 30)
- *
- * Returns:
- *   - Project productivity metrics
- *   - Developer breakdown
- *   - Pattern effectiveness for project
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, verifyProjectAccess } = require('./helpers');
-const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
-
-exports.handler = wrapHandler(async (event, context) => {
-    // Extract user email from Cognito claims
-    const email = event.requestContext?.authorizer?.claims?.email;
-    if (!email) {
-        return createErrorResponse(401, 'Unauthorized - no email in claims');
-    }
-
-    // Get project ID from query parameters
-    const projectId = event.queryStringParameters?.project_id;
-    if (!projectId) {
-        return createErrorResponse(400, 'Project ID is required');
-    }
-
-    // Parse query parameters
-    const queryParams = event.queryStringParameters || {};
-    const lookbackDays = parseInt(queryParams.lookbackDays) || 30;
-
-    // Verify user has access to this project (collaborator or company member)
-    const project = await verifyProjectAccess(projectId, email);
-    if (!project) {
-        return createErrorResponse(403, 'Access denied to this project');
-    }
-
-    // Initialize analyzer
-    const analyzer = new CorrelationAnalyzer();
-
-    // Get project productivity metrics
-    const projectMetrics = await analyzer.getProjectProductivity(projectId, lookbackDays);
-
-    // Get developer breakdown for the project
-    const developerBreakdown = await getDeveloperBreakdown(projectId, lookbackDays);
-
-    // Get pattern effectiveness for this project
-    const patternEffectiveness = await analyzer.getPatternEffectiveness(projectId, lookbackDays);
-
-    // Get recent correlations
-    const recentCorrelations = await getRecentCorrelations(projectId, 10);
-
-    return createSuccessResponse({
-        project: {
-            projectId: project.project_id,
-            projectName: project.project_name,
-            companyId: project.company_id
-        },
-        metrics: projectMetrics,
-        developerBreakdown,
-        patternEffectiveness,
-        recentCorrelations
-    });
-});
-
-/**
- * Get developer breakdown for a project
- */
-async function getDeveloperBreakdown(projectId, lookbackDays) {
-    const query = `
-        SELECT
-            sc.email_address,
-            CONCAT(u.first_name, ' ', u.last_name) as display_name,
-            COUNT(*) as total_sessions,
-            COUNT(*) FILTER (WHERE sc.has_commits = true) as productive_sessions,
-            ROUND(
-                COUNT(*) FILTER (WHERE sc.has_commits = true)::decimal /
-                NULLIF(COUNT(*), 0) * 100,
-                1
-            ) as conversion_rate,
-            SUM(sc.commit_count) as total_commits,
-            SUM(sc.total_insertions) as total_insertions,
-            SUM(sc.total_deletions) as total_deletions,
-            ROUND(AVG(sc.session_duration_seconds) / 60, 0) as avg_session_minutes,
-            MAX(sc.session_started_at) as last_session
-        FROM rapport.session_correlations sc
-        JOIN rapport.users u ON sc.email_address = u.email_address
-        WHERE sc.project_id = $1
-        AND sc.session_started_at > NOW() - $2 * INTERVAL '1 day'
-        GROUP BY sc.email_address, u.first_name, u.last_name
-        ORDER BY total_commits DESC NULLS LAST
-    `;
-
-    const result = await executeQuery(query, [projectId, lookbackDays]);
-
-    return result.rows.map(row => ({
-        email: row.email_address,
-        displayName: row.display_name,
-        totalSessions: parseInt(row.total_sessions) || 0,
-        productiveSessions: parseInt(row.productive_sessions) || 0,
-        conversionRate: parseFloat(row.conversion_rate) || 0,
-        totalCommits: parseInt(row.total_commits) || 0,
-        totalInsertions: parseInt(row.total_insertions) || 0,
-        totalDeletions: parseInt(row.total_deletions) || 0,
-        avgSessionMinutes: parseInt(row.avg_session_minutes) || 0,
-        lastSession: row.last_session
-    }));
-}
-
-/**
- * Get recent correlations for a project
- */
-async function getRecentCorrelations(projectId, limit) {
-    const query = `
-        SELECT
-            sc.session_id,
-            sc.email_address,
-            CONCAT(u.first_name, ' ', u.last_name) as display_name,
-            sc.session_started_at,
-            sc.session_duration_seconds,
-            sc.has_commits,
-            sc.commit_count,
-            sc.total_insertions,
-            sc.total_deletions,
-            sc.correlation_type,
-            sc.correlation_score
-        FROM rapport.session_correlations sc
-        JOIN rapport.users u ON sc.email_address = u.email_address
-        WHERE sc.project_id = $1
-        ORDER BY sc.session_started_at DESC
-        LIMIT $2
-    `;
-
-    const result = await executeQuery(query, [projectId, limit]);
-
-    return result.rows.map(row => ({
-        sessionId: row.session_id,
-        email: row.email_address,
-        displayName: row.display_name,
-        sessionStarted: row.session_started_at,
-        sessionDurationMinutes: Math.round((row.session_duration_seconds || 0) / 60),
-        hasCommits: row.has_commits,
-        commitCount: row.commit_count,
-        totalInsertions: row.total_insertions,
-        totalDeletions: row.total_deletions,
-        correlationType: row.correlation_type,
-        correlationScore: parseFloat(row.correlation_score) || 0
-    }));
-}