claude-flow-novice 1.0.0

package/dist/src/neural/integration.js

@@ -0,0 +1,590 @@
+/**
+ * Neural Domain Mapper Integration Module
+ *
+ * Provides integration between NeuralDomainMapper and the existing
+ * Claude Flow neural hooks system, enabling seamless domain analysis
+ * and optimization within the broader orchestration framework.
+ *
+ * @author Claude Flow Neural Team
+ * @version 2.0.0
+ */ import { EventEmitter } from 'events';
+import { NeuralDomainMapper } from './NeuralDomainMapper.js';
+import { agenticHookManager } from '../services/agentic-flow-hooks/hook-manager.js';
+/**
+ * Neural Domain Mapper Integration Class
+ *
+ * This class provides seamless integration between the NeuralDomainMapper
+ * and the existing Claude Flow neural hooks system. It automatically
+ * analyzes domain structures, generates optimization suggestions, and
+ * learns from domain relationship patterns.
+ */ export class NeuralDomainMapperIntegration extends EventEmitter {
+    domainMapper;
+    config;
+    analysisHistory = [];
+    activeAnalysis = new Map();
+    learningPatterns = [];
+    isInitialized = false;
+    constructor(domainMapper, config = {}){
+        super();
+        this.config = {
+            enableAutoAnalysis: true,
+            enableOptimizationSuggestions: true,
+            enableContinuousLearning: true,
+            confidenceThreshold: 0.7,
+            analysisInterval: 30000,
+            maxOptimizationProposals: 10,
+            ...config
+        };
+        this.domainMapper = domainMapper || new NeuralDomainMapper();
+        // Set up event listeners
+        this.setupEventListeners();
+    }
+    /**
+   * Initialize the integration system
+   */ async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        // Register neural hooks for domain analysis
+        this.registerDomainAnalysisHooks();
+        // Set up periodic analysis if enabled
+        if (this.config.enableAutoAnalysis) {
+            this.setupPeriodicAnalysis();
+        }
+        this.isInitialized = true;
+        this.emit('integration-initialized');
+    }
+    /**
+   * Analyze domains and integrate with neural hooks system
+   */ async analyzeDomains(domains, context1) {
+        const correlationId = context1.correlationId;
+        // Check if analysis is already in progress for this correlation ID
+        if (this.activeAnalysis.has(correlationId)) {
+            return await this.activeAnalysis.get(correlationId);
+        }
+        const analysisPromise = this.performDomainAnalysis(domains, context1);
+        this.activeAnalysis.set(correlationId, analysisPromise);
+        try {
+            const result = await analysisPromise;
+            // Store analysis history
+            this.analysisHistory.push(result);
+            // Keep only last 100 analyses
+            if (this.analysisHistory.length > 100) {
+                this.analysisHistory.shift();
+            }
+            // Generate side effects for the hooks system
+            await this.generateHookSideEffects(result, context1);
+            // Learn from the analysis if continuous learning is enabled
+            if (this.config.enableContinuousLearning) {
+                await this.learnFromAnalysis(result, context1);
+            }
+            this.emit('domain-analysis-completed', result);
+            return result;
+        } finally{
+            this.activeAnalysis.delete(correlationId);
+        }
+    }
+    /**
+   * Train the domain mapper on historical patterns
+   */ async trainOnPatterns(patterns, context1) {
+        // Convert patterns to training data
+        const trainingData = this.convertPatternsToTrainingData(patterns);
+        if (trainingData.inputs.length === 0) {
+            return {
+                trainingAccuracy: 0,
+                patternsProcessed: 0,
+                newInsights: [
+                    'No suitable training data found in patterns'
+                ]
+            };
+        }
+        // Train the domain mapper
+        const trainingResult = await this.domainMapper.train(trainingData);
+        // Analyze what was learned
+        const newInsights = this.extractTrainingInsights(trainingResult, patterns);
+        // Store learning patterns for future reference
+        this.learningPatterns.push(...patterns.slice(-50)); // Keep last 50 patterns
+        const result = {
+            trainingAccuracy: trainingResult.finalAccuracy,
+            patternsProcessed: patterns.length,
+            newInsights
+        };
+        this.emit('training-completed', result);
+        return result;
+    }
+    /**
+   * Get optimization suggestions based on current domain state
+   */ async getOptimizationSuggestions(context1) {
+        // Get current optimization suggestions
+        const optimization = await this.domainMapper.provideBoundaryOptimization();
+        // Calculate applicability based on context
+        const applicability = this.calculateOptimizationApplicability(optimization, context1);
+        // Generate prioritized actions
+        const prioritizedActions = this.generatePrioritizedActions(optimization);
+        const result = {
+            suggestions: optimization,
+            applicability,
+            prioritizedActions
+        };
+        this.emit('optimization-suggestions-generated', result);
+        return result;
+    }
+    /**
+   * Predict domain relationship outcomes
+   */ async predictDomainRelationships(proposedChanges, context1) {
+        // Create prediction input from proposed changes
+        const predictionInput = this.createPredictionInput(proposedChanges);
+        // Make predictions
+        const predictions = await Promise.all(predictionInput.map((input)=>this.domainMapper.predict(input)));
+        // Assess risks
+        const riskAssessment = this.assessChangeRisks(proposedChanges, predictions);
+        // Generate recommendations
+        const recommendations = this.generateChangeRecommendations(proposedChanges, predictions, riskAssessment);
+        const result = {
+            predictions,
+            riskAssessment,
+            recommendations
+        };
+        this.emit('domain-predictions-generated', result);
+        return result;
+    }
+    /**
+   * Get integration statistics
+   */ getIntegrationStats() {
+        const totalAnalyses = this.analysisHistory.length;
+        const avgTime = totalAnalyses > 0 ? this.analysisHistory.reduce((sum, a)=>sum + a.metrics.analysisTime, 0) / totalAnalyses : 0;
+        const optimizationsSuggested = this.analysisHistory.reduce((sum, a)=>sum + a.optimization.proposals.length, 0);
+        const accuracyTrend = this.analysisHistory.slice(-10).map((a)=>a.cohesion.overallScore);
+        return {
+            analysesPerformed: totalAnalyses,
+            averageAnalysisTime: avgTime,
+            patternsLearned: this.learningPatterns.length,
+            optimizationsSuggested,
+            accuracyTrend,
+            lastAnalysis: totalAnalyses > 0 ? this.analysisHistory[totalAnalyses - 1].timestamp : 0
+        };
+    }
+    // ===== Private Methods =====
+    setupEventListeners() {
+        this.domainMapper.on('graph-updated', (graph)=>{
+            this.emit('graph-updated', graph);
+        });
+        this.domainMapper.on('cohesion-calculated', (analysis)=>{
+            this.emit('cohesion-calculated', analysis);
+        });
+        this.domainMapper.on('dependencies-analyzed', (analysis)=>{
+            this.emit('dependencies-analyzed', analysis);
+        });
+        this.domainMapper.on('optimization-generated', (optimization)=>{
+            this.emit('optimization-generated', optimization);
+        });
+        this.domainMapper.on('training-completed', (result)=>{
+            this.emit('mapper-training-completed', result);
+        });
+    }
+    registerDomainAnalysisHooks() {
+        // Register hook for neural pattern detection
+        agenticHookManager.register({
+            id: 'domain-mapper-pattern-analysis',
+            type: 'neural-pattern-detected',
+            priority: 80,
+            handler: async (payload, context1)=>{
+                if (!this.config.enableAutoAnalysis || !payload.patterns?.length) {
+                    return {
+                        continue: true
+                    };
+                }
+                // Check if patterns are domain-related
+                const domainPatterns = payload.patterns.filter((p)=>this.isDomainRelatedPattern(p));
+                if (domainPatterns.length === 0) {
+                    return {
+                        continue: true
+                    };
+                }
+                const sideEffects = [];
+                // Trigger domain analysis based on patterns
+                try {
+                    const domainGraph = await this.extractDomainGraphFromPatterns(domainPatterns);
+                    if (domainGraph) {
+                        const analysisResult = await this.analyzeDomains(domainGraph, context1);
+                        // Generate suggestions if confidence is high enough
+                        if (analysisResult.optimization.optimizationScore >= this.config.confidenceThreshold) {
+                            sideEffects.push({
+                                type: 'notification',
+                                action: 'emit',
+                                data: {
+                                    event: 'domain:optimization-suggested',
+                                    data: analysisResult.optimization
+                                }
+                            });
+                        }
+                        // Store analysis results
+                        sideEffects.push({
+                            type: 'memory',
+                            action: 'store',
+                            data: {
+                                key: `domain:analysis:${context1.correlationId}`,
+                                value: analysisResult,
+                                ttl: 3600
+                            }
+                        });
+                    }
+                } catch (error) {
+                    sideEffects.push({
+                        type: 'log',
+                        action: 'write',
+                        data: {
+                            level: 'error',
+                            message: 'Domain analysis failed',
+                            error: error.message
+                        }
+                    });
+                }
+                return {
+                    continue: true,
+                    sideEffects
+                };
+            }
+        });
+        // Register hook for neural training completion
+        agenticHookManager.register({
+            id: 'domain-mapper-training-integration',
+            type: 'post-neural-train',
+            priority: 90,
+            handler: async (payload, context1)=>{
+                if (!this.config.enableContinuousLearning) {
+                    return {
+                        continue: true
+                    };
+                }
+                // Extract domain-relevant training data
+                if (payload.trainingData) {
+                    const domainTrainingData = this.extractDomainTrainingData(payload.trainingData);
+                    if (domainTrainingData.inputs.length > 0) {
+                        // Retrain domain mapper with new data
+                        try {
+                            await this.domainMapper.train(domainTrainingData);
+                            return {
+                                continue: true,
+                                sideEffects: [
+                                    {
+                                        type: 'log',
+                                        action: 'write',
+                                        data: {
+                                            level: 'info',
+                                            message: 'Domain mapper updated with new training data',
+                                            dataSize: domainTrainingData.inputs.length
+                                        }
+                                    }
+                                ]
+                            };
+                        } catch (error) {
+                            return {
+                                continue: true,
+                                sideEffects: [
+                                    {
+                                        type: 'log',
+                                        action: 'write',
+                                        data: {
+                                            level: 'warning',
+                                            message: 'Failed to update domain mapper',
+                                            error: error.message
+                                        }
+                                    }
+                                ]
+                            };
+                        }
+                    }
+                }
+                return {
+                    continue: true
+                };
+            }
+        });
+    }
+    setupPeriodicAnalysis() {
+        setInterval(async ()=>{
+            try {
+                // Check if there are recent patterns to analyze
+                const recentPatterns = context.neural.patterns.getByType('behavior').filter((p)=>Date.now() - (p.context.timestamp || 0) < this.config.analysisInterval * 2);
+                if (recentPatterns.length > 0) {
+                    const mockContext = {
+                        sessionId: 'periodic-analysis',
+                        timestamp: Date.now(),
+                        correlationId: `periodic-${Date.now()}`,
+                        metadata: {
+                            source: 'periodic-analysis'
+                        },
+                        memory: {
+                            namespace: 'domain-analysis',
+                            provider: 'default',
+                            cache: new Map()
+                        },
+                        neural: {
+                            modelId: 'domain-mapper',
+                            patterns: context.neural.patterns,
+                            training: context.neural.training
+                        },
+                        performance: {
+                            metrics: new Map(),
+                            bottlenecks: [],
+                            optimizations: []
+                        }
+                    };
+                    // Perform periodic analysis
+                    await this.trainOnPatterns(recentPatterns, mockContext);
+                }
+            } catch (error) {
+                this.emit('error', {
+                    type: 'periodic-analysis',
+                    error
+                });
+            }
+        }, this.config.analysisInterval);
+    }
+    async performDomainAnalysis(domains, context1) {
+        const startTime = Date.now();
+        // Perform comprehensive domain analysis
+        const analysis = await this.domainMapper.analyzeDomains(domains);
+        // Extract patterns from analysis results
+        const patterns = this.extractPatternsFromAnalysis(analysis, context1);
+        const analysisTime = Date.now() - startTime;
+        return {
+            timestamp: Date.now(),
+            correlationId: context1.correlationId,
+            graph: domains,
+            cohesion: analysis.cohesion,
+            dependencies: analysis.dependencies,
+            optimization: analysis.optimization,
+            patterns,
+            metrics: {
+                analysisTime,
+                nodesAnalyzed: domains.nodes.size,
+                edgesAnalyzed: domains.edges.size,
+                patternsDetected: patterns.length
+            }
+        };
+    }
+    async generateHookSideEffects(result, context1) {
+        const sideEffects = [];
+        // Generate optimization notifications if applicable
+        if (result.optimization.optimizationScore >= this.config.confidenceThreshold) {
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'domain:optimization-available',
+                    data: {
+                        score: result.optimization.optimizationScore,
+                        priority: result.optimization.priority,
+                        proposalCount: result.optimization.proposals.length
+                    }
+                }
+            });
+        }
+        // Store detected patterns
+        for (const pattern of result.patterns){
+            sideEffects.push({
+                type: 'neural',
+                action: 'store-pattern',
+                data: {
+                    pattern
+                }
+            });
+        }
+        // Store performance metrics
+        sideEffects.push({
+            type: 'metric',
+            action: 'update',
+            data: {
+                name: 'domain.analysis.time',
+                value: result.metrics.analysisTime
+            }
+        });
+        sideEffects.push({
+            type: 'metric',
+            action: 'update',
+            data: {
+                name: 'domain.cohesion.score',
+                value: result.cohesion.overallScore
+            }
+        });
+        // Execute side effects through the hook system
+        for (const effect of sideEffects){
+            try {
+                await this.executeSideEffect(effect, context1);
+            } catch (error) {
+                this.emit('error', {
+                    type: 'side-effect',
+                    effect,
+                    error
+                });
+            }
+        }
+    }
+    async learnFromAnalysis(result, context1) {
+        // Convert analysis results to training data
+        const learningData = this.convertAnalysisToTrainingData(result);
+        if (learningData.inputs.length > 0) {
+            try {
+                await this.domainMapper.train(learningData);
+                this.emit('continuous-learning-completed', {
+                    dataSize: learningData.inputs.length,
+                    correlationId: context1.correlationId
+                });
+            } catch (error) {
+                this.emit('error', {
+                    type: 'continuous-learning',
+                    error
+                });
+            }
+        }
+    }
+    convertPatternsToTrainingData(patterns) {
+        const inputs = [];
+        const outputs = [];
+        const labels = [];
+        for (const pattern of patterns){
+            if (this.isDomainRelatedPattern(pattern)) {
+                // Extract features from pattern context
+                const features = this.extractFeaturesFromPattern(pattern);
+                if (features.length > 0) {
+                    inputs.push({
+                        features
+                    });
+                    // Create target based on pattern type and confidence
+                    const target = this.createTargetFromPattern(pattern);
+                    outputs.push(target);
+                    labels.push(pattern.type);
+                }
+            }
+        }
+        return {
+            inputs,
+            outputs,
+            labels,
+            batchSize: Math.min(32, inputs.length),
+            epochs: Math.max(1, Math.min(10, inputs.length / 10))
+        };
+    }
+    isDomainRelatedPattern(pattern) {
+        // Check if pattern context contains domain-related information
+        return !!(pattern.context.domain || pattern.context.domainId || pattern.context.relationship || pattern.context.boundary || pattern.type === 'behavior' && pattern.context.component);
+    }
+    extractFeaturesFromPattern(pattern) {
+        const features = [];
+        // Pattern type encoding
+        const types = [
+            'success',
+            'failure',
+            'optimization',
+            'behavior'
+        ];
+        features.push(...types.map((t)=>t === pattern.type ? 1 : 0));
+        // Confidence and occurrence features
+        features.push(pattern.confidence, Math.log(pattern.occurrences + 1) / 10);
+        // Context features (simplified)
+        features.push(pattern.context.complexity || 0.5, pattern.context.size || 1, pattern.context.frequency || 1);
+        // Pad to consistent size
+        while(features.length < 32){
+            features.push(0);
+        }
+        return features.slice(0, 32);
+    }
+    createTargetFromPattern(pattern) {
+        // Create target vector based on pattern characteristics
+        const target = [
+            pattern.confidence,
+            pattern.type === 'success' ? 1 : 0,
+            pattern.type === 'failure' ? 1 : 0,
+            Math.min(pattern.occurrences / 100, 1)
+        ];
+        return target;
+    }
+    extractTrainingInsights(trainingResult, patterns) {
+        const insights = [];
+        if (trainingResult.finalAccuracy > 0.8) {
+            insights.push('High accuracy achieved - domain patterns are well understood');
+        } else if (trainingResult.finalAccuracy > 0.6) {
+            insights.push('Moderate accuracy - some domain patterns may need more data');
+        } else {
+            insights.push('Low accuracy - domain patterns are complex or insufficient data');
+        }
+        // Analyze pattern types
+        const patternTypes = new Map();
+        patterns.forEach((p)=>{
+            patternTypes.set(p.type, (patternTypes.get(p.type) || 0) + 1);
+        });
+        const dominantType = Array.from(patternTypes.entries()).sort((a, b)=>b[1] - a[1])[0];
+        if (dominantType) {
+            insights.push(`Primary learning focus: ${dominantType[0]} patterns (${dominantType[1]} samples)`);
+        }
+        return insights;
+    }
+    // Additional helper methods would be implemented here for the remaining functionality
+    // These are simplified stubs for the core functionality
+    async extractDomainGraphFromPatterns(patterns) {
+        // Extract domain structure from patterns - simplified implementation
+        return null;
+    }
+    extractDomainTrainingData(trainingData) {
+        // Filter and extract domain-relevant training data
+        return {
+            inputs: [],
+            outputs: [],
+            batchSize: 1,
+            epochs: 1
+        };
+    }
+    extractPatternsFromAnalysis(analysis, context1) {
+        // Extract patterns from analysis results
+        return [];
+    }
+    async executeSideEffect(effect, context1) {
+    // Execute side effect through appropriate system
+    }
+    convertAnalysisToTrainingData(result) {
+        // Convert analysis results to training data for continuous learning
+        return {
+            inputs: [],
+            outputs: [],
+            batchSize: 1,
+            epochs: 1
+        };
+    }
+    calculateOptimizationApplicability(optimization, context1) {
+        return optimization.optimizationScore;
+    }
+    generatePrioritizedActions(optimization) {
+        return optimization.proposals.map((p)=>({
+                action: `${p.type} domains: ${p.domains.join(', ')}`,
+                priority: p.confidence > 0.8 ? 'high' : p.confidence > 0.6 ? 'medium' : 'low',
+                impact: p.metrics.cohesionImprovement + p.metrics.couplingReduction,
+                effort: p.metrics.performanceImpact
+            }));
+    }
+    createPredictionInput(proposedChanges) {
+        return [];
+    }
+    assessChangeRisks(proposedChanges, predictions) {
+        return {
+            overallRisk: 0.5,
+            riskFactors: []
+        };
+    }
+    generateChangeRecommendations(proposedChanges, predictions, riskAssessment) {
+        return [
+            'Consider gradual implementation',
+            'Monitor domain cohesion metrics'
+        ];
+    }
+}
+/**
+ * Factory function to create and initialize a domain mapper integration
+ */ export async function createDomainMapperIntegration(config = {}) {
+    const integration = new NeuralDomainMapperIntegration(undefined, config);
+    await integration.initialize();
+    return integration;
+}
+
+//# sourceMappingURL=integration.js.map

