@equilateral_ai/mindmeld 3.2.0 → 3.3.0

package/src/core/DeprecationScheduler.js

@@ -0,0 +1,183 @@
+/**
+ * DeprecationScheduler.js - Scheduled Deprecation Management
+ *
+ * Handles the scheduled deprecation workflow for standards:
+ *   1. scheduleDeprecation - Marks a standard as deprecated with a grace period
+ *   2. processScheduledDeprecations - Deletes standards past their grace period
+ *   3. cancelDeprecation - Restores a deprecated standard back to active
+ *
+ * Called by scheduled Lambda / EventBridge for automatic cleanup,
+ * or directly by handlers for user-initiated actions.
+ */
+
+const { executeQuery } = require('../handlers/helpers/dbOperations');
+const { StandardLifecycle, STATES } = require('./StandardLifecycle');
+
+class DeprecationScheduler {
+    constructor(config = {}) {
+        this.config = {
+            defaultGracePeriodDays: config.defaultGracePeriodDays || 30,
+            ...config
+        };
+
+        this.lifecycle = config.lifecycle || new StandardLifecycle();
+    }
+
+    /**
+     * Schedule a standard for deprecation with a grace period
+     *
+     * Sets deprecated_at and deprecation_reason on the standard,
+     * transitions state to 'deprecated', and records in audit trail.
+     *
+     * @param {string} standardId - The standard identifier
+     * @param {number} gracePeriodDays - Days before automatic deletion
+     * @param {string} userId - Email of the user scheduling deprecation
+     * @param {string} reason - Reason for deprecation
+     * @returns {Promise<Object>} Deprecation result
+     */
+    async scheduleDeprecation(standardId, gracePeriodDays, userId, reason) {
+        const days = gracePeriodDays || this.config.defaultGracePeriodDays;
+
+        // Execute the lifecycle transition to deprecated
+        const transitionResult = await this.lifecycle.transition(
+            standardId,
+            'deprecate',
+            userId,
+            reason
+        );
+
+        // Set deprecation metadata on the standard
+        const deprecatedAt = new Date();
+        const deletionDate = new Date(deprecatedAt.getTime() + (days * 24 * 60 * 60 * 1000));
+
+        await executeQuery(`
+            UPDATE rapport.patterns
+            SET
+                deprecated_at = $2,
+                deprecation_reason = $3
+            WHERE pattern_id = $1
+        `, [standardId, deprecatedAt, reason]);
+
+        console.log(
+            `[DeprecationScheduler] Scheduled ${standardId} for deletion on ${deletionDate.toISOString()} ` +
+            `(${days} day grace period)`
+        );
+
+        return {
+            standard_id: standardId,
+            old_state: transitionResult.old_state,
+            new_state: transitionResult.new_state,
+            deprecated_at: deprecatedAt.toISOString(),
+            grace_period_days: days,
+            scheduled_deletion: deletionDate.toISOString(),
+            reason: reason,
+            audit_entry: transitionResult.audit_entry
+        };
+    }
+
+    /**
+     * Process all standards that have passed their grace period
+     *
+     * Finds deprecated standards where deprecated_at + grace period < now,
+     * and transitions them to 'deleted'.
+     *
+     * Intended to be called by a scheduled Lambda / EventBridge rule.
+     *
+     * @returns {Promise<Object>} Processing results
+     */
+    async processScheduledDeprecations() {
+        const gracePeriodDays = this.config.defaultGracePeriodDays;
+
+        // Find standards past their grace period
+        const result = await executeQuery(`
+            SELECT pattern_id, deprecated_at, deprecation_reason
+            FROM rapport.patterns
+            WHERE lifecycle_state = $1
+                AND deprecated_at IS NOT NULL
+                AND deprecated_at + ($2 || ' days')::INTERVAL < NOW()
+        `, [STATES.DEPRECATED, gracePeriodDays]);
+
+        const standards = result.rows;
+
+        console.log(`[DeprecationScheduler] Found ${standards.length} standards past grace period`);
+
+        const processed = [];
+        const errors = [];
+
+        for (const standard of standards) {
+            try {
+                const transitionResult = await this.lifecycle.transition(
+                    standard.pattern_id,
+                    'delete',
+                    'system@mindmeld.dev',
+                    `Automatic deletion after ${gracePeriodDays}-day grace period. ` +
+                    `Original reason: ${standard.deprecation_reason || 'Not specified'}`
+                );
+
+                processed.push({
+                    standard_id: standard.pattern_id,
+                    deprecated_at: standard.deprecated_at,
+                    deleted_at: new Date().toISOString()
+                });
+
+                console.log(`[DeprecationScheduler] Deleted ${standard.pattern_id} (deprecated ${standard.deprecated_at})`);
+            } catch (error) {
+                console.error(`[DeprecationScheduler] Failed to delete ${standard.pattern_id}:`, error.message);
+                errors.push({
+                    standard_id: standard.pattern_id,
+                    error: error.message
+                });
+            }
+        }
+
+        return {
+            total_found: standards.length,
+            processed: processed.length,
+            errors: errors.length,
+            deleted: processed,
+            failed: errors
+        };
+    }
+
+    /**
+     * Cancel a scheduled deprecation and restore to active
+     *
+     * Transitions the standard back to 'active', clears deprecated_at
+     * and deprecation_reason, and records in audit trail.
+     *
+     * @param {string} standardId - The standard identifier
+     * @param {string} userId - Email of the user cancelling deprecation
+     * @param {string} reason - Reason for cancelling deprecation
+     * @returns {Promise<Object>} Cancellation result
+     */
+    async cancelDeprecation(standardId, userId, reason) {
+        // Execute the lifecycle transition back to active
+        const transitionResult = await this.lifecycle.transition(
+            standardId,
+            'cancel_deprecation',
+            userId,
+            reason
+        );
+
+        // Clear deprecation metadata
+        await executeQuery(`
+            UPDATE rapport.patterns
+            SET
+                deprecated_at = NULL,
+                deprecation_reason = NULL
+            WHERE pattern_id = $1
+        `, [standardId]);
+
+        console.log(`[DeprecationScheduler] Cancelled deprecation for ${standardId} by ${userId}`);
+
+        return {
+            standard_id: standardId,
+            old_state: transitionResult.old_state,
+            new_state: transitionResult.new_state,
+            reason: reason,
+            audit_entry: transitionResult.audit_entry
+        };
+    }
+}
+
+module.exports = { DeprecationScheduler };

