claude-flow-novice 1.0.0

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

@@ -0,0 +1,640 @@
+/**
+ * Performance optimization hooks for agentic-flow
+ *
+ * Tracks metrics, identifies bottlenecks, and provides
+ * optimization suggestions based on provider performance.
+ */ import { agenticHookManager } from './hook-manager.js';
+// ===== Performance Metric Hook =====
+export const performanceMetricHook = {
+    id: 'agentic-performance-metric',
+    type: 'performance-metric',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { metric, value, unit, threshold } = payload;
+        const sideEffects = [];
+        // Store metric
+        const metricData = {
+            name: metric,
+            value,
+            unit,
+            timestamp: Date.now(),
+            tags: extractTags(payload.context)
+        };
+        context.performance.metrics.set(metric, metricData);
+        // Check threshold violations
+        if (threshold !== undefined) {
+            const violated = checkThreshold(value, threshold, payload.context);
+            if (violated) {
+                sideEffects.push({
+                    type: 'notification',
+                    action: 'emit',
+                    data: {
+                        event: 'performance:threshold:violated',
+                        data: {
+                            metric,
+                            value,
+                            threshold,
+                            unit
+                        }
+                    }
+                });
+                // Generate optimization suggestion
+                const suggestion = await generateOptimizationSuggestion(metric, value, threshold, context);
+                if (suggestion) {
+                    context.performance.optimizations.push(suggestion);
+                    sideEffects.push({
+                        type: 'log',
+                        action: 'write',
+                        data: {
+                            level: 'info',
+                            message: 'Optimization suggestion generated',
+                            data: suggestion
+                        }
+                    });
+                }
+            }
+        }
+        // Update rolling averages
+        await updateRollingAverages(metric, value, context);
+        // Detect anomalies
+        const anomaly = await detectAnomaly(metric, value, context);
+        if (anomaly) {
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'performance:anomaly:detected',
+                    data: {
+                        metric,
+                        value,
+                        anomaly
+                    }
+                }
+            });
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Performance Bottleneck Hook =====
+export const performanceBottleneckHook = {
+    id: 'agentic-performance-bottleneck',
+    type: 'performance-bottleneck',
+    priority: 90,
+    handler: async (payload, context)=>{
+        const { bottleneck } = payload;
+        if (!bottleneck) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Analyze bottleneck severity
+        const analysis = {
+            component: bottleneck.location,
+            severity: mapSeverity(bottleneck.severity),
+            impact: bottleneck.severity / 10,
+            suggestions: bottleneck.suggestions
+        };
+        context.performance.bottlenecks.push(analysis);
+        // Store for historical analysis
+        sideEffects.push({
+            type: 'memory',
+            action: 'store',
+            data: {
+                key: `bottleneck:${analysis.component}:${Date.now()}`,
+                value: analysis,
+                ttl: 86400
+            }
+        });
+        // Check for recurring bottlenecks
+        const recurrence = await checkBottleneckRecurrence(analysis.component, context);
+        if (recurrence.count > 3) {
+            // Recurring bottleneck - escalate
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'performance:bottleneck:recurring',
+                    data: {
+                        component: analysis.component,
+                        occurrences: recurrence.count,
+                        timespan: recurrence.timespan
+                    }
+                }
+            });
+            // Generate advanced optimization
+            const optimization = await generateAdvancedOptimization(analysis, recurrence, context);
+            if (optimization) {
+                context.performance.optimizations.push(optimization);
+            }
+        }
+        // Correlate with other metrics
+        const correlations = await findMetricCorrelations(analysis.component, context);
+        if (correlations.length > 0) {
+            sideEffects.push({
+                type: 'log',
+                action: 'write',
+                data: {
+                    level: 'info',
+                    message: 'Bottleneck correlations found',
+                    data: {
+                        bottleneck: analysis,
+                        correlations
+                    }
+                }
+            });
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Performance Optimization Hook =====
+export const performanceOptimizationHook = {
+    id: 'agentic-performance-optimization',
+    type: 'performance-optimization',
+    priority: 80,
+    handler: async (payload, context)=>{
+        const { optimization } = payload;
+        if (!optimization) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Validate optimization
+        const validation = await validateOptimization(optimization, context);
+        if (!validation.valid) {
+            sideEffects.push({
+                type: 'log',
+                action: 'write',
+                data: {
+                    level: 'warning',
+                    message: 'Optimization validation failed',
+                    data: {
+                        optimization,
+                        validation
+                    }
+                }
+            });
+            return {
+                continue: true,
+                sideEffects
+            };
+        }
+        // Simulate optimization impact
+        const simulation = await simulateOptimization(optimization, context);
+        if (simulation.expectedImprovement < 0.1) {
+            // Low impact - skip
+            return {
+                continue: true
+            };
+        }
+        // Store optimization recommendation
+        const recommendation = {
+            optimization,
+            simulation,
+            timestamp: Date.now(),
+            autoApply: optimization.applied && simulation.risk === 'low'
+        };
+        sideEffects.push({
+            type: 'memory',
+            action: 'store',
+            data: {
+                key: `optimization:${optimization.type}:${Date.now()}`,
+                value: recommendation,
+                ttl: 604800
+            }
+        });
+        // Auto-apply low-risk optimizations
+        if (recommendation.autoApply) {
+            await applyOptimization(optimization, context);
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'performance:optimization:applied',
+                    data: {
+                        optimization,
+                        automatic: true
+                    }
+                }
+            });
+        } else {
+            // Queue for manual review
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'performance:optimization:suggested',
+                    data: {
+                        optimization,
+                        simulation
+                    }
+                }
+            });
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Performance Threshold Hook =====
+export const performanceThresholdHook = {
+    id: 'agentic-performance-threshold',
+    type: 'performance-threshold',
+    priority: 95,
+    handler: async (payload, context)=>{
+        const { metric, value, threshold } = payload;
+        if (threshold === undefined) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Dynamic threshold adjustment
+        const historicalData = await getMetricHistory(metric, context);
+        const adjustedThreshold = calculateDynamicThreshold(threshold, historicalData);
+        if (adjustedThreshold !== threshold) {
+            sideEffects.push({
+                type: 'log',
+                action: 'write',
+                data: {
+                    level: 'info',
+                    message: 'Threshold dynamically adjusted',
+                    data: {
+                        metric,
+                        original: threshold,
+                        adjusted: adjustedThreshold
+                    }
+                }
+            });
+        }
+        // Predict threshold violations
+        const prediction = await predictThresholdViolation(metric, value, adjustedThreshold, historicalData);
+        if (prediction.willViolate && prediction.confidence > 0.7) {
+            sideEffects.push({
+                type: 'notification',
+                action: 'emit',
+                data: {
+                    event: 'performance:threshold:predicted',
+                    data: {
+                        metric,
+                        currentValue: value,
+                        threshold: adjustedThreshold,
+                        predictedTime: prediction.timeToViolation,
+                        confidence: prediction.confidence
+                    }
+                }
+            });
+            // Proactive optimization
+            const proactiveOpt = await generateProactiveOptimization(metric, prediction, context);
+            if (proactiveOpt) {
+                context.performance.optimizations.push(proactiveOpt);
+            }
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== Helper Functions =====
+function extractTags(context) {
+    const tags = [];
+    if (context.provider) tags.push(`provider:${context.provider}`);
+    if (context.model) tags.push(`model:${context.model}`);
+    if (context.operation) tags.push(`op:${context.operation}`);
+    if (context.component) tags.push(`component:${context.component}`);
+    return tags;
+}
+function checkThreshold(value, threshold, context) {
+    // Check if threshold is violated based on context
+    const operator = context.thresholdOperator || 'gt';
+    switch(operator){
+        case 'gt':
+            return value > threshold;
+        case 'gte':
+            return value >= threshold;
+        case 'lt':
+            return value < threshold;
+        case 'lte':
+            return value <= threshold;
+        case 'eq':
+            return value === threshold;
+        case 'ne':
+            return value !== threshold;
+        default:
+            return value > threshold;
+    }
+}
+async function generateOptimizationSuggestion(metric, value, threshold, context) {
+    // Generate optimization based on metric type
+    const metricType = getMetricType(metric);
+    switch(metricType){
+        case 'latency':
+            if (value > threshold * 2) {
+                return {
+                    type: 'cache',
+                    target: metric,
+                    expectedImprovement: 50,
+                    implementation: 'Enable response caching for frequently accessed data',
+                    risk: 'low'
+                };
+            } else if (value > threshold * 1.5) {
+                return {
+                    type: 'parallel',
+                    target: metric,
+                    expectedImprovement: 30,
+                    implementation: 'Parallelize independent operations',
+                    risk: 'medium'
+                };
+            }
+            break;
+        case 'throughput':
+            if (value < threshold * 0.5) {
+                return {
+                    type: 'batch',
+                    target: metric,
+                    expectedImprovement: 40,
+                    implementation: 'Batch similar requests together',
+                    risk: 'low'
+                };
+            }
+            break;
+        case 'memory':
+            if (value > threshold * 0.9) {
+                return {
+                    type: 'resource',
+                    target: metric,
+                    expectedImprovement: 20,
+                    implementation: 'Implement memory pooling and recycling',
+                    risk: 'medium'
+                };
+            }
+            break;
+    }
+    return null;
+}
+async function updateRollingAverages(metric, value, context) {
+    const avgKey = `avg:${metric}`;
+    const history = await context.memory.cache.get(avgKey) || [];
+    history.push({
+        value,
+        timestamp: Date.now()
+    });
+    // Keep last 1000 values
+    if (history.length > 1000) {
+        history.shift();
+    }
+    await context.memory.cache.set(avgKey, history);
+}
+async function detectAnomaly(metric, value, context) {
+    const avgKey = `avg:${metric}`;
+    const history = await context.memory.cache.get(avgKey) || [];
+    if (history.length < 100) {
+        return null; // Not enough data
+    }
+    // Calculate statistics
+    const values = history.map((h)=>h.value);
+    const mean = values.reduce((a, b)=>a + b, 0) / values.length;
+    const variance = values.reduce((a, b)=>a + Math.pow(b - mean, 2), 0) / values.length;
+    const stdDev = Math.sqrt(variance);
+    // Check if value is anomalous (> 3 standard deviations)
+    const zScore = Math.abs((value - mean) / stdDev);
+    if (zScore > 3) {
+        return {
+            type: 'statistical',
+            zScore,
+            mean,
+            stdDev,
+            severity: zScore > 5 ? 'high' : 'medium'
+        };
+    }
+    return null;
+}
+function mapSeverity(severity) {
+    if (severity >= 8) return 'critical';
+    if (severity >= 6) return 'high';
+    if (severity >= 4) return 'medium';
+    return 'low';
+}
+async function checkBottleneckRecurrence(component, context) {
+    const historyKey = `bottleneck:history:${component}`;
+    const history = await context.memory.cache.get(historyKey) || [];
+    const now = Date.now();
+    const dayAgo = now - 86400000;
+    // Count occurrences in last 24 hours
+    const recentOccurrences = history.filter((h)=>h.timestamp > dayAgo);
+    return {
+        count: recentOccurrences.length,
+        timespan: 86400000
+    };
+}
+async function generateAdvancedOptimization(bottleneck, recurrence, context) {
+    // Generate advanced optimization for recurring bottlenecks
+    if (bottleneck.severity === 'critical' && recurrence.count > 5) {
+        return {
+            type: 'algorithm',
+            target: bottleneck.component,
+            expectedImprovement: 60,
+            implementation: `Redesign ${bottleneck.component} algorithm for better scalability`,
+            risk: 'high'
+        };
+    }
+    if (bottleneck.severity === 'high' && recurrence.count > 3) {
+        return {
+            type: 'cache',
+            target: bottleneck.component,
+            expectedImprovement: 40,
+            implementation: `Implement distributed caching for ${bottleneck.component}`,
+            risk: 'medium'
+        };
+    }
+    return null;
+}
+async function findMetricCorrelations(component, context) {
+    const correlations = [];
+    // Check correlations with other metrics
+    for (const [metric, data] of context.performance.metrics){
+        if (data.tags.includes(`component:${component}`)) {
+            // Simple correlation check
+            correlations.push({
+                metric: data.name,
+                correlation: 0.7
+            });
+        }
+    }
+    return correlations;
+}
+async function validateOptimization(optimization, context) {
+    // Validate optimization is safe to apply
+    if (!optimization.type || !optimization.details) {
+        return {
+            valid: false,
+            reason: 'Missing required optimization fields'
+        };
+    }
+    // Check risk level
+    if (optimization.details === 'high' && !context.metadata.allowHighRisk) {
+        return {
+            valid: false,
+            reason: 'High-risk optimizations not allowed'
+        };
+    }
+    return {
+        valid: true
+    };
+}
+async function simulateOptimization(optimization, context) {
+    // Simulate optimization impact
+    const baseline = await getBaselineMetrics(optimization.type, context);
+    const simulation = {
+        expectedImprovement: optimization.improvement || 0.2,
+        risk: calculateRisk(optimization),
+        affectedMetrics: identifyAffectedMetrics(optimization),
+        rollbackPlan: generateRollbackPlan(optimization)
+    };
+    return simulation;
+}
+async function applyOptimization(optimization, context) {
+    // Apply optimization
+    // Placeholder implementation
+    const timestamp = Date.now();
+    // Store optimization application
+    await context.memory.cache.set(`applied:${optimization.type}:${timestamp}`, {
+        optimization,
+        appliedAt: timestamp,
+        appliedBy: 'automatic'
+    });
+}
+async function getMetricHistory(metric, context) {
+    const historyKey = `history:${metric}`;
+    return await context.memory.cache.get(historyKey) || [];
+}
+function calculateDynamicThreshold(baseThreshold, historicalData) {
+    if (historicalData.length < 50) {
+        return baseThreshold; // Not enough data
+    }
+    // Calculate percentile-based threshold
+    const values = historicalData.map((d)=>d.value).sort((a, b)=>a - b);
+    const p95 = values[Math.floor(values.length * 0.95)];
+    // Adjust threshold based on historical performance
+    return Math.max(baseThreshold, p95 * 1.1);
+}
+async function predictThresholdViolation(metric, currentValue, threshold, historicalData) {
+    if (historicalData.length < 10) {
+        return {
+            willViolate: false,
+            confidence: 0
+        };
+    }
+    // Simple linear trend prediction
+    const recentValues = historicalData.slice(-10).map((d)=>d.value);
+    const trend = calculateTrend(recentValues);
+    if (trend > 0 && currentValue > threshold * 0.8) {
+        const timeToViolation = (threshold - currentValue) / trend;
+        return {
+            willViolate: true,
+            timeToViolation,
+            confidence: Math.min(trend * 10, 0.9)
+        };
+    }
+    return {
+        willViolate: false,
+        confidence: 0
+    };
+}
+async function generateProactiveOptimization(metric, prediction, context) {
+    // Generate proactive optimization to prevent violation
+    const metricType = getMetricType(metric);
+    if (metricType === 'latency' && prediction.timeToViolation < 300000) {
+        return {
+            type: 'cache',
+            target: metric,
+            expectedImprovement: 30,
+            implementation: 'Preemptively cache high-latency operations',
+            risk: 'low'
+        };
+    }
+    return null;
+}
+function getMetricType(metric) {
+    if (metric.includes('latency')) return 'latency';
+    if (metric.includes('throughput')) return 'throughput';
+    if (metric.includes('memory')) return 'memory';
+    if (metric.includes('cpu')) return 'cpu';
+    return 'unknown';
+}
+async function getBaselineMetrics(type, context) {
+    // Get baseline metrics for comparison
+    // Placeholder implementation
+    return {};
+}
+function calculateRisk(optimization) {
+    // Calculate optimization risk level
+    if (optimization.type === 'algorithm') return 'high';
+    if (optimization.type === 'architecture') return 'high';
+    if (optimization.type === 'cache') return 'low';
+    if (optimization.type === 'batch') return 'low';
+    return 'medium';
+}
+function identifyAffectedMetrics(optimization) {
+    // Identify metrics affected by optimization
+    const affected = [];
+    switch(optimization.type){
+        case 'cache':
+            affected.push('latency', 'memory_usage');
+            break;
+        case 'parallel':
+            affected.push('latency', 'cpu_usage', 'throughput');
+            break;
+        case 'batch':
+            affected.push('throughput', 'latency');
+            break;
+        case 'algorithm':
+            affected.push('latency', 'cpu_usage', 'memory_usage');
+            break;
+    }
+    return affected;
+}
+function generateRollbackPlan(optimization) {
+    // Generate rollback plan
+    return {
+        steps: [
+            'Capture current metrics',
+            'Apply optimization',
+            'Monitor for 5 minutes',
+            'Rollback if metrics degrade'
+        ],
+        triggers: {
+            errorRate: 0.05,
+            latencyIncrease: 1.5
+        }
+    };
+}
+function calculateTrend(values) {
+    if (values.length < 2) return 0;
+    // Simple linear regression
+    const n = values.length;
+    const sumX = values.reduce((a, _, i)=>a + i, 0);
+    const sumY = values.reduce((a, b)=>a + b, 0);
+    const sumXY = values.reduce((a, b, i)=>a + i * b, 0);
+    const sumX2 = values.reduce((a, _, i)=>a + i * i, 0);
+    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+    return slope;
+}
+// ===== Register Hooks =====
+export function registerPerformanceHooks() {
+    agenticHookManager.register(performanceMetricHook);
+    agenticHookManager.register(performanceBottleneckHook);
+    agenticHookManager.register(performanceOptimizationHook);
+    agenticHookManager.register(performanceThresholdHook);
+}
+
+//# sourceMappingURL=performance-hooks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/agentic-flow-hooks/performance-hooks.ts"],"names":["agenticHookManager","performanceMetricHook","id","type","priority","handler","payload","context","metric","value","unit","threshold","sideEffects","metricData","name","timestamp","Date","now","tags","extractTags","performance","metrics","set","undefined","violated","checkThreshold","push","action","data","event","suggestion","generateOptimizationSuggestion","optimizations","level","message","updateRollingAverages","anomaly","detectAnomaly","continue","performanceBottleneckHook","bottleneck","analysis","component","location","severity","mapSeverity","impact","suggestions","bottlenecks","key","ttl","recurrence","checkBottleneckRecurrence","count","occurrences","timespan","optimization","generateAdvancedOptimization","correlations","findMetricCorrelations","length","performanceOptimizationHook","validation","validateOptimization","valid","simulation","simulateOptimization","expectedImprovement","recommendation","autoApply","applied","risk","applyOptimization","automatic","performanceThresholdHook","historicalData","getMetricHistory","adjustedThreshold","calculateDynamicThreshold","original","adjusted","prediction","predictThresholdViolation","willViolate","confidence","currentValue","predictedTime","timeToViolation","proactiveOpt","generateProactiveOptimization","provider","model","operation","operator","thresholdOperator","metricType","getMetricType","target","implementation","avgKey","history","memory","cache","get","shift","values","map","h","mean","reduce","a","b","variance","Math","pow","stdDev","sqrt","zScore","abs","historyKey","dayAgo","recentOccurrences","filter","includes","correlation","details","reason","metadata","allowHighRisk","baseline","getBaselineMetrics","improvement","calculateRisk","affectedMetrics","identifyAffectedMetrics","rollbackPlan","generateRollbackPlan","appliedAt","appliedBy","baseThreshold","d","sort","p95","floor","max","recentValues","slice","trend","calculateTrend","min","affected","steps","triggers","errorRate","latencyIncrease","n","sumX","_","i","sumY","sumXY","sumX2","slope","registerPerformanceHooks","register"],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+/**
+ * Agentic Flow Hook System Type Definitions
+ *
+ * This module defines the comprehensive hook system for integrating
+ * agentic-flow with Claude Flow's existing infrastructure.
+ */ export { };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/agentic-flow-hooks/types.ts"],"names":[],"mappings":"AAAA;;;;;CAKC,GA4eD,WAKC"}