@equilateral_ai/mindmeld 3.2.0 → 3.3.0

package/src/handlers/correlations/correlationsDeveloperGet.js

@@ -2,8 +2,9 @@
  * Get Developer Correlations Handler
  * Returns session-to-commit correlation data for a specific developer
  *
- * GET /api/correlations/developer/{email}
+ * GET /api/correlations/developer?email=xxx
  * Query params:
+ *   - email (required)
  *   - lookbackDays (optional, default: 30)
  *
  * Returns:
@@ -13,7 +14,7 @@
  */
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('../../core/CorrelationAnalyzer');
+const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
 
 exports.handler = wrapHandler(async (event, context) => {
     // Extract user email from Cognito claims
@@ -22,8 +23,8 @@ exports.handler = wrapHandler(async (event, context) => {
         return createErrorResponse(401, 'Unauthorized - no email in claims');
     }
 
-    // Get target developer email from path parameters
-    const targetEmail = decodeURIComponent(event.pathParameters?.email || '');
+    // Get target developer email from query parameters
+    const targetEmail = decodeURIComponent(event.queryStringParameters?.email || '');
     if (!targetEmail) {
         return createErrorResponse(400, 'Developer email is required');
     }
@@ -121,12 +122,12 @@ async function getSessionHistory(email, lookbackDays, limit) {
         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'
+        AND sc.session_started_at > NOW() - $2 * INTERVAL '1 day'
         ORDER BY sc.session_started_at DESC
-        LIMIT $2
+        LIMIT $3
     `;
 
-    const result = await executeQuery(query, [email, limit]);
+    const result = await executeQuery(query, [email, lookbackDays, limit]);
 
     return result.rows.map(row => ({
         sessionId: row.session_id,
@@ -167,12 +168,12 @@ async function getWeeklyTrend(email, lookbackDays) {
             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'
+        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]);
+    const result = await executeQuery(query, [email, lookbackDays]);
 
     return result.rows.map(row => ({
         week: row.week,
@@ -206,14 +207,14 @@ async function getPatternUsage(email, lookbackDays) {
         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'
+        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]);
+    const result = await executeQuery(query, [email, lookbackDays]);
 
     return result.rows.map(row => ({
         patternId: row.pattern_id,

package/src/handlers/correlations/correlationsGet.js

@@ -13,7 +13,7 @@
  */
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('../../core/CorrelationAnalyzer');
+const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
 
 exports.handler = wrapHandler(async (event, context) => {
     // Extract user email from Cognito claims

package/src/handlers/correlations/correlationsProjectGet.js

@@ -2,8 +2,9 @@
  * Get Project Correlations Handler
  * Returns session-to-commit correlation data for a specific project
  *
- * GET /api/correlations/project/{projectId}
+ * GET /api/correlations/project?project_id=xxx
  * Query params:
+ *   - project_id (required)
  *   - lookbackDays (optional, default: 30)
  *
  * Returns:
@@ -13,7 +14,7 @@
  */
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('../../core/CorrelationAnalyzer');
+const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
 
 exports.handler = wrapHandler(async (event, context) => {
     // Extract user email from Cognito claims
@@ -22,8 +23,8 @@ exports.handler = wrapHandler(async (event, context) => {
         return createErrorResponse(401, 'Unauthorized - no email in claims');
     }
 
-    // Get project ID from path parameters
-    const projectId = event.pathParameters?.projectId;
+    // Get project ID from query parameters
+    const projectId = event.queryStringParameters?.project_id;
     if (!projectId) {
         return createErrorResponse(400, 'Project ID is required');
     }
@@ -98,12 +99,12 @@ async function getDeveloperBreakdown(projectId, lookbackDays) {
         FROM rapport.session_correlations sc
         JOIN "Users" u ON sc.email_address = u."Email_Address"
         WHERE sc.project_id = $1
-        AND sc.session_started_at > NOW() - INTERVAL '${lookbackDays} days'
+        AND sc.session_started_at > NOW() - $2 * INTERVAL '1 day'
         GROUP BY sc.email_address, u."User_Display_Name"
         ORDER BY total_commits DESC NULLS LAST
     `;
 
-    const result = await executeQuery(query, [projectId]);
+    const result = await executeQuery(query, [projectId, lookbackDays]);
 
     return result.rows.map(row => ({
         email: row.email_address,

package/src/handlers/enterprise/enterpriseAuditGet.js

@@ -0,0 +1,108 @@
+/**
+ * Enterprise Audit Log Get Handler
+ *
+ * GET /api/enterprise/audit?page=&pageSize=&action=&resourceType=&startDate=&endDate=
+ * Returns: { Records: AuditLogEntry[] } + meta { Total_Records, Page, Page_Size, Request_ID, Timestamp }
+ * Auth: Cognito JWT required, enterprise tier only
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+async function getEnterpriseAudit({ queryStringParameters, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        // Look up client_id and verify enterprise tier
+        const userResult = await executeQuery(
+            `SELECT u.client_id, c.subscription_tier
+             FROM rapport.users u
+             JOIN rapport.clients c ON c.client_id = u.client_id
+             WHERE u.email_address = $1 LIMIT 1`,
+            [email]
+        );
+        if (!userResult.rows.length) {
+            return createErrorResponse(403, 'User not found');
+        }
+        if (userResult.rows[0].subscription_tier !== 'enterprise') {
+            return createErrorResponse(403, 'Enterprise subscription required');
+        }
+        const clientId = userResult.rows[0].client_id;
+
+        const params = queryStringParameters || {};
+        const page = Math.max(1, parseInt(params.page) || 1);
+        const pageSize = Math.min(100, Math.max(1, parseInt(params.pageSize) || 20));
+        const offset = (page - 1) * pageSize;
+
+        // Build WHERE clause
+        const conditions = ['client_id = $1'];
+        const values = [clientId];
+        let paramIndex = 2;
+
+        if (params.action) {
+            conditions.push(`event_type = $${paramIndex}`);
+            values.push(params.action);
+            paramIndex++;
+        }
+
+        if (params.resourceType) {
+            conditions.push(`entity_type = $${paramIndex}`);
+            values.push(params.resourceType);
+            paramIndex++;
+        }
+
+        if (params.startDate) {
+            conditions.push(`created_at >= $${paramIndex}`);
+            values.push(params.startDate);
+            paramIndex++;
+        }
+
+        if (params.endDate) {
+            conditions.push(`created_at <= $${paramIndex}`);
+            values.push(params.endDate);
+            paramIndex++;
+        }
+
+        const whereClause = conditions.join(' AND ');
+
+        // Get total count
+        const countResult = await executeQuery(
+            `SELECT COUNT(*) as total FROM rapport.unified_audit_log WHERE ${whereClause}`,
+            values
+        );
+        const total = parseInt(countResult.rows[0].total);
+
+        // Get paginated records, mapping columns to frontend AuditLogEntry type
+        const dataResult = await executeQuery(
+            `SELECT
+                audit_id,
+                client_id,
+                actor_email,
+                event_type as action,
+                entity_type as resource_type,
+                entity_id as resource_id,
+                before_state as old_value,
+                after_state as new_value,
+                created_at
+            FROM rapport.unified_audit_log
+            WHERE ${whereClause}
+            ORDER BY created_at DESC
+            LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+            [...values, pageSize, offset]
+        );
+
+        return createSuccessResponse(
+            { Records: dataResult.rows },
+            'Audit log retrieved',
+            { Total_Records: total, Page: page, Page_Size: pageSize, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(getEnterpriseAudit);

package/src/handlers/enterprise/enterpriseContributorsGet.js

@@ -0,0 +1,85 @@
+/**
+ * Enterprise Contributors Get Handler
+ *
+ * GET /api/enterprise/contributors?period=
+ * Returns: { Records: [contributor stats] } + meta
+ * Auth: Cognito JWT required, enterprise tier only
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+async function getEnterpriseContributors({ queryStringParameters, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const userResult = await executeQuery(
+            `SELECT u.client_id, c.subscription_tier
+             FROM rapport.users u
+             JOIN rapport.clients c ON c.client_id = u.client_id
+             WHERE u.email_address = $1 LIMIT 1`,
+            [email]
+        );
+        if (!userResult.rows.length) {
+            return createErrorResponse(403, 'User not found');
+        }
+        if (userResult.rows[0].subscription_tier !== 'enterprise') {
+            return createErrorResponse(403, 'Enterprise subscription required');
+        }
+        const clientId = userResult.rows[0].client_id;
+
+        const params = queryStringParameters || {};
+        const period = params.period || '30d';
+
+        // Calculate date filter
+        let intervalDays;
+        switch (period) {
+            case '7d': intervalDays = 7; break;
+            case '90d': intervalDays = 90; break;
+            case '30d':
+            default: intervalDays = 30; break;
+        }
+
+        // Aggregate contributions across audit trail and knowledge curation
+        const result = await executeQuery(
+            `WITH audit_activity AS (
+                SELECT
+                    actor_email as contributor_email,
+                    COUNT(*) FILTER (WHERE event_type = 'DATA_CREATE' AND entity_type = 'STANDARD') as discoveries,
+                    COUNT(*) FILTER (WHERE event_type = 'DATA_UPDATE' AND entity_type = 'STANDARD') as refinements,
+                    COUNT(*) FILTER (WHERE event_type = 'DATA_UPDATE' AND entity_type = 'STANDARD'
+                        AND (after_state->>'status') = 'approved') as verifications,
+                    COUNT(*) FILTER (WHERE event_type = 'DATA_CREATE' AND entity_type = 'KNOWLEDGE') as curations
+                FROM rapport.unified_audit_log
+                WHERE client_id = $1
+                    AND created_at >= NOW() - ($2 || ' days')::interval
+                    AND actor_email IS NOT NULL
+                GROUP BY actor_email
+            )
+            SELECT
+                contributor_email,
+                COALESCE(discoveries, 0) as discoveries,
+                COALESCE(refinements, 0) as refinements,
+                COALESCE(verifications, 0) as verifications,
+                COALESCE(curations, 0) as curations,
+                COALESCE(discoveries * 3 + refinements * 2 + verifications * 2 + curations * 4, 0) as total_weight
+            FROM audit_activity
+            ORDER BY total_weight DESC`,
+            [clientId, String(intervalDays)]
+        );
+
+        return createSuccessResponse(
+            { Records: result.rows },
+            'Contributors retrieved',
+            { Total_Records: result.rowCount, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(getEnterpriseContributors);

package/src/handlers/enterprise/enterpriseKnowledgeCategoriesGet.js

@@ -0,0 +1,53 @@
+/**
+ * Enterprise Knowledge Categories Get Handler
+ *
+ * GET /api/enterprise/knowledge/categories
+ * Returns: { Records: [{ category_id, name, description }] } + meta
+ * Auth: Cognito JWT required, enterprise tier only
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+async function getEnterpriseKnowledgeCategories({ requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const userResult = await executeQuery(
+            `SELECT u.client_id, c.subscription_tier
+             FROM rapport.users u
+             JOIN rapport.clients c ON c.client_id = u.client_id
+             WHERE u.email_address = $1 LIMIT 1`,
+            [email]
+        );
+        if (!userResult.rows.length) {
+            return createErrorResponse(403, 'User not found');
+        }
+        if (userResult.rows[0].subscription_tier !== 'enterprise') {
+            return createErrorResponse(403, 'Enterprise subscription required');
+        }
+        const clientId = userResult.rows[0].client_id;
+
+        const result = await executeQuery(
+            `SELECT category_id, name, description
+            FROM rapport.knowledge_categories
+            WHERE client_id = $1
+            ORDER BY name`,
+            [clientId]
+        );
+
+        return createSuccessResponse(
+            { Records: result.rows },
+            'Categories retrieved',
+            { Total_Records: result.rowCount, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(getEnterpriseKnowledgeCategories);

package/src/handlers/enterprise/enterpriseKnowledgeCreate.js

@@ -0,0 +1,77 @@
+/**
+ * Enterprise Knowledge Create Handler
+ *
+ * POST /api/enterprise/knowledge
+ * Body: { title, content, category?, tags?, invariant_id? }
+ * Returns: { Records: [CuratedKnowledge] } + meta
+ * Auth: Cognito JWT required, enterprise tier only
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, logModificationEvent, AuditEventType, EntityType } = require('./helpers');
+
+async function createEnterpriseKnowledge({ body, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const userResult = await executeQuery(
+            `SELECT u.client_id, c.subscription_tier
+             FROM rapport.users u
+             JOIN rapport.clients c ON c.client_id = u.client_id
+             WHERE u.email_address = $1 LIMIT 1`,
+            [email]
+        );
+        if (!userResult.rows.length) {
+            return createErrorResponse(403, 'User not found');
+        }
+        if (userResult.rows[0].subscription_tier !== 'enterprise') {
+            return createErrorResponse(403, 'Enterprise subscription required');
+        }
+        const clientId = userResult.rows[0].client_id;
+
+        const requestBody = body || {};
+        const { title, content, category, tags, invariant_id } = requestBody;
+
+        if (!title || !content) {
+            return createErrorResponse(400, 'title and content are required');
+        }
+
+        const result = await executeQuery(
+            `INSERT INTO rapport.curated_knowledge
+                (client_id, invariant_id, title, content, category, tags, curator_email, status)
+            VALUES ($1, $2, $3, $4, $5, $6, $7, 'draft')
+            RETURNING *`,
+            [
+                clientId,
+                invariant_id || null,
+                title,
+                content,
+                category || null,
+                tags || [],
+                email,
+            ]
+        );
+
+        const created = result.rows[0];
+
+        await logModificationEvent(AuditEventType.DATA_CREATE, EntityType.KNOWLEDGE, String(created.knowledge_id), {
+            requestContext,
+            client_id: clientId,
+            after_state: { title, category, status: 'draft' },
+        });
+
+        return createSuccessResponse(
+            { Records: [created] },
+            'Knowledge item created',
+            { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(createEnterpriseKnowledge);

package/src/handlers/enterprise/enterpriseKnowledgeDelete.js

@@ -0,0 +1,71 @@
+/**
+ * Enterprise Knowledge Delete Handler
+ *
+ * DELETE /api/enterprise/knowledge?knowledge_id=xxx
+ * Returns: { Records: [] } + meta
+ * Auth: Cognito JWT required, enterprise tier only
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, logModificationEvent, AuditEventType, EntityType } = require('./helpers');
+
+async function deleteEnterpriseKnowledge({ queryStringParameters, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const userResult = await executeQuery(
+            `SELECT u.client_id, c.subscription_tier
+             FROM rapport.users u
+             JOIN rapport.clients c ON c.client_id = u.client_id
+             WHERE u.email_address = $1 LIMIT 1`,
+            [email]
+        );
+        if (!userResult.rows.length) {
+            return createErrorResponse(403, 'User not found');
+        }
+        if (userResult.rows[0].subscription_tier !== 'enterprise') {
+            return createErrorResponse(403, 'Enterprise subscription required');
+        }
+        const clientId = userResult.rows[0].client_id;
+
+        const knowledgeId = (queryStringParameters || {}).knowledge_id;
+        if (!knowledgeId) {
+            return createErrorResponse(400, 'knowledge_id is required');
+        }
+
+        // Fetch current state for audit trail
+        const current = await executeQuery(
+            'SELECT * FROM rapport.curated_knowledge WHERE knowledge_id = $1 AND client_id = $2',
+            [knowledgeId, clientId]
+        );
+        if (!current.rows.length) {
+            return createErrorResponse(404, 'Knowledge item not found');
+        }
+        const beforeState = current.rows[0];
+
+        await executeQuery(
+            'DELETE FROM rapport.curated_knowledge WHERE knowledge_id = $1 AND client_id = $2',
+            [knowledgeId, clientId]
+        );
+
+        await logModificationEvent(AuditEventType.DATA_DELETE, EntityType.KNOWLEDGE, String(knowledgeId), {
+            requestContext,
+            client_id: clientId,
+            before_state: { title: beforeState.title, status: beforeState.status },
+        });
+
+        return createSuccessResponse(
+            { Records: [] },
+            'Knowledge item deleted',
+            { Total_Records: 0, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(deleteEnterpriseKnowledge);

package/src/handlers/enterprise/enterpriseKnowledgeGet.js

@@ -0,0 +1,87 @@
+/**
+ * Enterprise Knowledge Get Handler
+ *
+ * GET /api/enterprise/knowledge?page=&pageSize=&status=&category=
+ * Returns: { Records: CuratedKnowledge[] } + meta { Total_Records, Page, Page_Size, Request_ID, Timestamp }
+ * Auth: Cognito JWT required, enterprise tier only
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+async function getEnterpriseKnowledge({ queryStringParameters, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const userResult = await executeQuery(
+            `SELECT u.client_id, c.subscription_tier
+             FROM rapport.users u
+             JOIN rapport.clients c ON c.client_id = u.client_id
+             WHERE u.email_address = $1 LIMIT 1`,
+            [email]
+        );
+        if (!userResult.rows.length) {
+            return createErrorResponse(403, 'User not found');
+        }
+        if (userResult.rows[0].subscription_tier !== 'enterprise') {
+            return createErrorResponse(403, 'Enterprise subscription required');
+        }
+        const clientId = userResult.rows[0].client_id;
+
+        const params = queryStringParameters || {};
+        const page = Math.max(1, parseInt(params.page) || 1);
+        const pageSize = Math.min(100, Math.max(1, parseInt(params.pageSize) || 20));
+        const offset = (page - 1) * pageSize;
+
+        const conditions = ['client_id = $1'];
+        const values = [clientId];
+        let paramIndex = 2;
+
+        if (params.status) {
+            conditions.push(`status = $${paramIndex}`);
+            values.push(params.status);
+            paramIndex++;
+        }
+
+        if (params.category) {
+            conditions.push(`category = $${paramIndex}`);
+            values.push(params.category);
+            paramIndex++;
+        }
+
+        const whereClause = conditions.join(' AND ');
+
+        const countResult = await executeQuery(
+            `SELECT COUNT(*) as total FROM rapport.curated_knowledge WHERE ${whereClause}`,
+            values
+        );
+        const total = parseInt(countResult.rows[0].total);
+
+        const dataResult = await executeQuery(
+            `SELECT
+                knowledge_id, client_id, invariant_id,
+                title, content, category, tags,
+                curator_email, status,
+                created_at, published_at
+            FROM rapport.curated_knowledge
+            WHERE ${whereClause}
+            ORDER BY created_at DESC
+            LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+            [...values, pageSize, offset]
+        );
+
+        return createSuccessResponse(
+            { Records: dataResult.rows },
+            'Knowledge items retrieved',
+            { Total_Records: total, Page: page, Page_Size: pageSize, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(getEnterpriseKnowledge);