@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/handlers/sessions/sessionStandardsPost.js

@@ -1,171 +0,0 @@
-/**
- * Session Standards Handler
- * Records which standards were shown during a Claude Code session
- *
- * POST /api/sessions/standards
- * Body: { session_id, standards[], project_id?, user_id? }
- *
- * Called by: session-start.js hook (recordStandardsShown method)
- * Fire-and-forget - should not block session start
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
-
-/**
- * Record standards shown during session
- * Creates session record if needed, then records standards
- */
-async function recordSessionStandards({ body: requestBody = {}, requestContext }) {
-    try {
-        const Request_ID = requestContext?.requestId || 'unknown';
-
-        const {
-            session_id,
-            standards = [],
-            project_id,
-            user_id
-        } = requestBody;
-
-        // Validate required fields
-        if (!session_id) {
-            return createErrorResponse(400, 'session_id is required');
-        }
-
-        if (!standards || standards.length === 0) {
-            // Not an error - just nothing to record
-            return createSuccessResponse(
-                { Records: [], recorded: 0 },
-                'No standards to record',
-                { Request_ID, Timestamp: new Date().toISOString() }
-            );
-        }
-
-        // Try to ensure session exists (upsert with minimal data)
-        // If project doesn't exist, auto-create it to prevent silent session loss
-        if (project_id && user_id) {
-            const sessionUpsertQuery = `
-                INSERT INTO rapport.sessions (
-                    session_id,
-                    project_id,
-                    email_address,
-                    started_at,
-                    session_data
-                ) VALUES (
-                    $1, $2, $3, NOW(), '{}'::jsonb
-                )
-                ON CONFLICT (session_id) DO NOTHING
-            `;
-
-            try {
-                await executeQuery(sessionUpsertQuery, [session_id, project_id, user_id]);
-            } catch (sessionError) {
-                // FK constraint on project_id — auto-create the project and retry
-                if (sessionError.code === '23503' && sessionError.constraint && sessionError.constraint.includes('project_id')) {
-                    console.log(`[sessionStandardsPost] Project ${project_id} not found, auto-creating`);
-                    try {
-                        // Look up user's company_id
-                        const entResult = await executeQuery(
-                            `SELECT company_id FROM rapport.user_entitlements WHERE email_address = $1 LIMIT 1`,
-                            [user_id]
-                        );
-                        if (entResult.rowCount > 0) {
-                            const company_id = entResult.rows[0].company_id;
-                            // Derive a readable project name from the project_id
-                            // e.g. prj_pareidolia_main_1770727596802 → pareidolia main
-                            const projectName = project_id
-                                .replace(/^prj_/, '')
-                                .replace(/_\d+$/, '')
-                                .replace(/_/g, ' ');
-
-                            await executeQuery(`
-                                INSERT INTO rapport.projects (project_id, company_id, project_name, private)
-                                VALUES ($1, $2, $3, false)
-                                ON CONFLICT (project_id) DO NOTHING
-                            `, [project_id, company_id, projectName]);
-
-                            // Retry session upsert
-                            await executeQuery(sessionUpsertQuery, [session_id, project_id, user_id]);
-                            console.log(`[sessionStandardsPost] Auto-created project ${project_id} under ${company_id}`);
-                        } else {
-                            console.error(`[sessionStandardsPost] No entitlement found for ${user_id}, cannot auto-create project`);
-                        }
-                    } catch (autoCreateError) {
-                        console.error('[sessionStandardsPost] Auto-create project failed:', autoCreateError.message);
-                    }
-                } else {
-                    console.error('[sessionStandardsPost] Session upsert failed:', sessionError.message);
-                }
-            }
-        }
-
-        // Record each standard shown
-        const recordedStandards = [];
-        let errors = 0;
-
-        for (const standard of standards) {
-            const standardId = standard.pattern_id || standard.element;
-            const standardName = standard.title || standard.element || standardId;
-            const relevanceScore = standard.relevance_score || standard.score || 0;
-
-            if (!standardId) {
-                errors++;
-                continue;
-            }
-
-            const insertQuery = `
-                INSERT INTO rapport.session_standards (
-                    session_id,
-                    standard_id,
-                    standard_name,
-                    relevance_score,
-                    created_at
-                ) VALUES (
-                    $1, $2, $3, $4, NOW()
-                )
-                ON CONFLICT (session_id, standard_id) DO UPDATE SET
-                    relevance_score = EXCLUDED.relevance_score,
-                    created_at = NOW()
-                RETURNING id
-            `;
-
-            try {
-                const result = await executeQuery(insertQuery, [
-                    session_id,
-                    standardId,
-                    standardName,
-                    relevanceScore
-                ]);
-
-                recordedStandards.push({
-                    id: result.rows[0]?.id,
-                    standard_id: standardId,
-                    relevance_score: relevanceScore
-                });
-            } catch (insertError) {
-                // Standard might not exist or FK constraint failed
-                console.error(`[sessionStandardsPost] Failed to record standard ${standardId}:`, insertError.message);
-                errors++;
-            }
-        }
-
-        return createSuccessResponse(
-            {
-                Records: recordedStandards,
-                recorded: recordedStandards.length,
-                errors: errors
-            },
-            `Recorded ${recordedStandards.length} standard(s)`,
-            {
-                Total_Records: recordedStandards.length,
-                Request_ID,
-                Timestamp: new Date().toISOString()
-            }
-        );
-
-    } catch (error) {
-        console.error('Handler Error:', error);
-        return handleError(error);
-    }
-}
-
-exports.handler = wrapHandler(recordSessionStandards);

