@equilateral_ai/mindmeld 3.2.0 → 3.3.1

package/src/handlers/standards/standardsAuditGet.js

@@ -0,0 +1,65 @@
+/**
+ * Standards Audit Get Handler
+ * Returns the audit trail for a standard's lifecycle transitions
+ *
+ * GET /api/standards/audit?standard_id=xxx
+ * Query params: standard_id (required), cursor (string), limit (number, default 50, max 200)
+ * Returns: { audit_trail, total_transitions, current_state }
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, createSuccessResponse, createErrorResponse } = require('./helpers');
+const { StandardLifecycle } = require('./core/StandardLifecycle');
+
+const lifecycle = new StandardLifecycle();
+
+async function getStandardsAudit({ queryStringParameters, requestContext }) {
+    try {
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const id = (queryStringParameters || {}).standard_id;
+
+        if (!id) {
+            return createErrorResponse(400, 'standard_id is required');
+        }
+
+        // Verify the standard exists
+        const currentState = await lifecycle.getCurrentState(id);
+
+        if (!currentState) {
+            return createErrorResponse(404, 'Standard not found', { standard_id: id });
+        }
+
+        // Get valid transitions from the current state
+        const validTransitions = lifecycle.getValidTransitions(currentState);
+
+        // Get audit history with pagination
+        const cursor = queryStringParameters?.cursor || null;
+        const limit = queryStringParameters?.limit ? parseInt(queryStringParameters.limit) : 50;
+
+        const history = await lifecycle.getHistory(id, { cursor, limit });
+
+        return createSuccessResponse({
+            standard_id: id,
+            current_state: currentState,
+            valid_transitions: validTransitions,
+            audit_trail: history.entries,
+            total_transitions: history.total_transitions,
+            pagination: {
+                has_more: history.has_more,
+                next_cursor: history.next_cursor,
+                limit: limit
+            }
+        }, 'Audit trail retrieved');
+
+    } catch (error) {
+        console.error('Standards Audit Get Error:', error);
+        return createErrorResponse(500, 'Failed to retrieve audit trail');
+    }
+}
+
+exports.handler = wrapHandler(getStandardsAudit);

package/src/handlers/standards/standardsParseUpload.js

@@ -0,0 +1,153 @@
+/**
+ * Standards Parse Upload Handler
+ * Parses uploaded standards files into YAML-compatible format
+ *
+ * POST /api/standards/parse-upload
+ * Body: { project_id, content, format: 'adr'|'eslint'|'cursorrules'|'markdown', filename }
+ * Auth: Cognito JWT required
+ *
+ * Uses the appropriate parser based on the specified format and returns
+ * parsed YAML-compatible standards ready for storage or review.
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+const { parseAdr } = require('./core/parsers/adrParser');
+const { parseEslint } = require('./core/parsers/eslintParser');
+const { parseCursorRules } = require('./core/parsers/cursorRulesParser');
+
+const SUPPORTED_FORMATS = ['adr', 'eslint', 'cursorrules', 'markdown'];
+
+async function parseUploadStandards({ body, requestContext }) {
+  try {
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+      return createErrorResponse(401, 'Authentication required');
+    }
+
+    const { project_id, content, format, filename } = body || {};
+
+    // Validate required fields
+    if (!project_id) {
+      return createErrorResponse(400, 'project_id is required');
+    }
+
+    if (!content) {
+      return createErrorResponse(400, 'content is required');
+    }
+
+    if (!format) {
+      return createErrorResponse(400, 'format is required', {
+        supported: SUPPORTED_FORMATS
+      });
+    }
+
+    if (!SUPPORTED_FORMATS.includes(format)) {
+      return createErrorResponse(400, `Unsupported format: ${format}`, {
+        supported: SUPPORTED_FORMATS
+      });
+    }
+
+    // Verify user has access to the project
+    const accessResult = await executeQuery(`
+      SELECT role FROM rapport.project_collaborators
+      WHERE project_id = $1 AND email_address = $2
+    `, [project_id, email]);
+
+    if (accessResult.rowCount === 0) {
+      return createErrorResponse(403, 'Access denied to project');
+    }
+
+    // Parse the content using the appropriate parser
+    const parserOptions = {
+      filename: filename || `uploaded-${format}`,
+      category: undefined // Let parser infer category
+    };
+
+    let parsed;
+    try {
+      parsed = parseContent(content, format, parserOptions);
+    } catch (parseError) {
+      return createErrorResponse(422, `Failed to parse ${format} content: ${parseError.message}`, {
+        format,
+        filename: parserOptions.filename
+      });
+    }
+
+    // Record the upload activity
+    await executeQuery(`
+      INSERT INTO rapport.activity_log (
+        email_address,
+        project_id,
+        activity_type,
+        activity_data,
+        created_at
+      ) VALUES ($1, $2, 'standards_upload', $3, NOW())
+    `, [
+      email,
+      project_id,
+      JSON.stringify({
+        format,
+        filename: filename || null,
+        rules_count: parsed.rules ? parsed.rules.length : 0,
+        anti_patterns_count: parsed.anti_patterns ? parsed.anti_patterns.length : 0,
+        category: parsed.category,
+        id: parsed.id
+      })
+    ]);
+
+    return createSuccessResponse({
+      project_id,
+      format,
+      filename: filename || null,
+      parsed,
+      summary: {
+        id: parsed.id,
+        category: parsed.category,
+        priority: parsed.priority,
+        rules_count: parsed.rules ? parsed.rules.length : 0,
+        anti_patterns_count: parsed.anti_patterns ? parsed.anti_patterns.length : 0,
+        tags: parsed.tags || []
+      }
+    }, `Successfully parsed ${format} content`);
+
+  } catch (error) {
+    console.error('Standards Parse Upload Error:', error);
+    return createErrorResponse(500, 'Failed to parse uploaded standards');
+  }
+}
+
+/**
+ * Route content to the appropriate parser based on format
+ *
+ * @param {string} content - Raw content to parse
+ * @param {string} format - Format identifier
+ * @param {Object} options - Parser options
+ * @returns {Object} Parsed YAML-compatible standards object
+ */
+function parseContent(content, format, options) {
+  switch (format) {
+    case 'adr':
+      return parseAdr(content, options);
+
+    case 'eslint':
+      return parseEslint(content, options);
+
+    case 'cursorrules':
+      return parseCursorRules(content, options);
+
+    case 'markdown':
+      // Markdown format uses the cursor rules parser since it handles
+      // generic markdown with rule sections effectively
+      return parseCursorRules(content, {
+        ...options,
+        filename: options.filename || 'standards.md'
+      });
+
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+exports.handler = wrapHandler(parseUploadStandards);

package/src/handlers/standards/standardsRelevantPost.js

@@ -0,0 +1,213 @@
+/**
+ * Standards Relevant Post Handler
+ *
+ * Returns top 10 relevant standards for a project based on detected characteristics.
+ * The session-start hook calls this endpoint with locally-detected project characteristics;
+ * the handler maps them to categories, queries the database, ranks results, and returns
+ * the most relevant standards for injection into the AI coding session.
+ *
+ * POST /api/standards/relevant
+ * Auth: Cognito JWT required
+ * Body: { characteristics, projectId?, preferences? }
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+/**
+ * Category weights for relevance scoring
+ */
+const CATEGORY_WEIGHTS = {
+    'serverless-saas-aws': 1.0,
+    'multi-agent-orchestration': 1.0,
+    'frontend-development': 1.0,
+    'database': 0.9,
+    'compliance-security': 0.8,
+    'cost-optimization': 0.7,
+    'real-time-systems': 0.8,
+    'testing': 0.6,
+    'backend': 0.9,
+    'well-architected': 0.7
+};
+
+/**
+ * Map project characteristics to relevant standard categories
+ */
+function mapCharacteristicsToCategories(characteristics) {
+    const categories = new Set();
+
+    if (characteristics.hasLambda || characteristics.hasSAM) {
+        categories.add('serverless-saas-aws');
+        categories.add('cost-optimization');
+    }
+    if (characteristics.hasReact) {
+        categories.add('frontend-development');
+    }
+    if (characteristics.hasDatabase) {
+        categories.add('database');
+    }
+    if (characteristics.hasMultiAgent) {
+        categories.add('multi-agent-orchestration');
+    }
+    if (characteristics.hasAPI) {
+        categories.add('backend');
+    }
+    if (characteristics.hasTests) {
+        categories.add('testing');
+    }
+
+    // Always relevant
+    categories.add('compliance-security');
+    categories.add('well-architected');
+
+    return Array.from(categories);
+}
+
+/**
+ * Rank standards by relevance score
+ */
+function rankStandards(standards) {
+    return standards.map(standard => {
+        let score = 0;
+
+        // Base score from correlation
+        score += (standard.correlation || 1.0) * 40;
+
+        // Maturity score
+        const maturityScores = { enforced: 30, validated: 20, recommended: 10, provisional: 5 };
+        score += maturityScores[standard.maturity] || 0;
+
+        // Category weight
+        const categoryWeight = CATEGORY_WEIGHTS[standard.category] || 0.5;
+        score += categoryWeight * 20;
+
+        // File applicability bonus
+        if (standard.applicable_files && standard.applicable_files.length > 0) {
+            score += 5;
+        }
+
+        // Cost impact bonus (critical patterns)
+        if (standard.cost_impact && standard.cost_impact.severity === 'critical') {
+            score += 10;
+        }
+
+        // Anti-patterns bonus (important to know what NOT to do)
+        if (standard.anti_patterns) {
+            const apCount = Array.isArray(standard.anti_patterns)
+                ? standard.anti_patterns.length
+                : Object.keys(standard.anti_patterns).length;
+            if (apCount > 0) score += 5;
+        }
+
+        return {
+            ...standard,
+            relevance_score: Math.round(score * 10) / 10
+        };
+    }).sort((a, b) => b.relevance_score - a.relevance_score);
+}
+
+/**
+ * Apply user preferences to filter standards
+ */
+function applyPreferences(standards, preferences) {
+    if (!preferences) return standards;
+
+    const enabledCategories = preferences.enabled_categories || {};
+    const standardOverrides = preferences.standard_overrides || {};
+
+    return standards.filter(standard => {
+        const category = standard.category;
+        const standardPath = `${category}/${standard.element}`;
+
+        // Individual override takes priority
+        if (standardPath in standardOverrides) {
+            return standardOverrides[standardPath] === true;
+        }
+
+        // Category-level setting
+        if (category in enabledCategories) {
+            return enabledCategories[category] === true;
+        }
+
+        // Default: include
+        return true;
+    });
+}
+
+async function getRelevantStandards({ body, requestContext }) {
+    const email = requestContext.authorizer?.claims?.email
+        || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    // Parse request body
+    let requestBody;
+    try {
+        requestBody = typeof body === 'string' ? JSON.parse(body) : body;
+    } catch (e) {
+        return createErrorResponse(400, 'Invalid request body');
+    }
+
+    const { characteristics, preferences } = requestBody || {};
+
+    if (!characteristics || typeof characteristics !== 'object') {
+        return createErrorResponse(400, 'characteristics object is required');
+    }
+
+    // Map characteristics to categories
+    const categories = mapCharacteristicsToCategories(characteristics);
+
+    if (categories.length === 0) {
+        return createSuccessResponse({
+            standards: [],
+            categories: [],
+            total_matched: 0
+        }, 'No relevant categories detected');
+    }
+
+    // Query standards matching categories
+    const result = await executeQuery(`
+        SELECT
+            pattern_id,
+            element,
+            rule,
+            category,
+            correlation,
+            maturity,
+            applicable_files,
+            anti_patterns,
+            examples,
+            cost_impact,
+            source
+        FROM rapport.standards_patterns
+        WHERE category = ANY($1::varchar[])
+            AND maturity IN ('enforced', 'validated', 'recommended')
+        ORDER BY
+            CASE
+                WHEN maturity = 'enforced' THEN 1
+                WHEN maturity = 'validated' THEN 2
+                ELSE 3
+            END,
+            correlation DESC
+    `, [categories]);
+
+    // Rank by relevance
+    let ranked = rankStandards(result.rows);
+
+    // Apply preferences if provided
+    if (preferences) {
+        ranked = applyPreferences(ranked, preferences);
+    }
+
+    // Return top 10
+    const top = ranked.slice(0, 10);
+
+    return createSuccessResponse({
+        standards: top,
+        categories,
+        total_matched: result.rows.length
+    }, 'Relevant standards retrieved');
+}
+
+exports.handler = wrapHandler(getRelevantStandards);

package/src/handlers/standards/standardsTransition.js

@@ -0,0 +1,64 @@
+/**
+ * Standards Transition Handler
+ * Executes lifecycle state transitions on standards
+ *
+ * POST /api/standards/transition
+ * Body: { standard_id, action: 'approve'|'disable'|'deprecate'|'delete'|'enable'|'cancel_deprecation', reason? }
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, createSuccessResponse, createErrorResponse } = require('./helpers');
+const { StandardLifecycle } = require('./core/StandardLifecycle');
+
+const lifecycle = new StandardLifecycle();
+
+async function transitionStandard({ body, requestContext }) {
+    try {
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const { standard_id: id, action, reason } = body || {};
+
+        if (!id) {
+            return createErrorResponse(400, 'standard_id is required');
+        }
+
+        if (!action) {
+            return createErrorResponse(400, 'action is required', {
+                valid_actions: ['propose', 'approve', 'reject', 'disable', 'deprecate', 'delete', 'enable', 'cancel_deprecation']
+            });
+        }
+
+        // Execute the transition
+        const result = await lifecycle.transition(id, action, email, reason);
+
+        return createSuccessResponse({
+            standard_id: result.standard_id,
+            old_state: result.old_state,
+            new_state: result.new_state,
+            action: result.action,
+            audit_entry: result.audit_entry
+        }, `Standard transitioned from '${result.old_state}' to '${result.new_state}'`);
+
+    } catch (error) {
+        console.error('Standards Transition Error:', error);
+
+        // Return user-friendly messages for known validation errors
+        if (error.message.includes('Invalid action')) {
+            return createErrorResponse(400, error.message);
+        }
+        if (error.message.includes('not found')) {
+            return createErrorResponse(404, error.message);
+        }
+        if (error.message.includes('Cannot perform')) {
+            return createErrorResponse(409, error.message);
+        }
+
+        return createErrorResponse(500, 'Failed to transition standard');
+    }
+}
+
+exports.handler = wrapHandler(transitionStandard);

package/src/handlers/user/userSplashAck.js

@@ -0,0 +1,91 @@
+/**
+ * User Splash Acknowledge Handler
+ * Records that the user has dismissed the weekly splash screen
+ *
+ * POST /api/user/splash/acknowledge
+ * Auth: Cognito JWT required
+ *
+ * Body: { week_start: "2026-01-27" }
+ * Records acknowledgment so splash does not show again this week
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+async function acknowledgeUserSplash({ requestContext, body }) {
+    const Request_ID = requestContext.requestId;
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    const weekStart = body?.week_start;
+    if (!weekStart) {
+        return createErrorResponse(400, 'week_start is required');
+    }
+
+    // Validate week_start format (YYYY-MM-DD)
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+    if (!dateRegex.test(weekStart)) {
+        return createErrorResponse(400, 'week_start must be in YYYY-MM-DD format');
+    }
+
+    // Attempt to insert acknowledgment into dedicated table
+    try {
+        await executeQuery(`
+            INSERT INTO rapport.user_splash_acknowledgments (email_address, week_start, acknowledged_at)
+            VALUES ($1, $2, NOW())
+            ON CONFLICT (email_address, week_start) DO NOTHING
+        `, [email, weekStart]);
+
+        return createSuccessResponse(
+            { acknowledged: true, week_start: weekStart },
+            'Splash acknowledged',
+            { Request_ID, Timestamp: new Date().toISOString() }
+        );
+    } catch (tableErr) {
+        // If the dedicated table does not exist, fall back to storing
+        // acknowledgment as metadata in the patterns table
+        console.log('[SplashAck] Dedicated table not available, using fallback:', tableErr.message);
+
+        try {
+            await executeQuery(`
+                INSERT INTO rapport.patterns (
+                    pattern_type,
+                    pattern_key,
+                    pattern_value,
+                    created_by,
+                    created_at,
+                    metadata
+                )
+                VALUES (
+                    'splash_ack',
+                    $1,
+                    $2,
+                    $3,
+                    NOW(),
+                    $4
+                )
+                ON CONFLICT (pattern_type, pattern_key) WHERE pattern_type = 'splash_ack'
+                DO UPDATE SET
+                    pattern_value = EXCLUDED.pattern_value,
+                    created_at = NOW()
+            `, [
+                `splash_ack:${email}:${weekStart}`,
+                weekStart,
+                email,
+                JSON.stringify({ type: 'splash_acknowledgment', week_start: weekStart })
+            ]);
+
+            return createSuccessResponse(
+                { acknowledged: true, week_start: weekStart, fallback: true },
+                'Splash acknowledged (fallback)',
+                { Request_ID, Timestamp: new Date().toISOString() }
+            );
+        } catch (fallbackErr) {
+            return handleError(fallbackErr);
+        }
+    }
+}
+
+exports.handler = wrapHandler(acknowledgeUserSplash);