@equilateral_ai/mindmeld 3.0.0

package/src/core/RapportOrchestrator.js

@@ -0,0 +1,446 @@
+/**
+ * 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;
+        }
+    }
+
+    /**
+     * 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;