package/src/handlers/standards/catalogGet.js

@@ -1,185 +0,0 @@
-/**
- * Standards Catalog Get Handler
- * Returns the standards catalog manifest based on subscription tier
- *
- * GET /api/standards/catalog
- * Auth: Cognito JWT required
- * Query params:
- *   - catalog_id: Override catalog selection
- *   - tech_stack: Comma-separated list of detected technologies for recommendations
- *
- * Enterprise tier: Full proprietary standards (equilateral-v1)
- * Other tiers: Open standards only (equilateral-open-v1)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-// Enterprise tiers that get full proprietary standards
-const ENTERPRISE_TIERS = ['enterprise', 'enterprise_private', 'enterprise_team'];
-
-// Tech stack to category recommendations mapping
-const TECH_TO_CATEGORIES = {
-    // Languages/Frameworks
-    'react': ['frontend-development'],
-    'vue': ['frontend-development'],
-    'angular': ['frontend-development'],
-    'typescript': ['frontend-development'],
-    'node.js': ['serverless-saas-aws'],
-    'nodejs': ['serverless-saas-aws'],
-    'express': ['serverless-saas-aws'],
-
-    // Infrastructure
-    'aws sam': ['serverless-saas-aws'],
-    'aws lambda': ['serverless-saas-aws'],
-    'lambda': ['serverless-saas-aws'],
-    'serverless': ['serverless-saas-aws'],
-    'cloudformation': ['serverless-saas-aws'],
-    'api gateway': ['serverless-saas-aws'],
-
-    // Databases
-    'postgresql': ['database-patterns', 'memory-systems'],
-    'postgres': ['database-patterns', 'memory-systems'],
-    'dynamodb': ['serverless-saas-aws'],
-
-    // Testing
-    'jest': ['frontend-development'],
-
-    // Multi-agent
-    'claude': ['multi-agent-orchestration'],
-    'openai': ['multi-agent-orchestration'],
-    'langchain': ['multi-agent-orchestration'],
-};
-
-/**
- * Get recommended categories based on detected tech stack
- * @param {string} techStackParam - Comma-separated tech stack string
- * @returns {string[]} - Unique list of recommended category keys
- */
-function getRecommendations(techStackParam) {
-    if (!techStackParam) return [];
-
-    const technologies = techStackParam.split(',').map(t => t.trim().toLowerCase());
-    const recommendations = new Set();
-
-    for (const tech of technologies) {
-        const categories = TECH_TO_CATEGORIES[tech];
-        if (categories) {
-            categories.forEach(cat => recommendations.add(cat));
-        }
-    }
-
-    return Array.from(recommendations);
-}
-
-async function getCatalog({ requestContext, queryStringParameters }) {
-    try {
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        // Get user's subscription tier
-        const userResult = await executeQuery(`
-            SELECT c.subscription_tier
-            FROM rapport.users u
-            LEFT JOIN rapport.clients c ON u.client_id = c.client_id
-            WHERE u.email_address = $1 AND u.active = true
-        `, [email]);
-
-        const subscriptionTier = userResult.rows[0]?.subscription_tier || 'free';
-        const isEnterprise = ENTERPRISE_TIERS.includes(subscriptionTier);
-
-        // Get tech stack recommendations if provided
-        const techStack = queryStringParameters?.tech_stack;
-        const recommendations = getRecommendations(techStack);
-
-        // Determine which catalog to return based on tier
-        // Enterprise gets full catalog, others get open standards
-        const catalogId = queryStringParameters?.catalog_id ||
-            (isEnterprise ? 'equilateral-v1' : 'equilateral-open-v1');
-
-        const result = await executeQuery(`
-            SELECT
-                catalog_id,
-                version,
-                source_url,
-                updated_at,
-                total_standards,
-                total_layers,
-                categories,
-                layers,
-                critical_alerts
-            FROM rapport.standards_catalog
-            WHERE catalog_id = $1
-        `, [catalogId]);
-
-        if (result.rowCount === 0) {
-            // Fall back to open standards if requested catalog not found
-            const fallbackResult = await executeQuery(`
-                SELECT
-                    catalog_id,
-                    version,
-                    source_url,
-                    updated_at,
-                    total_standards,
-                    total_layers,
-                    categories,
-                    layers,
-                    critical_alerts
-                FROM rapport.standards_catalog
-                WHERE catalog_id = 'equilateral-open-v1'
-            `);
-
-            if (fallbackResult.rowCount === 0) {
-                return createErrorResponse(404, 'Standards catalog not found', {
-                    catalog_id: catalogId,
-                    hint: 'Run migration or sync catalog first'
-                });
-            }
-
-            const catalog = fallbackResult.rows[0];
-            return createSuccessResponse({
-                catalog_id: catalog.catalog_id,
-                version: catalog.version,
-                source_url: catalog.source_url,
-                updated_at: catalog.updated_at,
-                subscription_tier: subscriptionTier,
-                is_enterprise: false,
-                recommendations,
-                summary: {
-                    total_standards: catalog.total_standards,
-                    total_layers: catalog.total_layers
-                },
-                categories: catalog.categories,
-                layers: catalog.layers,
-                critical_alerts: catalog.critical_alerts
-            }, 'Open standards catalog retrieved');
-        }
-
-        const catalog = result.rows[0];
-
-        return createSuccessResponse({
-            catalog_id: catalog.catalog_id,
-            version: catalog.version,
-            source_url: catalog.source_url,
-            updated_at: catalog.updated_at,
-            subscription_tier: subscriptionTier,
-            is_enterprise: isEnterprise,
-            recommendations,
-            summary: {
-                total_standards: catalog.total_standards,
-                total_layers: catalog.total_layers
-            },
-            categories: catalog.categories,
-            layers: catalog.layers,
-            critical_alerts: catalog.critical_alerts
-        }, isEnterprise ? 'Full standards catalog retrieved' : 'Open standards catalog retrieved');
-
-    } catch (error) {
-        console.error('Catalog Get Error:', error);
-        return createErrorResponse(500, 'Failed to retrieve standards catalog');
-    }
-}
-
-exports.handler = wrapHandler(getCatalog);

