@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/handlers/standards/standardsRelevantPost.js

@@ -1,405 +0,0 @@
-/**
- * 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, getPredictedStandards, logStandardsActivation, createFrame } = require('./helpers');
-
-/**
- * Category weights for relevance scoring
- */
-const CATEGORY_WEIGHTS = {
-    // Code standard categories
-    'serverless-saas-aws': 1.0,
-    'frontend-development': 1.0,
-    'database': 0.9,
-    'backend': 0.9,
-    'compliance-security': 0.9,
-    'deployment': 0.8,
-    'testing': 0.7,
-    'real-time-systems': 0.7,
-    'well-architected': 0.7,
-    'cost-optimization': 0.7,
-    'multi-agent-orchestration': 0.1,  // Infrastructure config, rarely needed in coding sessions
-    // Business domains — moderate weights, boosted by recency when relevant
-    'ip-strategy': 0.6,
-    'architecture-decisions': 0.8,
-    'go-to-market': 0.6,
-    'operations': 0.5,
-    'legal-process': 0.5,
-    'finance': 0.5,
-    'communication': 0.4,
-    'product-strategy': 0.6,
-    'investor-relations': 0.4,
-};
-
-/**
- * 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');
-    }
-    if (characteristics.hasSAM || characteristics.hasLambda || characteristics.hasAPI) {
-        categories.add('deployment');
-    }
-
-    // Always relevant
-    categories.add('compliance-security');
-    categories.add('well-architected');
-
-    return Array.from(categories);
-}
-
-/**
- * Rank standards by relevance score
- */
-function rankStandards(standards, recentCategories) {
-    return standards.map(standard => {
-        let score = 0;
-
-        // Base score from correlation
-        score += (standard.correlation || 1.0) * 40;
-
-        // Maturity score (includes business invariant lifecycle values)
-        const maturityScores = { enforced: 30, reinforced: 25, validated: 20, solidified: 15, 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;
-        }
-
-        // Workflow bonus — workflows are high-value procedural knowledge
-        const isWorkflow = (standard.rule && standard.rule.startsWith('WORKFLOW:'))
-            || (Array.isArray(standard.keywords) && standard.keywords.includes('workflow'));
-        if (isWorkflow) score += 10;
-
-        // Rationale bonus — business invariants with documented reasoning
-        if (standard.rationale) score += 5;
-
-        // Recency bonus — boost categories the user has been working in recently
-        // Scaled by category weight to prevent feedback loops (low-weight categories
-        // that got injected shouldn't bootstrap themselves back into the top 10)
-        if (recentCategories && recentCategories[standard.category]) {
-            const usageCount = recentCategories[standard.category];
-            let rawBonus;
-            if (usageCount >= 8) rawBonus = 25;
-            else if (usageCount >= 4) rawBonus = 18;
-            else rawBonus = 10;
-            score += rawBonus * categoryWeight;
-        }
-
-        // Recency decay: patterns not seen in 30+ days get penalized
-        if (standard.last_seen_at) {
-            const daysSinceLastSeen = (Date.now() - new Date(standard.last_seen_at).getTime()) / (1000 * 60 * 60 * 24);
-            if (daysSinceLastSeen > 30) {
-                score *= 0.5;
-            }
-        }
-
-        // Frequency boost: high-occurrence patterns are more valuable
-        const occurrenceCount = standard.occurrence_count || 1;
-        if (occurrenceCount > 50) {
-            score *= 1.5;
-        } else if (occurrenceCount > 10) {
-            score *= 1.2;
-        }
-
-        return {
-            ...standard,
-            relevance_score: Math.round(score * 10) / 10
-        };
-    }).sort((a, b) => {
-        // Load-bearing standards always sort to the top
-        const aLB = a.load_bearing ? 1 : 0;
-        const bLB = b.load_bearing ? 1 : 0;
-        if (bLB !== aLB) return bLB - aLB;
-        return 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');
-    }
-
-    // Verify active subscription and resolve company_id for tenant isolation
-    const subResult = await executeQuery(`
-        SELECT c.subscription_tier, c.subscription_status, ue.company_id
-        FROM rapport.users u
-        JOIN rapport.clients c ON u.client_id = c.client_id
-        LEFT JOIN rapport.user_entitlements ue ON u.email_address = ue.email_address
-        WHERE u.email_address = $1
-        LIMIT 1
-    `, [email]);
-
-    let companyId = null;
-    if (subResult.rows.length > 0) {
-        const { subscription_tier, subscription_status } = subResult.rows[0];
-        companyId = subResult.rows[0].company_id;
-        if (!subscription_tier || subscription_tier === 'free') {
-            return createErrorResponse(403, 'Active MindMeld subscription required. Subscribe at app.mindmeld.dev');
-        }
-        if (subscription_status === 'canceled') {
-            return createErrorResponse(403, 'Subscription canceled. Resubscribe at app.mindmeld.dev');
-        }
-    }
-
-    // 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 recent session categories first (fast), then merge into categories for main query
-    const recentCategories = {};
-    try {
-        const recencyResult = await executeQuery(`
-            SELECT sp.category, COUNT(*) as usage_count
-            FROM rapport.session_standards ss
-            JOIN rapport.sessions s ON s.session_id = ss.session_id
-            JOIN rapport.standards_patterns sp ON sp.pattern_id = ss.standard_id
-            WHERE s.email_address = $1
-                AND s.started_at >= NOW() - INTERVAL '7 days'
-            GROUP BY sp.category
-            ORDER BY usage_count DESC
-            LIMIT 5
-        `, [email]);
-        for (const row of recencyResult.rows) {
-            recentCategories[row.category] = parseInt(row.usage_count, 10);
-        }
-    } catch (err) {
-        console.error('[standardsRelevant] Recency query failed:', err.message);
-    }
-
-    // Merge recency categories into query — recent activity should always be represented
-    for (const category of Object.keys(recentCategories)) {
-        if (!categories.includes(category)) {
-            categories.push(category);
-        }
-    }
-
-    // Query standards — tenant-isolated via get_effective_standards()
-    const maturityList = ['enforced', 'validated', 'recommended', 'provisional', 'solidified', 'reinforced'];
-    const result = await executeQuery(`
-        SELECT * FROM rapport.get_effective_standards($1, $2::varchar[], $3::varchar[])
-        ORDER BY
-            CASE
-                WHEN maturity = 'enforced' THEN 1
-                WHEN maturity = 'reinforced' THEN 2
-                WHEN maturity = 'validated' THEN 3
-                WHEN maturity = 'solidified' THEN 4
-                WHEN maturity = 'recommended' THEN 5
-                ELSE 6
-            END,
-            correlation DESC
-    `, [companyId, categories, maturityList]);
-
-    // Predictive cache: fetch standards with >80% activation rate for this project
-    let predictedStandards = [];
-    const projectId = requestBody.projectId;
-    if (projectId) {
-        try {
-            const predicted = await getPredictedStandards(projectId);
-            if (predicted.length > 0) {
-                const predictedIds = new Set(predicted.map(p => p.standard_id));
-                // Pull predicted standards from query results and mark them as pre-cached
-                predictedStandards = result.rows
-                    .filter(s => predictedIds.has(s.pattern_id || s.standard_id))
-                    .map(s => ({ ...s, relevance_score: 100, predicted: true }));
-            }
-        } catch (err) {
-            console.error('[standardsRelevant] Predictive cache lookup failed:', err.message);
-        }
-    }
-
-    // Rank by relevance with recency boost
-    let ranked = rankStandards(result.rows, recentCategories);
-
-    // Deduplicate by element name (same rule can be ingested with different path prefixes)
-    const seenElements = new Set();
-    ranked = ranked.filter(standard => {
-        const key = standard.element;
-        if (seenElements.has(key)) return false;
-        seenElements.add(key);
-        return true;
-    });
-
-    // Apply preferences if provided
-    if (preferences) {
-        ranked = applyPreferences(ranked, preferences);
-    }
-
-    // Return top 10 with diversity caps:
-    // - Max 2 per category (prevents single-category saturation)
-    // - Max 1 per standard title (prevents same-file rule pairs wasting slots)
-    // Predicted standards are included first (they skip scoring)
-    const MAX_PER_CATEGORY = 2;
-    const MAX_PER_TITLE = 1;
-    const top = [];
-    const categoryCounts = {};
-    const titleCounts = {};
-    const seenPredicted = new Set();
-
-    // Add predicted standards first — they have proven relevance
-    for (const standard of predictedStandards) {
-        const cat = standard.category;
-        const title = standard.title || standard.element;
-        const key = standard.element;
-        categoryCounts[cat] = (categoryCounts[cat] || 0) + 1;
-        titleCounts[title] = (titleCounts[title] || 0) + 1;
-        seenPredicted.add(key);
-        if (categoryCounts[cat] <= MAX_PER_CATEGORY && titleCounts[title] <= MAX_PER_TITLE) {
-            top.push(standard);
-            if (top.length >= 10) break;
-        }
-    }
-
-    // Fill remaining slots from scored standards
-    for (const standard of ranked) {
-        if (top.length >= 10) break;
-        if (seenPredicted.has(standard.element)) continue;
-        const cat = standard.category;
-        const title = standard.title || standard.element;
-        categoryCounts[cat] = (categoryCounts[cat] || 0) + 1;
-        titleCounts[title] = (titleCounts[title] || 0) + 1;
-        if (categoryCounts[cat] <= MAX_PER_CATEGORY && titleCounts[title] <= MAX_PER_TITLE) {
-            top.push(standard);
-        }
-    }
-
-    // Log activated standards for future predictions
-    if (projectId && top.length > 0) {
-        const activatedIds = top
-            .map(s => s.pattern_id || s.standard_id)
-            .filter(id => id != null);
-        logStandardsActivation(projectId, activatedIds).catch(err => {
-            console.error('[standardsRelevant] Activation logging failed:', err.message);
-        });
-    }
-
-    // Track decision frame for this standards selection
-    let frameId = null;
-    if (projectId && top.length > 0) {
-        try {
-            const standardIds = top
-                .map(s => s.pattern_id || s.standard_id)
-                .filter(id => id != null);
-            const avgScore = top.reduce((sum, s) => sum + (s.relevance_score || 0), 0) / top.length;
-            const confidence = Math.min(avgScore / 100, 1);
-            const frame = await createFrame({
-                projectId,
-                sessionId: requestBody.sessionId || null,
-                standardIds,
-                confidence,
-                context: { categories, characteristics, total_matched: result.rows.length }
-            });
-            frameId = frame.frame_id;
-        } catch (err) {
-            console.error('[standardsRelevant] Decision frame creation failed:', err.message);
-        }
-    }
-
-    return createSuccessResponse({
-        standards: top,
-        categories,
-        total_matched: result.rows.length,
-        frame_id: frameId
-    }, 'Relevant standards retrieved');
-}
-
-exports.handler = wrapHandler(getRelevantStandards);

package/src/handlers/standards/standardsTransition.js

@@ -1,161 +0,0 @@
-/**
- * Standards Transition Handler
- * Executes lifecycle state transitions on standards and discoveries
- *
- * POST /api/standards/transition
- * Body: { standard_id, action: 'approve'|'reject'|'observe'|'disable'|'deprecate'|'delete'|'enable'|'cancel_deprecation', reason?, reason_code? }
- * Auth: Cognito JWT required
- *
- * For discovery IDs (from onboarding_discoveries table):
- *   approve  → creates pattern + marks discovery approved
- *   reject   → marks discovery rejected
- *   observe  → marks discovery as observing (deferred review)
- */
-
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
-const { StandardLifecycle } = require('./core/StandardLifecycle');
-
-const lifecycle = new StandardLifecycle();
-
-const DISCOVERY_ACTIONS = ['approve', 'reject', 'observe'];
-
-/**
- * Handle transitions for onboarding discoveries
- */
-async function transitionDiscovery(discoveryId, action, email, reason, reasonCode) {
-    const discovery = await executeQuery(`
-        SELECT discovery_id, project_id, discovery_type, pattern_name, pattern_description, confidence, evidence, status
-        FROM rapport.onboarding_discoveries
-        WHERE discovery_id = $1
-    `, [discoveryId]);
-
-    if (discovery.rowCount === 0) {
-        return null; // Not a discovery either
-    }
-
-    const row = discovery.rows[0];
-    const oldStatus = row.status;
-
-    if (action === 'approve') {
-        // Create pattern from discovery
-        const patternId = `pat_${row.project_id}_${Date.now()}`;
-        await executeQuery(`
-            INSERT INTO rapport.patterns (
-                pattern_id, project_id, intent, constraints, outcome_criteria,
-                maturity, discovered_by, pattern_data
-            ) VALUES ($1, $2, $3, $4, $5, 'provisional', $6, $7)
-        `, [
-            patternId,
-            row.project_id,
-            row.pattern_name,
-            JSON.stringify([row.pattern_description || '']),
-            JSON.stringify([`Discovered via onboarding: ${row.discovery_type}`]),
-            email,
-            JSON.stringify({
-                source: 'discovery_review',
-                discovery_type: row.discovery_type,
-                evidence: row.evidence
-            })
-        ]);
-
-        await executeQuery(`
-            UPDATE rapport.onboarding_discoveries
-            SET status = 'approved', reviewed_at = NOW(), updated_at = NOW(), pattern_id = $1
-            WHERE discovery_id = $2
-        `, [patternId, discoveryId]);
-
-        return { old_state: oldStatus, new_state: 'approved', pattern_id: patternId };
-    }
-
-    if (action === 'reject') {
-        await executeQuery(`
-            UPDATE rapport.onboarding_discoveries
-            SET status = 'rejected', reviewed_at = NOW(), updated_at = NOW(), reason = $1, reason_code = $2
-            WHERE discovery_id = $3
-        `, [reason || null, reasonCode || null, discoveryId]);
-
-        return { old_state: oldStatus, new_state: 'rejected' };
-    }
-
-    if (action === 'observe') {
-        await executeQuery(`
-            UPDATE rapport.onboarding_discoveries
-            SET status = 'observing', updated_at = NOW()
-            WHERE discovery_id = $1
-        `, [discoveryId]);
-
-        return { old_state: oldStatus, new_state: 'observing' };
-    }
-
-    return null;
-}
-
-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, reason_code: reasonCode } = body || {};
-
-        if (!id) {
-            return createErrorResponse(400, 'standard_id is required');
-        }
-
-        if (!action) {
-            return createErrorResponse(400, 'action is required', {
-                valid_actions: ['propose', 'approve', 'reject', 'observe', 'disable', 'deprecate', 'delete', 'enable', 'cancel_deprecation']
-            });
-        }
-
-        // Try standard lifecycle transition first
-        try {
-            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 (lifecycleError) {
-            // If pattern not found and action is valid for discoveries, try discovery transition
-            if (lifecycleError.message.includes('not found') && DISCOVERY_ACTIONS.includes(action)) {
-                const discoveryResult = await transitionDiscovery(id, action, email, reason, reasonCode);
-
-                if (discoveryResult) {
-                    return createSuccessResponse({
-                        standard_id: id,
-                        old_state: discoveryResult.old_state,
-                        new_state: discoveryResult.new_state,
-                        action,
-                        pattern_id: discoveryResult.pattern_id || null
-                    }, `Discovery transitioned from '${discoveryResult.old_state}' to '${discoveryResult.new_state}'`);
-                }
-            }
-
-            // Re-throw if not handled
-            throw lifecycleError;
-        }
-
-    } catch (error) {
-        console.error('Standards Transition Error:', error);
-
-        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);