@equilateral_ai/mindmeld 3.0.0

package/src/handlers/patterns/patternUsagePost.js

@@ -0,0 +1,182 @@
+/**
+ * Pattern Usage Handler
+ * Records pattern usage (success/failure) from Claude Code sessions
+ *
+ * POST /api/patterns/usage
+ * Body: { pattern, session_id, user_id, project_id, success, context, timestamp }
+ *
+ * Called by: pre-compact.js hook (reinforcePattern method)
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Record pattern usage
+ * Updates usage count and maturity level based on success
+ */
+async function recordPatternUsage({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext?.requestId || 'unknown';
+
+        const {
+            pattern,
+            session_id,
+            user_id,
+            project_id,
+            success = true,
+            context = {},
+            timestamp
+        } = requestBody;
+
+        // Validate required fields
+        if (!pattern || !pattern.element) {
+            return createErrorResponse(400, 'pattern.element is required');
+        }
+
+        if (!session_id) {
+            return createErrorResponse(400, 'session_id is required');
+        }
+
+        // Generate pattern_id from element if not provided
+        const patternId = pattern.pattern_id || `pat_${pattern.element.toLowerCase().replace(/\s+/g, '_').substring(0, 50)}`;
+
+        // If no project_id, we can't create a pattern record (FK constraint)
+        // Return success anyway - hooks should not fail
+        if (!project_id) {
+            console.log('[patternUsagePost] No project_id provided, skipping pattern record');
+            return createSuccessResponse(
+                {
+                    Records: [{
+                        pattern_id: patternId,
+                        recorded: false,
+                        reason: 'no_project_id',
+                        message: 'Pattern usage logged but not recorded (no project context)'
+                    }]
+                },
+                'Pattern usage acknowledged (no project context)',
+                {
+                    Total_Records: 0,
+                    Request_ID,
+                    Timestamp: new Date().toISOString()
+                }
+            );
+        }
+
+        // First, ensure the pattern exists in rapport.patterns (upsert)
+        const upsertPatternQuery = `
+            INSERT INTO rapport.patterns (
+                pattern_id,
+                project_id,
+                intent,
+                constraints,
+                outcome_criteria,
+                maturity,
+                handoff_count,
+                successful_handoffs,
+                failed_handoffs,
+                discovered_by,
+                discovered_at,
+                last_used,
+                pattern_data
+            ) VALUES (
+                $1, $2, $3, $4, $5, 'provisional', 1,
+                CASE WHEN $6 THEN 1 ELSE 0 END,
+                CASE WHEN $6 THEN 0 ELSE 1 END,
+                $7, NOW(), NOW(), $8
+            )
+            ON CONFLICT (pattern_id) DO UPDATE SET
+                handoff_count = rapport.patterns.handoff_count + 1,
+                successful_handoffs = rapport.patterns.successful_handoffs + CASE WHEN $6 THEN 1 ELSE 0 END,
+                failed_handoffs = rapport.patterns.failed_handoffs + CASE WHEN $6 THEN 0 ELSE 1 END,
+                last_used = NOW(),
+                maturity = CASE
+                    WHEN rapport.patterns.handoff_count >= 9 AND
+                         (rapport.patterns.successful_handoffs + CASE WHEN $6 THEN 1 ELSE 0 END)::float /
+                         (rapport.patterns.handoff_count + 1) >= 0.7
+                    THEN 'reinforced'
+                    WHEN rapport.patterns.handoff_count >= 4 AND
+                         (rapport.patterns.successful_handoffs + CASE WHEN $6 THEN 1 ELSE 0 END)::float /
+                         (rapport.patterns.handoff_count + 1) >= 0.6
+                    THEN 'validated'
+                    ELSE rapport.patterns.maturity
+                END
+            RETURNING pattern_id, maturity, handoff_count, successful_handoffs, failed_handoffs
+        `;
+
+        const patternResult = await executeQuery(upsertPatternQuery, [
+            patternId,
+            project_id || null,
+            pattern.intent || pattern.element,
+            JSON.stringify(pattern.constraints || []),
+            JSON.stringify(pattern.outcome_criteria || []),
+            success,
+            user_id || 'anonymous',
+            JSON.stringify({
+                type: pattern.type,
+                category: pattern.category,
+                file: pattern.file,
+                confidence: pattern.confidence,
+                evidence: pattern.evidence
+            })
+        ]);
+
+        const updatedPattern = patternResult.rows[0];
+
+        // Record the individual usage in pattern_usage table
+        const usageQuery = `
+            INSERT INTO rapport.pattern_usage (
+                pattern_id,
+                email_address,
+                session_id,
+                success,
+                context,
+                used_at
+            ) VALUES (
+                $1, $2, $3, $4, $5, $6
+            )
+            RETURNING usage_id
+        `;
+
+        const usageResult = await executeQuery(usageQuery, [
+            patternId,
+            user_id || 'anonymous',
+            session_id,
+            success,
+            JSON.stringify({
+                working_directory: context.working_directory,
+                source: context.source,
+                file: pattern.file,
+                category: pattern.category
+            }),
+            timestamp ? new Date(timestamp) : new Date()
+        ]);
+
+        // Calculate success rate
+        const successRate = updatedPattern.successful_handoffs / updatedPattern.handoff_count;
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    usage_id: usageResult.rows[0]?.usage_id,
+                    pattern_id: updatedPattern.pattern_id,
+                    maturity: updatedPattern.maturity,
+                    usage_count: updatedPattern.handoff_count,
+                    success_rate: successRate.toFixed(2),
+                    recorded: true
+                }]
+            },
+            success ? 'Pattern usage recorded (success)' : 'Pattern usage recorded (failure)',
+            {
+                Total_Records: 1,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(recordPatternUsage);

package/src/handlers/patterns/patternViolationPost.js

@@ -0,0 +1,185 @@
+/**
+ * Pattern Violation Handler
+ * Records standards violations detected during Claude Code sessions
+ *
+ * POST /api/patterns/violations
+ * Body: { pattern, violations[], session_id, user_id, project_id, timestamp }
+ *
+ * Called by: pre-compact.js hook (recordViolation method)
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Record pattern violation
+ * Stores violation for compliance tracking and team learning
+ */
+async function recordPatternViolation({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext?.requestId || 'unknown';
+
+        const {
+            pattern,
+            violations = [],
+            session_id,
+            user_id,
+            project_id,
+            timestamp
+        } = requestBody;
+
+        // Validate required fields
+        if (!pattern || !pattern.element) {
+            return createErrorResponse(400, 'pattern.element is required');
+        }
+
+        if (!violations || violations.length === 0) {
+            return createErrorResponse(400, 'violations array is required');
+        }
+
+        if (!session_id) {
+            return createErrorResponse(400, 'session_id is required');
+        }
+
+        // Generate pattern_id from element if not provided
+        const patternId = pattern.pattern_id || `pat_${pattern.element.toLowerCase().replace(/\s+/g, '_').substring(0, 50)}`;
+
+        // If no project_id, we can't create a pattern record (FK constraint)
+        // Return success anyway - hooks should not fail
+        if (!project_id) {
+            console.log('[patternViolationPost] No project_id provided, skipping violation record');
+            return createSuccessResponse(
+                {
+                    Records: [{
+                        pattern_id: patternId,
+                        violation_count: violations.length,
+                        recorded: false,
+                        reason: 'no_project_id',
+                        message: 'Violation logged but not recorded (no project context)'
+                    }]
+                },
+                'Violation acknowledged (no project context)',
+                {
+                    Total_Records: 0,
+                    Request_ID,
+                    Timestamp: new Date().toISOString()
+                }
+            );
+        }
+
+        // Ensure the pattern exists (upsert with violation count)
+        const upsertPatternQuery = `
+            INSERT INTO rapport.patterns (
+                pattern_id,
+                project_id,
+                intent,
+                constraints,
+                outcome_criteria,
+                maturity,
+                handoff_count,
+                successful_handoffs,
+                failed_handoffs,
+                discovered_by,
+                discovered_at,
+                last_used,
+                pattern_data
+            ) VALUES (
+                $1, $2, $3, $4, $5, 'provisional', 1, 0, 1, $6, NOW(), NOW(), $7
+            )
+            ON CONFLICT (pattern_id) DO UPDATE SET
+                handoff_count = rapport.patterns.handoff_count + 1,
+                failed_handoffs = rapport.patterns.failed_handoffs + 1,
+                last_used = NOW()
+            RETURNING pattern_id
+        `;
+
+        await executeQuery(upsertPatternQuery, [
+            patternId,
+            project_id || null,
+            pattern.intent || pattern.element,
+            JSON.stringify(pattern.constraints || []),
+            JSON.stringify(pattern.outcome_criteria || []),
+            user_id || 'anonymous',
+            JSON.stringify({
+                type: pattern.type,
+                category: pattern.category,
+                file: pattern.file
+            })
+        ]);
+
+        // Record each violation
+        const violationRecords = [];
+        for (const violation of violations) {
+            const violationQuery = `
+                INSERT INTO rapport.pattern_usage (
+                    pattern_id,
+                    email_address,
+                    session_id,
+                    success,
+                    context,
+                    used_at
+                ) VALUES (
+                    $1, $2, $3, false, $4, $5
+                )
+                RETURNING usage_id
+            `;
+
+            const result = await executeQuery(violationQuery, [
+                patternId,
+                user_id || 'anonymous',
+                session_id,
+                JSON.stringify({
+                    violation: true,
+                    standard_id: violation.standard_id,
+                    rule: violation.rule,
+                    description: violation.description,
+                    file: pattern.file,
+                    category: pattern.category
+                }),
+                timestamp ? new Date(timestamp) : new Date()
+            ]);
+
+            violationRecords.push({
+                usage_id: result.rows[0]?.usage_id,
+                standard_id: violation.standard_id,
+                rule: violation.rule
+            });
+        }
+
+        // Also record in session_standards if tracking standards shown
+        // Update to mark standard as violated
+        const updateStandardsQuery = `
+            UPDATE rapport.session_standards
+            SET violated = true
+            WHERE session_id = $1
+                AND pattern_id = ANY($2::varchar[])
+        `;
+
+        const standardIds = violations.map(v => v.standard_id).filter(Boolean);
+        if (standardIds.length > 0) {
+            await executeQuery(updateStandardsQuery, [session_id, standardIds]);
+        }
+
+        return createSuccessResponse(
+            {
+                Records: [{
+                    pattern_id: patternId,
+                    violation_count: violationRecords.length,
+                    violations: violationRecords,
+                    recorded: true
+                }]
+            },
+            `Recorded ${violationRecords.length} violation(s)`,
+            {
+                Total_Records: violationRecords.length,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(recordPatternViolation);

package/src/handlers/projects/projectCreate.js

@@ -0,0 +1,107 @@
+/**
+ * Project Create Handler
+ * Creates new project for a company
+ *
+ * POST /api/projects
+ * Body: { Company_ID, project_name, description, private }
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Create project
+ * Requires Admin access to company
+ */
+async function createProject({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        // REST API: requestContext.authorizer.claims.email
+        // HTTP API: requestContext.authorizer.jwt.claims.email
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        const { Company_ID, project_name, description, private: isPrivate, repo_url } = requestBody;
+
+        // Validate required fields
+        if (!Company_ID || !project_name) {
+            return createErrorResponse(400, 'Company_ID and project_name are required');
+        }
+
+        // Check user has admin access to company
+        const adminQuery = `
+            SELECT ue."Admin", c."Company_Name"
+            FROM "UserEntitlements" ue
+            JOIN "Company" c ON ue."Company_ID" = c."Company_ID"
+            WHERE ue."Email_Address" = $1
+            AND ue."Company_ID" = $2
+        `;
+        const adminCheck = await executeQuery(adminQuery, [email, Company_ID]);
+
+        if (adminCheck.rowCount === 0 || !adminCheck.rows[0].Admin) {
+            return createErrorResponse(403, 'Admin access required to create projects');
+        }
+
+        // Generate business-scoped project ID
+        // Format: prj_COMPANYID_timestamp
+        const timestamp = Date.now();
+        const project_id = `prj_${Company_ID}_${timestamp}`.toLowerCase().replace(/\s/g, '_');
+
+        // Create project
+        const query = `
+            INSERT INTO rapport.projects (
+                project_id,
+                company_id,
+                project_name,
+                description,
+                private,
+                repo_url
+            )
+            VALUES ($1, $2, $3, $4, $5, $6)
+            RETURNING
+                project_id,
+                company_id,
+                project_name,
+                description,
+                private,
+                repo_url,
+                created_at
+        `;
+
+        const result = await executeQuery(query, [
+            project_id,
+            Company_ID,
+            project_name,
+            description || null,
+            isPrivate || false,
+            repo_url || null
+        ]);
+
+        // Add creator as owner
+        const collabQuery = `
+            INSERT INTO rapport.project_collaborators (
+                project_id,
+                email_address,
+                role
+            )
+            VALUES ($1, $2, 'owner')
+        `;
+        await executeQuery(collabQuery, [project_id, email]);
+
+        return createSuccessResponse(
+            { Records: result.rows },
+            'Project created successfully',
+            {
+                Total_Records: result.rowCount,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        if (error.code === '23505') {
+            return createErrorResponse(409, 'Project already exists');
+        }
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(createProject);

package/src/handlers/projects/projectDelete.js

@@ -0,0 +1,82 @@
+/**
+ * Project Delete Handler
+ * Archives (soft deletes) a project
+ *
+ * DELETE /api/projects/{projectId}
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Archive project (soft delete)
+ * Requires owner role or company admin
+ */
+async function deleteProject({ pathParameters = {}, queryStringParameters: queryParams = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        // REST API: requestContext.authorizer.claims.email
+        // HTTP API: requestContext.authorizer.jwt.claims.email
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+        const { projectId } = pathParameters;
+
+        if (!projectId) {
+            return createErrorResponse(400, 'projectId is required');
+        }
+
+        // Check user has access to project
+        const accessQuery = `
+            SELECT
+                p.project_id,
+                p.company_id,
+                pc.role,
+                ue."Admin" as company_admin
+            FROM rapport.projects p
+            LEFT JOIN rapport.project_collaborators pc
+                ON p.project_id = pc.project_id
+                AND pc.email_address = $1
+            LEFT JOIN "UserEntitlements" ue
+                ON ue."Email_Address" = $1
+                AND ue."Company_ID" = p.company_id
+            WHERE p.project_id = $2
+        `;
+        const accessCheck = await executeQuery(accessQuery, [email, projectId]);
+
+        if (accessCheck.rowCount === 0) {
+            return createErrorResponse(404, 'Project not found');
+        }
+
+        const access = accessCheck.rows[0];
+
+        // Check permissions (only owner or company admin can delete)
+        const canDelete = access.role === 'owner' || access.company_admin === true;
+        if (!canDelete) {
+            return createErrorResponse(403, 'Only project owner or company admin can delete project');
+        }
+
+        // Archive project (soft delete)
+        const query = `
+            UPDATE rapport.projects
+            SET archived = true, updated_at = NOW()
+            WHERE project_id = $1
+            RETURNING project_id, project_name, archived
+        `;
+
+        const result = await executeQuery(query, [projectId]);
+
+        return createSuccessResponse(
+            { Records: result.rows },
+            'Project archived successfully',
+            {
+                Total_Records: result.rowCount,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(deleteProject);

package/src/handlers/projects/projectGet.js

@@ -0,0 +1,95 @@
+/**
+ * Project Get Handler
+ * Retrieves projects for a company with collaborator access check
+ *
+ * GET /api/projects?Company_ID=xxx
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Get projects
+ * Returns all projects user has access to (via company entitlements or direct collaboration)
+ */
+async function getProjects({ queryStringParameters: queryParams = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext.requestId;
+        // REST API: requestContext.authorizer.claims.email
+        // HTTP API: requestContext.authorizer.jwt.claims.email
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        // Get user's company access
+        const entitlementQuery = `
+            SELECT ue."Company_ID", ue."Admin", c."Company_Name"
+            FROM "UserEntitlements" ue
+            JOIN "Company" c ON ue."Company_ID" = c."Company_ID"
+            WHERE ue."Email_Address" = $1
+        `;
+        const entitlements = await executeQuery(entitlementQuery, [email]);
+
+        if (entitlements.rowCount === 0) {
+            return createErrorResponse(403, 'No company access');
+        }
+
+        const companyIds = entitlements.rows.map(e => e.Company_ID);
+
+        // Optional filter by specific company
+        let targetCompanyIds = companyIds;
+        if (queryParams.Company_ID) {
+            if (!companyIds.includes(queryParams.Company_ID)) {
+                return createErrorResponse(403, 'No access to specified company');
+            }
+            targetCompanyIds = [queryParams.Company_ID];
+        }
+
+        // Get projects for user's companies
+        const query = `
+            SELECT
+                p.project_id,
+                p.company_id,
+                p.project_name,
+                p.description,
+                p.private,
+                p.created_at,
+                p.last_active,
+                p.archived,
+                c."Company_Name",
+                COUNT(DISTINCT pc.email_address) as collaborator_count,
+                COALESCE(
+                    json_agg(
+                        json_build_object(
+                            'email', pc.email_address,
+                            'role', pc.role,
+                            'is_external', pc.is_external
+                        )
+                    ) FILTER (WHERE pc.email_address IS NOT NULL),
+                    '[]'
+                ) as collaborators
+            FROM rapport.projects p
+            JOIN "Company" c ON p.company_id = c."Company_ID"
+            LEFT JOIN rapport.project_collaborators pc ON p.project_id = pc.project_id
+            WHERE p.company_id = ANY($1::varchar[])
+            AND p.archived = false
+            GROUP BY p.project_id, c."Company_Name"
+            ORDER BY p.last_active DESC NULLS LAST, p.created_at DESC
+        `;
+
+        const result = await executeQuery(query, [targetCompanyIds]);
+
+        return createSuccessResponse(
+            { Records: result.rows },
+            'Projects retrieved successfully',
+            {
+                Total_Records: result.rowCount,
+                Request_ID,
+                Timestamp: new Date().toISOString()
+            }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(getProjects);