package/src/handlers/standards/catalogSync.js

@@ -1,120 +0,0 @@
-/**
- * Standards Catalog Sync Handler
- * Imports/updates the standards catalog from manifest.json
- *
- * POST /api/standards/catalog/sync
- * Body: { manifest } - The manifest.json content
- * Auth: Cognito JWT required (admin only)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-
-async function syncCatalog({ body, requestContext }) {
-    try {
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        const { manifest, catalog_id = 'equilateral-v1', source_url } = body || {};
-
-        if (!manifest) {
-            return createErrorResponse(400, 'manifest is required');
-        }
-
-        // Validate manifest structure
-        if (!manifest.version || !manifest.categories || !manifest.layers) {
-            return createErrorResponse(400, 'Invalid manifest: missing version, categories, or layers');
-        }
-
-        // Extract metadata
-        const totalStandards = manifest.metadata?.totalStandards || 0;
-        const totalLayers = manifest.layers?.length || 0;
-
-        // Build categories object with descriptions
-        const categories = {};
-        if (manifest.categories) {
-            for (const [key, description] of Object.entries(manifest.categories)) {
-                categories[key] = {
-                    name: key.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
-                    description: description,
-                    // Count files in this category from layers
-                    standards_count: 0
-                };
-            }
-        }
-
-        // Count standards per category from layers
-        if (manifest.layers) {
-            for (const layer of manifest.layers) {
-                if (layer.files) {
-                    for (const file of layer.files) {
-                        const category = file.split('/')[0];
-                        if (categories[category]) {
-                            categories[category].standards_count++;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Upsert catalog
-        const result = await executeQuery(`
-            INSERT INTO rapport.standards_catalog (
-                catalog_id,
-                version,
-                source_url,
-                manifest,
-                total_standards,
-                total_layers,
-                categories,
-                layers,
-                critical_alerts,
-                updated_at
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW())
-            ON CONFLICT (catalog_id) DO UPDATE SET
-                version = EXCLUDED.version,
-                source_url = EXCLUDED.source_url,
-                manifest = EXCLUDED.manifest,
-                total_standards = EXCLUDED.total_standards,
-                total_layers = EXCLUDED.total_layers,
-                categories = EXCLUDED.categories,
-                layers = EXCLUDED.layers,
-                critical_alerts = EXCLUDED.critical_alerts,
-                updated_at = NOW()
-            RETURNING catalog_id, version, updated_at
-        `, [
-            catalog_id,
-            manifest.version,
-            source_url || manifest.metadata?.repository || null,
-            JSON.stringify(manifest),
-            totalStandards,
-            totalLayers,
-            JSON.stringify(categories),
-            JSON.stringify(manifest.layers),
-            JSON.stringify(manifest.criticalAlerts || [])
-        ]);
-
-        const synced = result.rows[0];
-
-        return createSuccessResponse({
-            catalog_id: synced.catalog_id,
-            version: synced.version,
-            updated_at: synced.updated_at,
-            summary: {
-                total_standards: totalStandards,
-                total_layers: totalLayers,
-                total_categories: Object.keys(categories).length,
-                critical_alerts: (manifest.criticalAlerts || []).length
-            },
-            categories: Object.keys(categories)
-        }, 'Standards catalog synced successfully');
-
-    } catch (error) {
-        console.error('Catalog Sync Error:', error);
-        return createErrorResponse(500, 'Failed to sync standards catalog');
-    }
-}
-
-exports.handler = wrapHandler(syncCatalog);

package/src/handlers/standards/discoveriesGet.js

@@ -1,89 +0,0 @@
-/**
- * Discoveries Get Handler
- * Returns discovery review queue for a project
- *
- * GET /api/standards/discoveries?project_id=xxx&status=proposed
- * Auth: Cognito JWT required
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, verifyProjectAccess } = require('./helpers');
-
-async function getDiscoveries({ queryStringParameters, requestContext }) {
-    try {
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        const projectId = (queryStringParameters || {}).project_id;
-        const status = (queryStringParameters || {}).status;
-
-        if (!projectId) {
-            return createErrorResponse(400, 'project_id is required');
-        }
-
-        // Verify user has access to project (collaborator or company member)
-        const projectAccess = await verifyProjectAccess(projectId, email);
-        if (!projectAccess) {
-            return createErrorResponse(403, 'Access denied to project');
-        }
-
-        // Build query with optional status filter
-        let query = `
-            SELECT
-                discovery_id,
-                project_id,
-                pattern_name,
-                pattern_description,
-                confidence,
-                discovery_type,
-                status,
-                evidence,
-                reason,
-                reason_code,
-                created_at,
-                updated_at
-            FROM rapport.onboarding_discoveries
-            WHERE project_id = $1
-        `;
-        const params = [projectId];
-
-        if (status) {
-            query += ` AND status = $2`;
-            params.push(status);
-        }
-
-        query += ` ORDER BY confidence DESC, created_at DESC`;
-
-        const result = await executeQuery(query, params);
-
-        // Map DB columns to frontend Discovery interface
-        const records = result.rows.map(row => ({
-            id: row.discovery_id,
-            project_id: row.project_id,
-            name: row.pattern_name,
-            description: row.pattern_description || '',
-            confidence: parseFloat(row.confidence) || 0,
-            source: 'github',
-            category: row.discovery_type || 'Architecture',
-            status: row.status || 'proposed',
-            rule_text: null,
-            action_type: null,
-            evidence: row.evidence || null,
-            created_at: row.created_at,
-            updated_at: row.updated_at
-        }));
-
-        return createSuccessResponse({
-            records,
-            total: result.rowCount
-        }, `Found ${result.rowCount} discoveries`);
-
-    } catch (error) {
-        console.error('Discoveries Get Error:', error);
-        return createErrorResponse(500, 'Failed to load discoveries');
-    }
-}
-
-exports.handler = wrapHandler(getDiscoveries);

package/src/handlers/standards/projectStandardsGet.js

@@ -1,129 +0,0 @@
-/**
- * Project Standards Get Handler
- * Returns standards preferences for a project
- *
- * GET /api/projects/standards?project_id=xxx
- * Auth: Cognito JWT required
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, verifyProjectAccess } = require('./helpers');
-
-async function getProjectStandards({ queryStringParameters, pathParameters, requestContext }) {
-    try {
-        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
-
-        if (!email) {
-            return createErrorResponse(401, 'Authentication required');
-        }
-
-        const projectId = pathParameters?.projectId || (queryStringParameters || {}).project_id;
-
-        if (!projectId) {
-            return createErrorResponse(400, 'projectId is required');
-        }
-
-        // Verify user has access to project (collaborator or company member)
-        const projectAccess = await verifyProjectAccess(projectId, email);
-        if (!projectAccess) {
-            return createErrorResponse(403, 'Access denied to project');
-        }
-
-        const projectName = projectAccess.project_name;
-
-        // Get project standards preferences
-        const prefsResult = await executeQuery(`
-            SELECT
-                ps.catalog_id,
-                ps.enabled_categories,
-                ps.standard_overrides,
-                ps.critical_overrides,
-                ps.modified_by,
-                ps.modified_at,
-                sc.version as catalog_version,
-                sc.categories as available_categories,
-                sc.layers as available_layers,
-                sc.critical_alerts,
-                sc.total_standards
-            FROM rapport.project_standards ps
-            JOIN rapport.standards_catalog sc ON ps.catalog_id = sc.catalog_id
-            WHERE ps.project_id = $1
-        `, [projectId]);
-
-        // If no preferences exist, return defaults with catalog info
-        if (prefsResult.rowCount === 0) {
-            const catalogResult = await executeQuery(`
-                SELECT
-                    catalog_id,
-                    version,
-                    categories,
-                    layers,
-                    critical_alerts,
-                    total_standards
-                FROM rapport.standards_catalog
-                WHERE catalog_id = 'equilateral-v1'
-            `);
-
-            if (catalogResult.rowCount === 0) {
-                return createErrorResponse(404, 'Standards catalog not found');
-            }
-
-            const catalog = catalogResult.rows[0];
-
-            // Default: all categories enabled
-            const defaultCategories = {};
-            if (catalog.categories) {
-                for (const key of Object.keys(catalog.categories)) {
-                    defaultCategories[key] = true;
-                }
-            }
-
-            return createSuccessResponse({
-                project_id: projectId,
-                project_name: projectName,
-                catalog_id: catalog.catalog_id,
-                catalog_version: catalog.version,
-                has_custom_preferences: false,
-                preferences: {
-                    enabled_categories: defaultCategories,
-                    standard_overrides: {},
-                    critical_overrides: {}
-                },
-                catalog: {
-                    categories: catalog.categories,
-                    layers: catalog.layers,
-                    critical_alerts: catalog.critical_alerts,
-                    total_standards: catalog.total_standards
-                }
-            }, 'Default standards preferences');
-        }
-
-        const prefs = prefsResult.rows[0];
-
-        return createSuccessResponse({
-            project_id: projectId,
-            project_name: projectName,
-            catalog_id: prefs.catalog_id,
-            catalog_version: prefs.catalog_version,
-            has_custom_preferences: true,
-            preferences: {
-                enabled_categories: prefs.enabled_categories || {},
-                standard_overrides: prefs.standard_overrides || {},
-                critical_overrides: prefs.critical_overrides || {}
-            },
-            catalog: {
-                categories: prefs.available_categories,
-                layers: prefs.available_layers,
-                critical_alerts: prefs.critical_alerts,
-                total_standards: prefs.total_standards
-            },
-            modified_by: prefs.modified_by,
-            modified_at: prefs.modified_at
-        }, 'Project standards preferences retrieved');
-
-    } catch (error) {
-        console.error('Project Standards Get Error:', error);
-        return createErrorResponse(500, 'Failed to retrieve project standards');
-    }
-}
-
-exports.handler = wrapHandler(getProjectStandards);