claude-flow-novice 1.0.0

package/dist/src/services/agentic-flow-hooks/neural-hooks.js

@@ -0,0 +1,595 @@
+/**
+ * Neural training hooks for agentic-flow
+ *
+ * Enables learning from multi-model responses with
+ * pattern detection and adaptive optimization.
+ */ import { agenticHookManager } from './hook-manager.js';
+// ===== Pre-Neural Train Hook =====
+export const preNeuralTrainHook = {
+    id: 'agentic-pre-neural-train',
+    type: 'pre-neural-train',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { operation, modelId, trainingData } = payload;
+        if (operation !== 'train' || !trainingData) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Validate training data
+        const validation = validateTrainingData(trainingData);
+        if (!validation.valid) {
+            return {
+                continue: false,
+                sideEffects: [
+                    {
+                        type: 'log',
+                        action: 'write',
+                        data: {
+                            level: 'error',
+                            message: 'Invalid training data',
+                            data: validation
+                        }
+                    }
+                ]
+            };
+        }
+        // Augment training data with historical patterns
+        const augmentedData = await augmentTrainingData(trainingData, modelId, context);
+        // Balance dataset if needed
+        const balancedData = balanceTrainingData(augmentedData);
+        // Apply data preprocessing
+        const preprocessedData = preprocessTrainingData(balancedData);
+        // Store training session metadata
+        sideEffects.push({
+            type: 'memory',
+            action: 'store',
+            data: {
+                key: `neural:training:${modelId}:${Date.now()}`,
+                value: {
+                    originalSize: trainingData.inputs.length,
+                    augmentedSize: augmentedData.inputs.length,
+                    balancedSize: balancedData.inputs.length,
+                    epochs: balancedData.epochs,
+                    timestamp: Date.now()
+                },
+                ttl: 86400
+            }
+        });
+        return {
+            continue: true,
+            modified: true,
+            payload: {
+                ...payload,
+                trainingData: preprocessedData
+            },
+            sideEffects
+        };
+    }
+};
+// ===== Post-Neural Train Hook =====
+export const postNeuralTrainHook = {
+    id: 'agentic-post-neural-train',
+    type: 'post-neural-train',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { modelId, accuracy, trainingData } = payload;
+        const sideEffects = [];
+        // Store training results
+        const trainingResult = {
+            modelId,
+            accuracy,
+            timestamp: Date.now(),
+            sessionId: context.sessionId,
+            dataSize: trainingData?.inputs.length || 0,
+            epochs: trainingData?.epochs || 0
+        };
+        sideEffects.push({
+            type: 'memory',
+            action: 'store',
+            data: {
+                key: `neural:results:${modelId}:${Date.now()}`,
+                value: trainingResult,
+                ttl: 604800
+            }
+        });
+        // Update model performance history
+        await updateModelPerformance(modelId, accuracy, context);
+        // Check if model should be promoted
+        const shouldPromote = await evaluateModelPromotion(modelId, accuracy, context);
+        if (shouldPromote) {
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'neural:model:promoted',
+                    data: {
+                        modelId,
+                        accuracy
+                    }
+                }
+            });
+        }
+        // Extract learned patterns
+        const patterns = await extractLearnedPatterns(modelId, context);
+        if (patterns.length > 0) {
+            sideEffects.push({
+                type: 'neural',
+                action: 'store-patterns',
+                data: {
+                    patterns
+                }
+            });
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Neural Pattern Detected Hook =====
+export const neuralPatternDetectedHook = {
+    id: 'agentic-neural-pattern-detected',
+    type: 'neural-pattern-detected',
+    priority: 90,
+    handler: async (payload, context)=>{
+        const { patterns } = payload;
+        if (!patterns || patterns.length === 0) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Analyze pattern significance
+        for (const pattern of patterns){
+            const significance = calculatePatternSignificance(pattern);
+            if (significance > 0.7) {
+                // High significance pattern
+                sideEffects.push({
+                    type: 'memory',
+                    action: 'store',
+                    data: {
+                        key: `pattern:significant:${pattern.id}`,
+                        value: {
+                            pattern,
+                            significance,
+                            detectedAt: Date.now(),
+                            context: context.metadata
+                        },
+                        ttl: 0
+                    }
+                });
+                // Trigger adaptation if needed
+                const adaptation = await generateAdaptation(pattern, context);
+                if (adaptation) {
+                    sideEffects.push({
+                        type: 'neural',
+                        action: 'adapt',
+                        data: {
+                            adaptation
+                        }
+                    });
+                }
+            }
+            // Update pattern store
+            context.neural.patterns.add(pattern);
+        }
+        // Check for pattern combinations
+        const combinations = findPatternCombinations(patterns, context);
+        if (combinations.length > 0) {
+            sideEffects.push({
+                type: 'log',
+                action: 'write',
+                data: {
+                    level: 'info',
+                    message: 'Pattern combinations detected',
+                    data: {
+                        combinations
+                    }
+                }
+            });
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Neural Prediction Hook =====
+export const neuralPredictionHook = {
+    id: 'agentic-neural-prediction',
+    type: 'neural-prediction',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { prediction, modelId } = payload;
+        if (!prediction) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Validate prediction confidence
+        if (prediction.confidence < 0.5) {
+            // Low confidence - consider alternatives
+            const alternatives = await generateAlternatives(prediction.input, modelId, context);
+            if (alternatives.length > 0) {
+                return {
+                    continue: true,
+                    modified: true,
+                    payload: {
+                        ...payload,
+                        prediction: {
+                            ...prediction,
+                            alternatives: [
+                                ...prediction.alternatives,
+                                ...alternatives
+                            ]
+                        }
+                    },
+                    sideEffects: [
+                        {
+                            type: 'metric',
+                            action: 'increment',
+                            data: {
+                                name: 'neural.predictions.low_confidence'
+                            }
+                        }
+                    ]
+                };
+            }
+        }
+        // Store prediction for future training
+        sideEffects.push({
+            type: 'memory',
+            action: 'store',
+            data: {
+                key: `prediction:${modelId}:${Date.now()}`,
+                value: {
+                    input: prediction.input,
+                    output: prediction.output,
+                    confidence: prediction.confidence,
+                    timestamp: Date.now()
+                },
+                ttl: 86400
+            }
+        });
+        // Track prediction metrics
+        sideEffects.push({
+            type: 'metric',
+            action: 'update',
+            data: {
+                name: `neural.predictions.confidence.${modelId}`,
+                value: prediction.confidence
+            }
+        });
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Neural Adaptation Hook =====
+export const neuralAdaptationHook = {
+    id: 'agentic-neural-adaptation',
+    type: 'neural-adaptation',
+    priority: 90,
+    handler: async (payload, context)=>{
+        const { adaptations, modelId } = payload;
+        if (!adaptations || adaptations.length === 0) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Validate adaptations
+        const validAdaptations = adaptations.filter((a)=>validateAdaptation(a, modelId, context));
+        if (validAdaptations.length === 0) {
+            return {
+                continue: true
+            };
+        }
+        // Apply adaptations in order of impact
+        const sortedAdaptations = validAdaptations.sort((a, b)=>Math.abs(b.impact) - Math.abs(a.impact));
+        for (const adaptation of sortedAdaptations){
+            // Store adaptation history
+            sideEffects.push({
+                type: 'memory',
+                action: 'store',
+                data: {
+                    key: `adaptation:${modelId}:${adaptation.target}:${Date.now()}`,
+                    value: adaptation,
+                    ttl: 604800
+                }
+            });
+            // Apply adaptation based on type
+            switch(adaptation.type){
+                case 'parameter':
+                    await applyParameterAdaptation(adaptation, modelId, context);
+                    break;
+                case 'architecture':
+                    await applyArchitectureAdaptation(adaptation, modelId, context);
+                    break;
+                case 'strategy':
+                    await applyStrategyAdaptation(adaptation, modelId, context);
+                    break;
+            }
+            // Track adaptation metrics
+            sideEffects.push({
+                type: 'metric',
+                action: 'increment',
+                data: {
+                    name: `neural.adaptations.${adaptation.type}`
+                }
+            });
+        }
+        // Trigger retraining if significant adaptations
+        const totalImpact = sortedAdaptations.reduce((sum, a)=>sum + Math.abs(a.impact), 0);
+        if (totalImpact > 0.5) {
+            sideEffects.push({
+                type: 'neural',
+                action: 'retrain',
+                data: {
+                    modelId,
+                    reason: 'significant_adaptations',
+                    adaptations: sortedAdaptations.length
+                }
+            });
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Helper Functions =====
+function validateTrainingData(data) {
+    const errors = [];
+    if (!data.inputs || data.inputs.length === 0) {
+        errors.push('No input data provided');
+    }
+    if (!data.outputs || data.outputs.length === 0) {
+        errors.push('No output data provided');
+    }
+    if (data.inputs.length !== data.outputs.length) {
+        errors.push('Input and output lengths do not match');
+    }
+    if (data.batchSize <= 0) {
+        errors.push('Invalid batch size');
+    }
+    if (data.epochs <= 0) {
+        errors.push('Invalid number of epochs');
+    }
+    return {
+        valid: errors.length === 0,
+        errors: errors.length > 0 ? errors : undefined
+    };
+}
+async function augmentTrainingData(data, modelId, context) {
+    // Augment with historical successful patterns
+    const historicalPatterns = await loadHistoricalPatterns(modelId, context);
+    const augmented = {
+        ...data,
+        inputs: [
+            ...data.inputs
+        ],
+        outputs: [
+            ...data.outputs
+        ],
+        labels: data.labels ? [
+            ...data.labels
+        ] : undefined,
+        weights: data.weights ? [
+            ...data.weights
+        ] : undefined
+    };
+    // Add successful patterns
+    for (const pattern of historicalPatterns){
+        if (pattern.type === 'success' && pattern.confidence > 0.8) {
+            augmented.inputs.push(pattern.context.input);
+            augmented.outputs.push(pattern.context.output);
+            if (augmented.weights) {
+                // Give higher weight to successful patterns
+                augmented.weights.push(pattern.confidence);
+            }
+        }
+    }
+    return augmented;
+}
+function balanceTrainingData(data) {
+    // Balance dataset to prevent bias
+    if (!data.labels) {
+        return data;
+    }
+    // Count occurrences of each label
+    const labelCounts = new Map();
+    for (const label of data.labels){
+        labelCounts.set(label, (labelCounts.get(label) || 0) + 1);
+    }
+    // Find minimum count
+    const minCount = Math.min(...labelCounts.values());
+    // Balance by undersampling
+    const balanced = {
+        ...data,
+        inputs: [],
+        outputs: [],
+        labels: [],
+        weights: data.weights ? [] : undefined
+    };
+    const labelIndices = new Map();
+    data.labels.forEach((label, i)=>{
+        if (!labelIndices.has(label)) {
+            labelIndices.set(label, []);
+        }
+        labelIndices.get(label).push(i);
+    });
+    // Sample equally from each label
+    for (const [label, indices] of labelIndices.entries()){
+        const sampled = indices.sort(()=>Math.random() - 0.5).slice(0, minCount);
+        for (const idx of sampled){
+            balanced.inputs.push(data.inputs[idx]);
+            balanced.outputs.push(data.outputs[idx]);
+            balanced.labels.push(label);
+            if (data.weights && balanced.weights) {
+                balanced.weights.push(data.weights[idx]);
+            }
+        }
+    }
+    return balanced;
+}
+function preprocessTrainingData(data) {
+    // Apply preprocessing transformations
+    const processed = {
+        ...data,
+        inputs: data.inputs.map((input)=>normalizeInput(input)),
+        outputs: data.outputs.map((output)=>normalizeOutput(output))
+    };
+    return processed;
+}
+function normalizeInput(input) {
+    // Normalize input data
+    // Placeholder - actual implementation would depend on data type
+    return input;
+}
+function normalizeOutput(output) {
+    // Normalize output data
+    // Placeholder - actual implementation would depend on data type
+    return output;
+}
+async function updateModelPerformance(modelId, accuracy, context) {
+    const perfKey = `model:performance:${modelId}`;
+    const history = await context.memory.cache.get(perfKey) || [];
+    history.push({
+        accuracy,
+        timestamp: Date.now(),
+        sessionId: context.sessionId
+    });
+    // Keep last 100 performance records
+    if (history.length > 100) {
+        history.shift();
+    }
+    await context.memory.cache.set(perfKey, history);
+}
+async function evaluateModelPromotion(modelId, accuracy, context) {
+    // Check if model should be promoted to production
+    const perfKey = `model:performance:${modelId}`;
+    const history = await context.memory.cache.get(perfKey) || [];
+    if (history.length < 10) {
+        return false; // Not enough history
+    }
+    // Calculate average accuracy over last 10 runs
+    const recent = history.slice(-10);
+    const avgAccuracy = recent.reduce((sum, h)=>sum + h.accuracy, 0) / recent.length;
+    // Promote if consistently above threshold
+    return avgAccuracy > 0.85 && accuracy > 0.85;
+}
+async function extractLearnedPatterns(modelId, context) {
+    // Extract patterns learned during training
+    // Placeholder implementation
+    return [];
+}
+function calculatePatternSignificance(pattern) {
+    // Calculate pattern significance score
+    const baseScore = pattern.confidence;
+    const occurrenceBonus = Math.min(pattern.occurrences / 100, 0.2);
+    return Math.min(baseScore + occurrenceBonus, 1.0);
+}
+async function generateAdaptation(pattern, context) {
+    // Generate adaptation based on pattern
+    if (pattern.type === 'failure' && pattern.confidence > 0.8) {
+        return {
+            type: 'parameter',
+            target: 'learning_rate',
+            oldValue: context.neural.training.learningRate,
+            newValue: context.neural.training.learningRate * 0.9,
+            reason: `High confidence failure pattern detected: ${pattern.id}`,
+            impact: -0.1
+        };
+    }
+    if (pattern.type === 'optimization' && pattern.confidence > 0.9) {
+        return {
+            type: 'strategy',
+            target: 'batch_size',
+            oldValue: 32,
+            newValue: 64,
+            reason: `Optimization opportunity detected: ${pattern.id}`,
+            impact: 0.2
+        };
+    }
+    return null;
+}
+function findPatternCombinations(patterns, context) {
+    const combinations = [];
+    // Find co-occurring patterns
+    for(let i = 0; i < patterns.length; i++){
+        for(let j = i + 1; j < patterns.length; j++){
+            const pattern1 = patterns[i];
+            const pattern2 = patterns[j];
+            // Check if patterns are related
+            if (areRelatedPatterns(pattern1, pattern2)) {
+                const significance = (pattern1.confidence + pattern2.confidence) / 2 * 1.2;
+                combinations.push({
+                    patterns: [
+                        pattern1,
+                        pattern2
+                    ],
+                    significance: Math.min(significance, 1.0)
+                });
+            }
+        }
+    }
+    return combinations;
+}
+function areRelatedPatterns(p1, p2) {
+    // Check if patterns are related
+    // Simplified implementation
+    return p1.type === p2.type || Object.keys(p1.context).some((key)=>key in p2.context);
+}
+async function generateAlternatives(input, modelId, context) {
+    // Generate alternative predictions
+    // Placeholder implementation
+    return [];
+}
+function validateAdaptation(adaptation, modelId, context) {
+    // Validate adaptation is safe to apply
+    if (Math.abs(adaptation.impact) > 0.5) {
+        // Large impact adaptations need more validation
+        return context.neural.training.epoch > 10;
+    }
+    return true;
+}
+async function applyParameterAdaptation(adaptation, modelId, context) {
+// Apply parameter adaptation
+// Placeholder implementation
+}
+async function applyArchitectureAdaptation(adaptation, modelId, context) {
+// Apply architecture adaptation
+// Placeholder implementation
+}
+async function applyStrategyAdaptation(adaptation, modelId, context) {
+// Apply strategy adaptation
+// Placeholder implementation
+}
+async function loadHistoricalPatterns(modelId, context) {
+    // Load historical patterns
+    const patterns = [];
+    // Get recent patterns from memory
+    const patternKeys = await context.memory.cache.get(`patterns:${modelId}`) || [];
+    for (const key of patternKeys.slice(-100)){
+        const pattern = await context.memory.cache.get(key);
+        if (pattern) {
+            patterns.push(pattern);
+        }
+    }
+    return patterns;
+}
+// ===== Register Hooks =====
+export function registerNeuralHooks() {
+    agenticHookManager.register(preNeuralTrainHook);
+    agenticHookManager.register(postNeuralTrainHook);
+    agenticHookManager.register(neuralPatternDetectedHook);
+    agenticHookManager.register(neuralPredictionHook);
+    agenticHookManager.register(neuralAdaptationHook);
+}
+
+//# sourceMappingURL=neural-hooks.js.map

package/dist/src/services/agentic-flow-hooks/neural-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/agentic-flow-hooks/neural-hooks.ts"],"names":["agenticHookManager","preNeuralTrainHook","id","type","priority","handler","payload","context","operation","modelId","trainingData","continue","sideEffects","validation","validateTrainingData","valid","action","data","level","message","augmentedData","augmentTrainingData","balancedData","balanceTrainingData","preprocessedData","preprocessTrainingData","push","key","Date","now","value","originalSize","inputs","length","augmentedSize","balancedSize","epochs","timestamp","ttl","modified","postNeuralTrainHook","accuracy","trainingResult","sessionId","dataSize","updateModelPerformance","shouldPromote","evaluateModelPromotion","event","patterns","extractLearnedPatterns","neuralPatternDetectedHook","pattern","significance","calculatePatternSignificance","detectedAt","metadata","adaptation","generateAdaptation","neural","add","combinations","findPatternCombinations","neuralPredictionHook","prediction","confidence","alternatives","generateAlternatives","input","name","output","neuralAdaptationHook","adaptations","validAdaptations","filter","a","validateAdaptation","sortedAdaptations","sort","b","Math","abs","impact","target","applyParameterAdaptation","applyArchitectureAdaptation","applyStrategyAdaptation","totalImpact","reduce","sum","reason","errors","outputs","batchSize","undefined","historicalPatterns","loadHistoricalPatterns","augmented","labels","weights","labelCounts","Map","label","set","get","minCount","min","values","balanced","labelIndices","forEach","i","has","indices","entries","sampled","random","slice","idx","processed","map","normalizeInput","normalizeOutput","perfKey","history","memory","cache","shift","recent","avgAccuracy","h","baseScore","occurrenceBonus","occurrences","oldValue","training","learningRate","newValue","j","pattern1","pattern2","areRelatedPatterns","p1","p2","Object","keys","some","epoch","patternKeys","registerNeuralHooks","register"],"mappings":"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"}