package/dist/src/neural/integration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/neural/integration.ts"],"names":["EventEmitter","NeuralDomainMapper","agenticHookManager","NeuralDomainMapperIntegration","domainMapper","config","analysisHistory","activeAnalysis","Map","learningPatterns","isInitialized","enableAutoAnalysis","enableOptimizationSuggestions","enableContinuousLearning","confidenceThreshold","analysisInterval","maxOptimizationProposals","setupEventListeners","initialize","registerDomainAnalysisHooks","setupPeriodicAnalysis","emit","analyzeDomains","domains","context","correlationId","has","get","analysisPromise","performDomainAnalysis","set","result","push","length","shift","generateHookSideEffects","learnFromAnalysis","delete","trainOnPatterns","patterns","trainingData","convertPatternsToTrainingData","inputs","trainingAccuracy","patternsProcessed","newInsights","trainingResult","train","extractTrainingInsights","slice","finalAccuracy","getOptimizationSuggestions","optimization","provideBoundaryOptimization","applicability","calculateOptimizationApplicability","prioritizedActions","generatePrioritizedActions","suggestions","predictDomainRelationships","proposedChanges","predictionInput","createPredictionInput","predictions","Promise","all","map","input","predict","riskAssessment","assessChangeRisks","recommendations","generateChangeRecommendations","getIntegrationStats","totalAnalyses","avgTime","reduce","sum","a","metrics","analysisTime","optimizationsSuggested","proposals","accuracyTrend","cohesion","overallScore","analysesPerformed","averageAnalysisTime","patternsLearned","lastAnalysis","timestamp","on","graph","analysis","register","id","type","priority","handler","payload","continue","domainPatterns","filter","p","isDomainRelatedPattern","sideEffects","domainGraph","extractDomainGraphFromPatterns","analysisResult","optimizationScore","action","data","event","key","value","ttl","error","level","message","domainTrainingData","extractDomainTrainingData","dataSize","setInterval","recentPatterns","neural","getByType","Date","now","mockContext","sessionId","metadata","source","memory","namespace","provider","cache","modelId","training","performance","bottlenecks","optimizations","startTime","extractPatternsFromAnalysis","dependencies","nodesAnalyzed","nodes","size","edgesAnalyzed","edges","patternsDetected","score","proposalCount","pattern","name","effect","executeSideEffect","learningData","convertAnalysisToTrainingData","outputs","labels","features","extractFeaturesFromPattern","target","createTargetFromPattern","batchSize","Math","min","epochs","max","domain","domainId","relationship","boundary","component","types","t","confidence","log","occurrences","complexity","frequency","insights","patternTypes","forEach","dominantType","Array","from","entries","sort","b","join","impact","cohesionImprovement","couplingReduction","effort","performanceImpact","overallRisk","riskFactors","createDomainMapperIntegration","integration","undefined"],"mappings":"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"}