@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/core/RapportOrchestrator.js

@@ -1,632 +0,0 @@
-/**
- * Rapport Orchestrator - Multi-Agent Integration Layer
- * Integrates Rapport's pattern discovery with existing 63-agent ecosystem
- *
- * Phase 6: Multi-Agent Orchestration
- *
- * Key Integration:
- * - Leverages existing PatternHarvestingAgent, AuditorAgent, SecurityReviewerAgent, KnowledgeSynthesisAgent
- * - Creates RapportCurationWorkflow for pattern -> standard pipeline
- * - Background sync daemon for .equilateral-standards monitoring
- * - Event-driven architecture for real-time updates
- */
-
-const EventEmitter = require('events');
-const fs = require('fs').promises;
-const path = require('path');
-const { watch } = require('fs');
-
-class RapportOrchestrator extends EventEmitter {
-    constructor(config = {}) {
-        super();
-
-        this.config = {
-            rapportRoot: config.rapportRoot || process.cwd(),
-            equilateralAgentsPath: config.equilateralAgentsPath || path.join(__dirname, '../../../EquilateralAgents'),
-            standardsPath: config.standardsPath || '.equilateral-standards',
-            enableBackgroundSync: config.enableBackgroundSync !== false,
-            syncInterval: config.syncInterval || 300000, // 5 minutes
-            ...config
-        };
-
-        this.agents = new Map();
-        this.workflows = new Map();
-        this.backgroundJobs = new Map();
-        this.standardsWatcher = null;
-        this.initialized = false;
-    }
-
-    /**
-     * Initialize Rapport Orchestrator with agent system integration
-     */
-    async initialize() {
-        try {
-            console.log('[RapportOrchestrator] Initializing with multi-agent integration...');
-
-            // 1. Connect to existing EquilateralAgents system
-            await this.connectToAgentSystem();
-
-            // 2. Register Rapport-specific workflows
-            await this.registerWorkflows();
-
-            // 3. Start background sync daemon (if enabled)
-            if (this.config.enableBackgroundSync) {
-                await this.startBackgroundSync();
-            }
-
-            this.initialized = true;
-            this.emit('initialized', {
-                agents: Array.from(this.agents.keys()),
-                workflows: Array.from(this.workflows.keys()),
-                backgroundSync: this.config.enableBackgroundSync
-            });
-
-            console.log('[RapportOrchestrator] Initialization complete');
-            return { success: true, status: 'initialized' };
-
-        } catch (error) {
-            console.error('[RapportOrchestrator] Initialization failed:', error);
-            this.emit('error', { component: 'orchestrator', error });
-            throw error;
-        }
-    }
-
-    /**
-     * Connect to existing EquilateralAgents system
-     * Leverages the 63-agent infrastructure without recreating it
-     */
-    async connectToAgentSystem() {
-        try {
-            // Import core agents from EquilateralAgents (if available)
-            const agentsPath = path.join(this.config.equilateralAgentsPath, 'src/agents/specialists');
-
-            // Core agents needed for Rapport curation workflow
-            const coreAgents = [
-                'PatternHarvestingAgent',
-                'AuditorAgent',
-                'SecurityReviewerAgent',
-                'KnowledgeSynthesisAgent'
-            ];
-
-            for (const agentName of coreAgents) {
-                try {
-                    const agentPath = path.join(agentsPath, `${agentName}.js`);
-                    const AgentClass = require(agentPath);
-
-                    // Register agent (lazy instantiation)
-                    this.agents.set(agentName, {
-                        name: agentName,
-                        class: AgentClass,
-                        instance: null,
-                        status: 'registered'
-                    });
-
-                    console.log(`[RapportOrchestrator] Registered agent: ${agentName}`);
-                } catch (error) {
-                    console.warn(`[RapportOrchestrator] Could not load ${agentName}:`, error.message);
-                }
-            }
-
-            // If no agents found, use fallback mode
-            if (this.agents.size === 0) {
-                console.warn('[RapportOrchestrator] No EquilateralAgents found, using standalone mode');
-            }
-
-        } catch (error) {
-            console.warn('[RapportOrchestrator] Agent system connection failed, using standalone mode:', error.message);
-        }
-    }
-
-    /**
-     * Get or instantiate an agent (lazy loading)
-     */
-    getAgent(agentName) {
-        if (!this.agents.has(agentName)) {
-            throw new Error(`Agent ${agentName} not registered`);
-        }
-
-        const agentInfo = this.agents.get(agentName);
-
-        // Return cached instance if available
-        if (agentInfo.instance) {
-            return agentInfo.instance;
-        }
-
-        // Instantiate agent
-        const AgentClass = agentInfo.class;
-        const instance = new AgentClass({
-            projectRoot: this.config.rapportRoot
-        });
-
-        // Cache instance
-        agentInfo.instance = instance;
-        agentInfo.status = 'active';
-
-        console.log(`[RapportOrchestrator] Instantiated agent: ${agentName}`);
-        return instance;
-    }
-
-    /**
-     * Register Rapport-specific workflows
-     */
-    async registerWorkflows() {
-        // Workflow 1: Pattern Curation Pipeline
-        this.workflows.set('rapport-curate-pattern', {
-            name: 'rapport-curate-pattern',
-            description: 'Curate discovered pattern into standard',
-            steps: [
-                { agent: 'PatternHarvestingAgent', method: 'gatherEvidence', parallel: false },
-                { agent: 'AuditorAgent', method: 'validateCompliance', parallel: false },
-                { agent: 'SecurityReviewerAgent', method: 'reviewPattern', parallel: false },
-                { agent: 'KnowledgeSynthesisAgent', method: 'generateStandard', parallel: false }
-            ]
-        });
-
-        // Workflow 2: Standards Validation
-        this.workflows.set('rapport-validate-standards', {
-            name: 'rapport-validate-standards',
-            description: 'Validate code against ingested standards',
-            steps: [
-                { agent: 'PatternHarvestingAgent', method: 'detectPatterns', parallel: false },
-                { agent: 'AuditorAgent', method: 'validateStandards', parallel: false }
-            ]
-        });
-
-        // Workflow 3: Standards Sync
-        this.workflows.set('rapport-sync-standards', {
-            name: 'rapport-sync-standards',
-            description: 'Sync .equilateral-standards into Rapport',
-            steps: [
-                { agent: 'PatternHarvestingAgent', method: 'discoverStandards', parallel: false },
-                { agent: 'KnowledgeSynthesisAgent', method: 'synthesizeStandards', parallel: false }
-            ]
-        });
-
-        console.log(`[RapportOrchestrator] Registered ${this.workflows.size} workflows`);
-    }
-
-    /**
-     * Execute a workflow
-     */
-    async executeWorkflow(workflowName, params = {}) {
-        if (!this.workflows.has(workflowName)) {
-            throw new Error(`Workflow ${workflowName} not found`);
-        }
-
-        const workflow = this.workflows.get(workflowName);
-        const workflowId = `${workflowName}_${Date.now()}`;
-
-        this.emit('workflow:started', { workflowId, workflow: workflowName, params });
-
-        try {
-            const results = {
-                workflowId,
-                workflowName,
-                steps: [],
-                startedAt: new Date().toISOString(),
-                status: 'running'
-            };
-
-            // Execute workflow steps sequentially (for now)
-            for (const step of workflow.steps) {
-                const stepResult = await this.executeWorkflowStep(step, params, workflowId);
-                results.steps.push(stepResult);
-
-                // Fail workflow if critical step fails
-                if (!stepResult.success && step.required !== false) {
-                    results.status = 'failed';
-                    results.failedAt = step.agent;
-                    this.emit('workflow:failed', results);
-                    return results;
-                }
-            }
-
-            results.status = 'completed';
-            results.completedAt = new Date().toISOString();
-
-            this.emit('workflow:completed', results);
-            return results;
-
-        } catch (error) {
-            this.emit('workflow:failed', { workflowId, error: error.message });
-            throw error;
-        }
-    }
-
-    /**
-     * Execute a single workflow step
-     */
-    async executeWorkflowStep(step, params, workflowId) {
-        const { agent: agentName, method, parallel } = step;
-
-        this.emit('step:started', { workflowId, agent: agentName, method });
-
-        try {
-            // Get agent instance (lazy load if needed)
-            const agent = this.getAgent(agentName);
-
-            // Execute agent method
-            let result;
-            if (typeof agent[method] === 'function') {
-                result = await agent[method](params);
-            } else {
-                // Fallback to generic execute method
-                result = await agent.execute({ task: method, ...params });
-            }
-
-            this.emit('step:completed', { workflowId, agent: agentName, method, result });
-
-            return {
-                agent: agentName,
-                method,
-                success: true,
-                result,
-                completedAt: new Date().toISOString()
-            };
-
-        } catch (error) {
-            this.emit('step:failed', { workflowId, agent: agentName, method, error: error.message });
-
-            return {
-                agent: agentName,
-                method,
-                success: false,
-                error: error.message,
-                failedAt: new Date().toISOString()
-            };
-        }
-    }
-
-    /**
-     * Start background sync daemon for .equilateral-standards monitoring
-     */
-    async startBackgroundSync() {
-        console.log('[RapportOrchestrator] Starting background sync daemon...');
-
-        // 1. Initial sync
-        await this.syncStandards();
-
-        // 2. Set up file watcher for .equilateral-standards/
-        const standardsPath = path.join(this.config.rapportRoot, this.config.standardsPath);
-
-        try {
-            this.standardsWatcher = watch(standardsPath, { recursive: true }, async (eventType, filename) => {
-                if (filename && filename.endsWith('.md')) {
-                    console.log(`[RapportOrchestrator] Standards change detected: ${filename}`);
-                    this.emit('standards:changed', { filename, eventType });
-
-                    // Debounce sync to avoid rapid-fire updates
-                    if (this.syncDebounceTimer) {
-                        clearTimeout(this.syncDebounceTimer);
-                    }
-
-                    this.syncDebounceTimer = setTimeout(async () => {
-                        await this.syncStandards();
-                    }, 5000); // 5 second debounce
-                }
-            });
-
-            console.log('[RapportOrchestrator] File watcher active on:', standardsPath);
-        } catch (error) {
-            console.warn('[RapportOrchestrator] Could not watch standards directory:', error.message);
-        }
-
-        // 3. Set up periodic sync interval
-        this.backgroundJobs.set('standards-sync', setInterval(async () => {
-            console.log('[RapportOrchestrator] Running periodic standards sync...');
-            await this.syncStandards();
-        }, this.config.syncInterval));
-    }
-
-    /**
-     * Sync .equilateral-standards into Rapport database
-     */
-    async syncStandards() {
-        try {
-            console.log('[RapportOrchestrator] Syncing standards...');
-
-            const result = await this.executeWorkflow('rapport-sync-standards', {
-                standardsPath: path.join(this.config.rapportRoot, this.config.standardsPath)
-            });
-
-            if (result.status === 'completed') {
-                this.emit('standards:synced', {
-                    timestamp: new Date().toISOString(),
-                    result
-                });
-                console.log('[RapportOrchestrator] Standards sync completed');
-            } else {
-                console.warn('[RapportOrchestrator] Standards sync failed:', result);
-            }
-
-            return result;
-
-        } catch (error) {
-            console.error('[RapportOrchestrator] Standards sync error:', error);
-            this.emit('standards:sync-failed', { error: error.message });
-        }
-    }
-
-    /**
-     * Curate a pattern into a standard
-     * Main entry point for pattern -> standard promotion
-     */
-    async curatePattern(patternId, options = {}) {
-        console.log(`[RapportOrchestrator] Curating pattern: ${patternId}`);
-
-        try {
-            const result = await this.executeWorkflow('rapport-curate-pattern', {
-                patternId,
-                ...options
-            });
-
-            if (result.status === 'completed') {
-                this.emit('pattern:curated', {
-                    patternId,
-                    result
-                });
-            }
-
-            return result;
-
-        } catch (error) {
-            console.error('[RapportOrchestrator] Pattern curation failed:', error);
-            throw error;
-        }
-    }
-
-    /**
-     * Validate code against standards
-     */
-    async validateStandards(codeContext) {
-        console.log('[RapportOrchestrator] Validating standards...');
-
-        try {
-            const result = await this.executeWorkflow('rapport-validate-standards', {
-                codeContext
-            });
-
-            return result;
-
-        } catch (error) {
-            console.error('[RapportOrchestrator] Standards validation failed:', error);
-            throw error;
-        }
-    }
-
-    // =============================================
-    // 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
-     */
-    getStatus() {
-        return {
-            initialized: this.initialized,
-            agents: {
-                registered: this.agents.size,
-                active: Array.from(this.agents.values()).filter(a => a.status === 'active').length,
-                list: Array.from(this.agents.keys())
-            },
-            workflows: {
-                registered: this.workflows.size,
-                list: Array.from(this.workflows.keys())
-            },
-            backgroundSync: {
-                enabled: this.config.enableBackgroundSync,
-                watching: !!this.standardsWatcher,
-                jobs: Array.from(this.backgroundJobs.keys())
-            }
-        };
-    }
-
-    /**
-     * Shutdown orchestrator and cleanup
-     */
-    async shutdown() {
-        console.log('[RapportOrchestrator] Shutting down...');
-
-        // Close file watcher
-        if (this.standardsWatcher) {
-            this.standardsWatcher.close();
-        }
-
-        // Clear background jobs
-        for (const [name, job] of this.backgroundJobs) {
-            clearInterval(job);
-            console.log(`[RapportOrchestrator] Stopped background job: ${name}`);
-        }
-
-        this.backgroundJobs.clear();
-        this.agents.clear();
-        this.workflows.clear();
-
-        this.emit('shutdown');
-        console.log('[RapportOrchestrator] Shutdown complete');
-    }
-}
-
-module.exports = RapportOrchestrator;