package/src/core/LLMPatternDetector.js

@@ -503,6 +503,224 @@ Respond with a JSON object: { "summary": "...", "keyDecisions": ["..."], "newPat
     clearCache() {
         this.cache.clear();
     }
+
+    /**
+     * Analyze repository code samples for patterns (used in GitHub discovery)
+     * Returns patterns in YAML standards format with action types
+     *
+     * @param {string} codeContext - Combined code samples with file paths
+     * @param {Object} context - Additional context (tech stack, frameworks)
+     * @returns {Promise<Object>} Patterns in YAML-compatible format
+     */
+    async analyzeRepoPatterns(codeContext, context = {}) {
+        if (!this.isAvailable()) {
+            return this.fallbackRepoAnalysis(codeContext, context);
+        }
+
+        const systemPrompt = this.buildRepoAnalysisSystemPrompt(context);
+        const userPrompt = this.buildRepoAnalysisUserPrompt(codeContext, context);
+
+        try {
+            const requestBody = {
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: this.config.maxTokens,
+                system: systemPrompt,
+                messages: [{ role: 'user', content: userPrompt }]
+            };
+
+            const command = new InvokeModelCommand({
+                modelId: this.config.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(requestBody)
+            });
+
+            const response = await this.client.send(command);
+            const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+
+            return this.parseRepoAnalysisResponse(responseBody.content?.[0]?.text || '');
+        } catch (error) {
+            console.error('[LLMPatternDetector] Repo analysis error:', error.message);
+            return this.fallbackRepoAnalysis(codeContext, context);
+        }
+    }
+
+    /**
+     * Build system prompt for repository pattern analysis
+     */
+    buildRepoAnalysisSystemPrompt(context) {
+        const techStack = context.techStack?.join(', ') || 'Unknown';
+        const frameworks = context.frameworks?.join(', ') || 'Unknown';
+
+        return `You are an expert code analyst for MindMeld, a standards and pattern management platform.
+
+Your task is to analyze code samples from a repository and extract coding patterns, conventions, and potential issues in a format compatible with our YAML standards schema.
+
+Context about this repository:
+- Detected tech stack: ${techStack}
+- Detected frameworks: ${frameworks}
+
+Extract patterns using these action types:
+- ALWAYS: Rules that must always be followed (critical patterns)
+- NEVER: Anti-patterns that must be avoided
+- USE: Recommended tools, libraries, or approaches
+- PREFER: Better alternatives when possible
+- AVOID: Patterns to avoid when better alternatives exist
+
+Respond ONLY with valid JSON in this exact format:
+{
+  "patterns": [
+    {
+      "element": "Short pattern name",
+      "action": "ALWAYS|NEVER|USE|PREFER|AVOID",
+      "rule": "Clear description of the rule",
+      "category": "api|database|security|performance|architecture|testing|error-handling",
+      "confidence": 0.95,
+      "evidence": "Code snippet or reference showing this pattern"
+    }
+  ],
+  "anti_patterns": [
+    {
+      "pattern": "Description of the anti-pattern",
+      "risk": "Why this is problematic",
+      "fix": "How to fix it"
+    }
+  ],
+  "recommendations": [
+    {
+      "category": "standards-category-name",
+      "reason": "Why this standards category is relevant",
+      "priority": "high|medium|low"
+    }
+  ],
+  "tech_summary": {
+    "primary_language": "JavaScript/TypeScript/Python/etc",
+    "architecture": "serverless|monolith|microservices|frontend-spa",
+    "key_patterns": ["pattern1", "pattern2"]
+  }
+}`;
+    }
+
+    /**
+     * Build user prompt for repository analysis
+     */
+    buildRepoAnalysisUserPrompt(codeContext, context) {
+        const repoName = context.repoName || 'Unknown repository';
+
+        return `Analyze these code samples from "${repoName}" and extract patterns:
+
+${codeContext}
+
+---
+
+Focus on identifying:
+1. Database connection patterns (pooling vs single client, connection reuse)
+2. Error handling approaches (try/catch, wrapper functions, error responses)
+3. API design patterns (response formats, authentication, CORS)
+4. Security patterns (input validation, secrets management, authorization)
+5. Code organization (helper functions, modular structure)
+6. Testing patterns (test frameworks, mocking approaches)
+
+Extract actionable patterns that could become team standards.
+Respond with JSON only.`;
+    }
+
+    /**
+     * Parse repository analysis response
+     */
+    parseRepoAnalysisResponse(content) {
+        try {
+            let jsonStr = content;
+            const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
+            if (jsonMatch) {
+                jsonStr = jsonMatch[1];
+            }
+
+            const parsed = JSON.parse(jsonStr.trim());
+
+            return {
+                success: true,
+                source: 'llm_repo_analysis',
+                model: this.config.model,
+                timestamp: new Date().toISOString(),
+                patterns: parsed.patterns || [],
+                anti_patterns: parsed.anti_patterns || [],
+                recommendations: parsed.recommendations || [],
+                tech_summary: parsed.tech_summary || {}
+            };
+        } catch (error) {
+            console.error('[LLMPatternDetector] Failed to parse repo analysis:', error.message);
+            return {
+                success: false,
+                source: 'llm_repo_analysis',
+                error: 'Failed to parse LLM response',
+                rawContent: content.substring(0, 500),
+                patterns: [],
+                anti_patterns: [],
+                recommendations: []
+            };
+        }
+    }
+
+    /**
+     * Fallback analysis for repository patterns when LLM unavailable
+     */
+    fallbackRepoAnalysis(codeContext, context) {
+        const patterns = [];
+        const antiPatterns = [];
+
+        // Basic regex detection for common patterns
+        if (/wrapHandler/.test(codeContext)) {
+            patterns.push({
+                element: 'Lambda Handler Wrapper',
+                action: 'USE',
+                rule: 'Use wrapHandler for consistent Lambda error handling',
+                category: 'api',
+                confidence: 0.8,
+                evidence: 'Found wrapHandler usage'
+            });
+        }
+
+        if (/executeQuery/.test(codeContext)) {
+            patterns.push({
+                element: 'Database Query Helper',
+                action: 'USE',
+                rule: 'Use executeQuery for standardized database operations',
+                category: 'database',
+                confidence: 0.8,
+                evidence: 'Found executeQuery usage'
+            });
+        }
+
+        if (/new Pool\(|createPool/.test(codeContext)) {
+            antiPatterns.push({
+                pattern: 'Connection pool in Lambda',
+                risk: 'Connection pools are wasteful in Lambda - connections persist across invocations',
+                fix: 'Use a cached single client instead of a connection pool'
+            });
+        }
+
+        if (/try\s*\{[\s\S]*catch\s*\(/.test(codeContext)) {
+            patterns.push({
+                element: 'Try-Catch Error Handling',
+                action: 'ALWAYS',
+                rule: 'Wrap async operations in try-catch blocks',
+                category: 'error-handling',
+                confidence: 0.7,
+                evidence: 'Found try-catch blocks'
+            });
+        }
+
+        return {
+            success: true,
+            source: 'fallback_repo_analysis',
+            timestamp: new Date().toISOString(),
+            patterns,
+            anti_patterns: antiPatterns,
+            recommendations: [],
+            tech_summary: { primary_language: 'Unknown', architecture: 'Unknown', key_patterns: [] }
+        };
+    }
 }
 
 module.exports = { LLMPatternDetector };

package/src/core/RapportOrchestrator.js

@@ -394,6 +394,192 @@ class RapportOrchestrator extends EventEmitter {
         }
     }
 
+    // =============================================
+    // Roadmap Team Dispatch (TeamOrchestrator)
+    // =============================================
+
+    /**
+     * Roadmap team templates — each team gets isolated agents and phased workflow
+     */
+    getRoadmapTeams() {
+        return {
+            'standards-parsers': {
+                description: 'Standards parsers for onboarding upload (ADR, ESLint, Cursor rules)',
+                agents: ['CodeGenerationAgent', 'PatternHarvestingAgent'],
+                phases: ['ADR_PARSER', 'ESLINT_PARSER', 'CURSOR_RULES_PARSER', 'CROSS_REFERENCE']
+            },
+            'frontend-curation': {
+                description: 'Frontend curation dashboard (review queue, rejection flow, conflict resolution)',
+                agents: ['UIUXSpecialistAgent', 'CodeGenerationAgent'],
+                phases: ['REVIEW_QUEUE', 'REJECTION_FLOW', 'CONFLICT_RESOLUTION', 'STANDARD_EDITOR']
+            },
+            'standard-lifecycle': {
+                description: 'Standard lifecycle state machine, audit trail, deprecation',
+                agents: ['DatabaseAgent', 'AuditorAgent'],
+                phases: ['STATE_MACHINE', 'AUDIT_TRAIL_TABLE', 'DEPRECATION_SCHEDULER']
+            },
+            'weekly-splash-cli': {
+                description: 'Weekly splash screen, activity summary, /mm slash commands',
+                agents: ['CodeGenerationAgent', 'KnowledgeSynthesisAgent'],
+                phases: ['SPLASH_SCREEN', 'ACTIVITY_SUMMARY', 'SLASH_COMMANDS']
+            },
+            'developer-insights': {
+                description: 'Enterprise developer insights (quality scoring, trends, coaching)',
+                agents: ['BusinessIntelligenceAgent', 'DataGovernanceAgent'],
+                phases: ['QUALITY_SCORING', 'TEAM_TRENDS', 'COACHING_ENGINE']
+            }
+        };
+    }
+
+    /**
+     * Dispatch all roadmap teams in parallel
+     * Each team runs with isolated context, dedicated agents, phased workflow
+     *
+     * @param {Object} options - Dispatch options
+     * @param {string} options.team - Dispatch a single team by name (optional)
+     * @returns {Promise<Object>} Results from all teams
+     */
+    async dispatchRoadmap(options = {}) {
+        const allTeams = this.getRoadmapTeams();
+        const teamsToRun = options.team
+            ? { [options.team]: allTeams[options.team] }
+            : allTeams;
+
+        if (options.team && !allTeams[options.team]) {
+            throw new Error(`Unknown team: ${options.team}. Available: ${Object.keys(allTeams).join(', ')}`);
+        }
+
+        console.log(`[RapportOrchestrator] Dispatching ${Object.keys(teamsToRun).length} roadmap teams in parallel...`);
+        this.emit('roadmap:started', { teams: Object.keys(teamsToRun), startedAt: new Date().toISOString() });
+
+        // Connect to extended agent set for roadmap work
+        await this.connectRoadmapAgents(teamsToRun);
+
+        // Dispatch all teams in parallel
+        const teamPromises = Object.entries(teamsToRun).map(([teamName, template]) =>
+            this.dispatchTeam(teamName, template, options)
+                .then(result => ({ team: teamName, status: 'fulfilled', result }))
+                .catch(error => ({ team: teamName, status: 'rejected', error: error.message }))
+        );
+
+        const results = await Promise.all(teamPromises);
+
+        const summary = {
+            total: results.length,
+            fulfilled: results.filter(r => r.status === 'fulfilled').length,
+            rejected: results.filter(r => r.status === 'rejected').length,
+            teams: results,
+            completedAt: new Date().toISOString()
+        };
+
+        console.log(`[RapportOrchestrator] Roadmap dispatch complete: ${summary.fulfilled}/${summary.total} teams succeeded`);
+        this.emit('roadmap:completed', summary);
+
+        return summary;
+    }
+
+    /**
+     * Dispatch a single team with isolated context
+     */
+    async dispatchTeam(teamName, template, options = {}) {
+        const teamId = `team_${teamName}_${Date.now()}`;
+        console.log(`[RapportOrchestrator] Dispatching team: ${teamName} (${teamId})`);
+        this.emit('team:started', { teamId, teamName, phases: template.phases });
+
+        const teamContext = {
+            teamId,
+            teamName,
+            startedAt: new Date().toISOString(),
+            projectRoot: this.config.rapportRoot,
+            standardsPath: path.join(this.config.rapportRoot, this.config.standardsPath),
+            phaseResults: {}
+        };
+
+        // Execute phases sequentially within team
+        for (const phase of template.phases) {
+            console.log(`  [${teamName}] Phase: ${phase}`);
+            this.emit('phase:started', { teamId, teamName, phase });
+
+            try {
+                const phaseResult = await this.executeTeamPhase(teamName, phase, template.agents, teamContext);
+                teamContext.phaseResults[phase] = { success: true, result: phaseResult };
+                this.emit('phase:completed', { teamId, teamName, phase, result: phaseResult });
+            } catch (error) {
+                console.error(`  [${teamName}] Phase ${phase} failed:`, error.message);
+                teamContext.phaseResults[phase] = { success: false, error: error.message };
+                this.emit('phase:failed', { teamId, teamName, phase, error: error.message });
+            }
+        }
+
+        teamContext.completedAt = new Date().toISOString();
+        this.emit('team:completed', { teamId, teamName, context: teamContext });
+
+        return teamContext;
+    }
+
+    /**
+     * Execute a single phase within a team, using assigned agents
+     */
+    async executeTeamPhase(teamName, phase, agentNames, teamContext) {
+        // Try each assigned agent for this phase
+        for (const agentName of agentNames) {
+            if (!this.agents.has(agentName)) continue;
+
+            try {
+                const agent = this.getAgent(agentName);
+
+                // Try phase-specific method first, then generic execute
+                const methodName = `execute${phase.replace(/_/g, '')}`;
+                if (typeof agent[methodName] === 'function') {
+                    return await agent[methodName](teamContext);
+                } else if (typeof agent.execute === 'function') {
+                    return await agent.execute({
+                        task: phase,
+                        team: teamName,
+                        context: teamContext
+                    });
+                }
+            } catch (error) {
+                console.warn(`  [${teamName}] Agent ${agentName} failed on ${phase}:`, error.message);
+            }
+        }
+
+        // Fallback: emit phase for external handling
+        return { status: 'pending_implementation', phase, team: teamName };
+    }
+
+    /**
+     * Connect additional agents needed for roadmap work
+     */
+    async connectRoadmapAgents(teams) {
+        const agentsPath = path.join(this.config.equilateralAgentsPath, 'src/agents/specialists');
+        const neededAgents = new Set();
+
+        for (const template of Object.values(teams)) {
+            for (const agentName of template.agents) {
+                if (!this.agents.has(agentName)) {
+                    neededAgents.add(agentName);
+                }
+            }
+        }
+
+        for (const agentName of neededAgents) {
+            try {
+                const agentPath = path.join(agentsPath, `${agentName}.js`);
+                const AgentClass = require(agentPath);
+                this.agents.set(agentName, {
+                    name: agentName,
+                    class: AgentClass,
+                    instance: null,
+                    status: 'registered'
+                });
+                console.log(`[RapportOrchestrator] Registered roadmap agent: ${agentName}`);
+            } catch (error) {
+                console.warn(`[RapportOrchestrator] Could not load roadmap agent ${agentName}:`, error.message);
+            }
+        }
+    }
+
     /**
      * Get orchestrator status
      */

package/src/core/RelevanceDetector.js

@@ -15,6 +15,7 @@
 const fs = require('fs').promises;
 const path = require('path');
 const { executeQuery } = require('../handlers/helpers/dbOperations');
+const { StandardsIngestion } = require('./StandardsIngestion');
 
 class RelevanceDetector {
     constructor(options = {}) {
@@ -459,8 +460,37 @@ class RelevanceDetector {
             const result = await executeQuery(query, [categories]);
             return result.rows;
         } catch (error) {
-            // If table doesn't exist (Phase 1 not complete), return empty array
-            console.warn('Standards patterns table not found. Assuming Phase 1 not complete.');
+            // Database unavailable — fall back to reading YAML files directly
+            console.warn('Standards patterns table not found. Falling back to file-based standards.');
+            return this.loadStandardsFromFiles(categories);
+        }
+    }
+
+    /**
+     * File-system fallback: load and filter standards from YAML files
+     * Used when database is unavailable (local dev, first run, DB down)
+     */
+    async loadStandardsFromFiles(categories) {
+        try {
+            const standardsPath = path.isAbsolute(this.standardsPath)
+                ? this.standardsPath
+                : path.join(this.workingDirectory, this.standardsPath);
+
+            const ingestion = new StandardsIngestion({ standardsPath });
+            const allPatterns = await ingestion.parseAllStandards();
+
+            // Filter by requested categories and enforced/validated maturity
+            const validMaturity = ['enforced', 'validated', 'recommended'];
+            const categorySet = new Set(categories);
+
+            return allPatterns
+                .filter(p => categorySet.has(p.category) && validMaturity.includes(p.maturity))
+                .sort((a, b) => {
+                    const maturityOrder = { enforced: 1, validated: 2, recommended: 3 };
+                    return (maturityOrder[a.maturity] || 3) - (maturityOrder[b.maturity] || 3);
+                });
+        } catch (fallbackError) {
+            console.error('File-based standards fallback failed:', fallbackError.message);
             return [];
         }
     }