@equilateral_ai/mindmeld 3.0.0

package/src/handlers/context/loopsGet.js

@@ -0,0 +1,82 @@
+/**
+ * Loops Get Handler
+ * Retrieves active loops for a user
+ *
+ * GET /api/context/loops
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, checkSuperAdmin } = require('./helpers');
+
+/**
+ * Get active loops
+ */
+async function getLoops({ 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 includeCompleted = queryParams.include_completed === 'true';
+
+        let query = `
+            SELECT
+                loop_id,
+                project_scope,
+                task_description,
+                completion_promise,
+                max_iterations,
+                current_iteration,
+                status,
+                promise_found,
+                started_at,
+                updated_at,
+                completed_at
+            FROM rapport.active_loops
+            WHERE email_address = $1
+        `;
+
+        if (!includeCompleted) {
+            query += ` AND status = 'active'`;
+        }
+
+        query += ` ORDER BY started_at DESC LIMIT 20`;
+
+        const result = await executeQuery(query, [email]);
+
+        return createSuccessResponse(
+            {
+                loops: result.rows.map(row => ({
+                    id: row.loop_id,
+                    scope: row.project_scope,
+                    task: row.task_description,
+                    promise: row.completion_promise,
+                    iteration: row.current_iteration,
+                    max_iterations: row.max_iterations,
+                    status: row.status,
+                    promise_found: row.promise_found,
+                    started_at: row.started_at,
+                    updated_at: row.updated_at,
+                    completed_at: row.completed_at
+                })),
+                count: result.rowCount
+            },
+            `${result.rowCount} loops`,
+            {
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(getLoops);

package/src/handlers/context/notesCreate.js

@@ -0,0 +1,74 @@
+/**
+ * Notes Create Handler
+ * Creates a new context note from mobile/iOS
+ *
+ * POST /api/context/notes
+ * Body: { content: "...", scope: "jarvis", tags: ["mobile"] }
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, checkSuperAdmin } = require('./helpers');
+
+/**
+ * Create context note
+ */
+async function createNote({ body, 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 data = typeof body === 'string' ? JSON.parse(body) : body;
+
+        if (!data.content || data.content.trim() === '') {
+            return createErrorResponse(400, 'Content is required');
+        }
+
+        const scope = data.scope || 'global';
+        const tags = data.tags || [];
+        const source = data.source || 'mobile';
+        const metadata = data.metadata || {};
+
+        const query = `
+            INSERT INTO rapport.context_notes
+                (email_address, scope, content, tags, source, metadata)
+            VALUES ($1, $2, $3, $4, $5, $6)
+            RETURNING note_id, created_at
+        `;
+
+        const result = await executeQuery(query, [
+            email,
+            scope,
+            data.content.trim(),
+            JSON.stringify(tags),
+            source,
+            JSON.stringify(metadata)
+        ]);
+
+        const note = result.rows[0];
+
+        return createSuccessResponse(
+            {
+                note_id: note.note_id,
+                scope,
+                created_at: note.created_at
+            },
+            `Note created: ${note.note_id}`,
+            {
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(createNote);

package/src/handlers/context/purposeGet.js

@@ -0,0 +1,78 @@
+/**
+ * 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

@@ -0,0 +1,226 @@
+/**
+ * Get Developer Correlations Handler
+ * Returns session-to-commit correlation data for a specific developer
+ *
+ * GET /api/correlations/developer/{email}
+ * Query params:
+ *   - 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 path parameters
+    const targetEmail = decodeURIComponent(event.pathParameters?.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 "UserEntitlements" ue1
+            JOIN "UserEntitlements" 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,
+            u."User_Display_Name" as display_name,
+            u."First_Name" as first_name,
+            u."Last_Name" as last_name
+        FROM "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() - INTERVAL '${lookbackDays} days'
+        ORDER BY sc.session_started_at DESC
+        LIMIT $2
+    `;
+
+    const result = await executeQuery(query, [email, 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() - INTERVAL '${lookbackDays} days'
+        GROUP BY DATE_TRUNC('week', sc.session_started_at)
+        ORDER BY week DESC
+    `;
+
+    const result = await executeQuery(query, [email]);
+
+    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() - INTERVAL '${lookbackDays} days'
+        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]);
+
+    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

@@ -0,0 +1,93 @@
+/**
+ * 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 "UserEntitlements" 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 "UserEntitlements"
+        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;
+}