@equilateral_ai/mindmeld 3.5.2 → 4.0.1

package/src/handlers/standards/projectStandardsPut.js

@@ -1,151 +0,0 @@
-/**
- * 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, verifyProjectRole } = require('./helpers');
-
-async function updateProjectStandards({ body, 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 || (body || {}).project_id;
-
-        if (!projectId) {
-            return createErrorResponse(400, 'projectId is required');
-        }
-
-        const {
-            enabled_categories,
-            standard_overrides,
-            critical_overrides,
-            catalog_id = 'equilateral-v1',
-            standard_id,
-            load_bearing
-        } = body || {};
-
-        // Verify user has admin access to project (project owner/admin or company admin)
-        const projectAccess = await verifyProjectRole(projectId, email, ['owner', 'admin']);
-        if (!projectAccess) {
-            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
-                });
-            }
-        }
-
-        // Update load_bearing flag on a specific standard if provided
-        if (standard_id && typeof load_bearing === 'boolean') {
-            const userCompany = await executeQuery(`
-                SELECT company_id FROM rapport.user_entitlements WHERE email_address = $1 LIMIT 1
-            `, [email]);
-            const companyId = userCompany.rows[0]?.company_id;
-
-            // Try base standards first
-            const baseResult = await executeQuery(`
-                UPDATE rapport.standards_patterns
-                SET load_bearing = $1
-                WHERE pattern_id = $2
-                  AND (company_id IS NULL OR company_id = $3)
-            `, [load_bearing, standard_id, companyId]);
-
-            // If no base standard matched, try company overrides
-            if (baseResult.rowCount === 0 && companyId) {
-                await executeQuery(`
-                    UPDATE rapport.company_standard_overrides
-                    SET load_bearing = $1
-                    WHERE (base_standard_id = $2 OR override_id::text = $3)
-                      AND company_id = $4
-                      AND active = TRUE
-                `, [load_bearing, standard_id, standard_id.replace('company-add-', ''), companyId]);
-            }
-        }
-
-        // 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);

package/src/handlers/standards/standardsAuditGet.js

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

@@ -1,149 +0,0 @@
-/**
- * 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, verifyProjectAccess } = 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 (collaborator or company member)
-    const projectAccess = await verifyProjectAccess(project_id, email);
-    if (!projectAccess) {
-      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);