@equilateral_ai/mindmeld 3.1.2 → 3.3.0

package/src/handlers/projects/projectUpdate.js

@@ -2,8 +2,8 @@
  * Project Update Handler
  * Updates project metadata
  *
- * PUT /api/projects/{projectId}
- * Body: { project_name, description, private }
+ * PUT /api/projects
+ * Body: { project_id, project_name, description, private }
  */
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
@@ -12,14 +12,13 @@ const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, h
  * Update project
  * Requires owner or admin role on project
  */
-async function updateProject({ pathParameters = {}, body: requestBody = {}, requestContext }) {
+async function updateProject({ 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 { projectId } = pathParameters;
-        const { project_name, description, private: isPrivate, repo_url } = requestBody;
+        const { project_id: projectId, project_name, description, private: isPrivate, repo_url } = requestBody;
 
         if (!projectId) {
             return createErrorResponse(400, 'projectId is required');

package/src/handlers/scheduled/analyzeCorrelations.js

@@ -13,7 +13,7 @@
  */
 
 const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
-const { CorrelationAnalyzer } = require('../../core/CorrelationAnalyzer');
+const { CorrelationAnalyzer } = require('./core/CorrelationAnalyzer');
 
 /**
  * Main handler - wrapped with wrapHandler for consistent error handling
@@ -105,9 +105,9 @@ async function createStrugglingDeveloperAlerts(companyId, developers) {
                 SELECT 1 FROM rapport.attention_alerts
                 WHERE email_address = $1
                 AND alert_type = 'low_conversion'
-                AND (status = 'active' OR created_at > NOW() - INTERVAL '${cooldownHours} hours')
+                AND (status = 'active' OR created_at > NOW() - $2 * INTERVAL '1 hour')
                 LIMIT 1
-            `, [dev.email]);
+            `, [dev.email, cooldownHours]);
 
             if (existingCheck.rows.length > 0) {
                 console.log(`[AnalyzeCorrelations] Skipping alert for ${dev.email} - already exists`);

package/src/handlers/scheduled/generateAlerts.js

@@ -15,7 +15,7 @@
  */
 
 const { wrapHandler, createSuccessResponse, executeQuery } = require('./helpers');
-const { AlertEngine, setExecuteQuery } = require('../../core/AlertEngine');
+const { AlertEngine, setExecuteQuery } = require('./core/AlertEngine');
 
 // Initialize AlertEngine with database connection
 setExecuteQuery(executeQuery);

package/src/handlers/standards/catalogGet.js

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

@@ -0,0 +1,120 @@
+/**
+ * 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/projectStandardsGet.js

@@ -0,0 +1,135 @@
+/**
+ * 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 } = require('./helpers');
+
+async function getProjectStandards({ 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;
+
+        if (!projectId) {
+            return createErrorResponse(400, 'projectId is required');
+        }
+
+        // Verify user has access to project
+        const accessResult = await executeQuery(`
+            SELECT pc.role, p.project_name
+            FROM rapport.project_collaborators pc
+            JOIN rapport.projects p ON pc.project_id = p.project_id
+            WHERE pc.project_id = $1 AND pc.email_address = $2
+        `, [projectId, email]);
+
+        if (accessResult.rowCount === 0) {
+            return createErrorResponse(403, 'Access denied to project');
+        }
+
+        const projectName = accessResult.rows[0].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);

package/src/handlers/standards/projectStandardsPut.js

@@ -0,0 +1,131 @@
+/**
+ * Project Standards Put Handler
+ * Updates standards preferences for a project
+ *
+ * PUT /api/projects/standards
+ * Body: { project_id, enabled_categories, standard_overrides, critical_overrides }
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+async function updateProjectStandards({ body, requestContext }) {
+    try {
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const projectId = (body || {}).project_id;
+
+        if (!projectId) {
+            return createErrorResponse(400, 'projectId is required');
+        }
+
+        const {
+            enabled_categories,
+            standard_overrides,
+            critical_overrides,
+            catalog_id = 'equilateral-v1'
+        } = body || {};
+
+        // Verify user has admin access to project
+        const accessResult = await executeQuery(`
+            SELECT role FROM rapport.project_collaborators
+            WHERE project_id = $1 AND email_address = $2
+        `, [projectId, email]);
+
+        if (accessResult.rowCount === 0) {
+            return createErrorResponse(403, 'Access denied to project');
+        }
+
+        const role = accessResult.rows[0].role;
+        if (role !== 'owner' && role !== 'admin') {
+            return createErrorResponse(403, 'Admin access required to modify standards preferences');
+        }
+
+        // Verify catalog exists
+        const catalogResult = await executeQuery(`
+            SELECT catalog_id, categories FROM rapport.standards_catalog
+            WHERE catalog_id = $1
+        `, [catalog_id]);
+
+        if (catalogResult.rowCount === 0) {
+            return createErrorResponse(404, 'Standards catalog not found', { catalog_id });
+        }
+
+        const availableCategories = Object.keys(catalogResult.rows[0].categories || {});
+
+        // Validate enabled_categories keys
+        if (enabled_categories) {
+            const invalidCategories = Object.keys(enabled_categories).filter(
+                cat => !availableCategories.includes(cat)
+            );
+            if (invalidCategories.length > 0) {
+                return createErrorResponse(400, 'Invalid category names', {
+                    invalid: invalidCategories,
+                    valid: availableCategories
+                });
+            }
+        }
+
+        // Upsert project standards
+        const result = await executeQuery(`
+            INSERT INTO rapport.project_standards (
+                project_id,
+                catalog_id,
+                enabled_categories,
+                standard_overrides,
+                critical_overrides,
+                created_by,
+                modified_by
+            ) VALUES ($1, $2, $3, $4, $5, $6, $6)
+            ON CONFLICT (project_id, catalog_id) DO UPDATE SET
+                enabled_categories = COALESCE($3, rapport.project_standards.enabled_categories),
+                standard_overrides = COALESCE($4, rapport.project_standards.standard_overrides),
+                critical_overrides = COALESCE($5, rapport.project_standards.critical_overrides),
+                modified_by = $6,
+                modified_at = NOW()
+            RETURNING *
+        `, [
+            projectId,
+            catalog_id,
+            enabled_categories ? JSON.stringify(enabled_categories) : null,
+            standard_overrides ? JSON.stringify(standard_overrides) : null,
+            critical_overrides ? JSON.stringify(critical_overrides) : null,
+            email
+        ]);
+
+        const updated = result.rows[0];
+
+        // Count enabled standards
+        const enabledCats = updated.enabled_categories || {};
+        const enabledCount = Object.values(enabledCats).filter(v => v === true).length;
+        const disabledCount = Object.values(enabledCats).filter(v => v === false).length;
+
+        return createSuccessResponse({
+            project_id: projectId,
+            catalog_id: updated.catalog_id,
+            preferences: {
+                enabled_categories: updated.enabled_categories,
+                standard_overrides: updated.standard_overrides,
+                critical_overrides: updated.critical_overrides
+            },
+            summary: {
+                categories_enabled: enabledCount,
+                categories_disabled: disabledCount,
+                standard_overrides: Object.keys(updated.standard_overrides || {}).length,
+                critical_overrides: Object.keys(updated.critical_overrides || {}).length
+            },
+            modified_by: updated.modified_by,
+            modified_at: updated.modified_at
+        }, 'Standards preferences updated');
+
+    } catch (error) {
+        console.error('Project Standards Put Error:', error);
+        return createErrorResponse(500, 'Failed to update project standards');
+    }
+}
+
+exports.handler = wrapHandler(updateProjectStandards);