claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.62

package/dist/enterprise/analytics-manager.js

@@ -42,7 +42,7 @@ export class AnalyticsManager extends EventEmitter {
         const fullMetric = {
             id: `metric-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
             timestamp: new Date(),
-            ...metric
+            ...metric,
         };
         const key = `${metric.category}-${metric.name}`;
         if (!this.metrics.has(key)) {
@@ -53,7 +53,7 @@ export class AnalyticsManager extends EventEmitter {
         // Keep only recent metrics in memory (configurable retention)
         const retentionPeriod = 24 * 60 * 60 * 1000; // 24 hours
         const cutoff = Date.now() - retentionPeriod;
-        const filteredMetrics = metricArray.filter(m => m.timestamp.getTime() > cutoff);
+        const filteredMetrics = metricArray.filter((m) => m.timestamp.getTime() > cutoff);
         this.metrics.set(key, filteredMetrics);
         // Persist to disk for longer-term storage
         await this.persistMetric(fullMetric);
@@ -65,19 +65,18 @@ export class AnalyticsManager extends EventEmitter {
         const results = {};
         for (const metricName of query.metrics) {
             const key = metricName.includes('-') ? metricName : `*-${metricName}`;
-            const matchingKeys = Array.from(this.metrics.keys()).filter(k => key === '*' || k.includes(key.replace('*-', '')) || k === key);
+            const matchingKeys = Array.from(this.metrics.keys()).filter((k) => key === '*' || k.includes(key.replace('*-', '')) || k === key);
             let allMetrics = [];
             for (const k of matchingKeys) {
                 const keyMetrics = this.metrics.get(k) || [];
                 allMetrics.push(...keyMetrics);
             }
             // Filter by time range
-            allMetrics = allMetrics.filter(m => m.timestamp >= query.timeRange.start &&
-                m.timestamp <= query.timeRange.end);
+            allMetrics = allMetrics.filter((m) => m.timestamp >= query.timeRange.start && m.timestamp <= query.timeRange.end);
             // Apply filters
             if (query.filters) {
                 for (const [field, value] of Object.entries(query.filters)) {
-                    allMetrics = allMetrics.filter(m => {
+                    allMetrics = allMetrics.filter((m) => {
                         if (field === 'tags') {
                             return Object.entries(value).every(([k, v]) => m.tags[k] === v);
                         }
@@ -108,28 +107,28 @@ export class AnalyticsManager extends EventEmitter {
             type: dashboardData.type,
             widgets: dashboardData.widgets.map((widget, index) => ({
                 id: `widget-${Date.now()}-${index}`,
-                ...widget
+                ...widget,
             })),
             layout: {
                 columns: 12,
                 rows: 8,
                 grid: true,
-                responsive: true
+                responsive: true,
             },
             permissions: {
                 viewers: [],
                 editors: [],
                 public: false,
-                ...dashboardData.permissions
+                ...dashboardData.permissions,
             },
             schedule: {
                 autoRefresh: true,
-                refreshInterval: 30
+                refreshInterval: 30,
             },
             filters: [],
             createdAt: new Date(),
             updatedAt: new Date(),
-            createdBy: 'system'
+            createdBy: 'system',
         };
         this.dashboards.set(dashboard.id, dashboard);
         await this.saveDashboard(dashboard);
@@ -142,7 +141,7 @@ export class AnalyticsManager extends EventEmitter {
         // Default time range: last 24 hours
         const timeRange = scope.timeRange || {
             start: new Date(Date.now() - 24 * 60 * 60 * 1000),
-            end: new Date()
+            end: new Date(),
         };
         // Anomaly detection
         const anomalies = await this.detectAnomalies(timeRange, scope.metrics);
@@ -183,15 +182,15 @@ export class AnalyticsManager extends EventEmitter {
             trainingData: {
                 samples: 0,
                 features: modelConfig.features.length,
-                timeRange: modelConfig.trainingPeriod
+                timeRange: modelConfig.trainingPeriod,
             },
             performance: {
                 precision: 0,
                 recall: 0,
-                f1Score: 0
+                f1Score: 0,
             },
             predictions: [],
-            status: 'training'
+            status: 'training',
         };
         try {
             // Collect training data
@@ -228,7 +227,7 @@ export class AnalyticsManager extends EventEmitter {
             input,
             prediction: prediction.value,
             confidence: prediction.confidence,
-            timestamp: new Date()
+            timestamp: new Date(),
         };
         model.predictions.push(result);
         model.lastPrediction = new Date();
@@ -240,22 +239,22 @@ export class AnalyticsManager extends EventEmitter {
     async getPerformanceMetrics(timeRange) {
         const range = timeRange || {
             start: new Date(Date.now() - 60 * 60 * 1000), // Last hour
-            end: new Date()
+            end: new Date(),
         };
         const systemMetrics = await this.queryMetrics({
             metrics: ['cpu-usage', 'memory-usage', 'disk-usage', 'network-io'],
             timeRange: range,
-            aggregation: 'avg'
+            aggregation: 'avg',
         });
         const appMetrics = await this.queryMetrics({
             metrics: ['response-time', 'request-rate', 'error-rate', 'uptime'],
             timeRange: range,
-            aggregation: 'avg'
+            aggregation: 'avg',
         });
         const dbMetrics = await this.queryMetrics({
             metrics: ['db-connections', 'query-time', 'db-size'],
             timeRange: range,
-            aggregation: 'avg'
+            aggregation: 'avg',
         });
         // Construct performance metrics (simplified)
         return {
@@ -263,91 +262,91 @@ export class AnalyticsManager extends EventEmitter {
                 cpu: {
                     usage: this.getLatestValue(systemMetrics['cpu-usage']) || 0,
                     cores: 8, // Would be detected from system
-                    loadAverage: [1.2, 1.5, 1.8] // Would be collected from system
+                    loadAverage: [1.2, 1.5, 1.8], // Would be collected from system
                 },
                 memory: {
                     used: this.getLatestValue(systemMetrics['memory-usage']) || 0,
                     free: 4000000000, // Would be calculated
                     total: 8000000000,
-                    usage: 50
+                    usage: 50,
                 },
                 disk: {
                     used: this.getLatestValue(systemMetrics['disk-usage']) || 0,
                     free: 100000000000,
                     total: 500000000000,
                     usage: 20,
-                    iops: 1000
+                    iops: 1000,
                 },
                 network: {
                     bytesIn: 1000000,
                     bytesOut: 2000000,
                     packetsIn: 5000,
                     packetsOut: 6000,
-                    errors: 5
-                }
+                    errors: 5,
+                },
             },
             application: {
                 responseTime: {
                     avg: this.getLatestValue(appMetrics['response-time']) || 0,
                     p50: 150,
                     p95: 500,
-                    p99: 1000
+                    p99: 1000,
                 },
                 throughput: {
                     requestsPerSecond: this.getLatestValue(appMetrics['request-rate']) || 0,
-                    transactionsPerSecond: 50
+                    transactionsPerSecond: 50,
                 },
                 errors: {
                     rate: this.getLatestValue(appMetrics['error-rate']) || 0,
                     count: 10,
-                    types: { '500': 5, '404': 3, '400': 2 }
+                    types: { '500': 5, '404': 3, '400': 2 },
                 },
                 availability: {
                     uptime: this.getLatestValue(appMetrics['uptime']) || 0,
                     sla: 99.9,
-                    incidents: 2
-                }
+                    incidents: 2,
+                },
             },
             database: {
                 connections: {
                     active: 25,
                     idle: 75,
-                    max: 100
+                    max: 100,
                 },
                 queries: {
                     avgExecutionTime: this.getLatestValue(dbMetrics['query-time']) || 0,
                     slowQueries: 5,
-                    deadlocks: 0
+                    deadlocks: 0,
                 },
                 storage: {
                     size: this.getLatestValue(dbMetrics['db-size']) || 0,
                     growth: 1000000, // bytes per day
-                    fragmentation: 5
-                }
+                    fragmentation: 5,
+                },
             },
             infrastructure: {
                 containers: {
                     running: 12,
                     stopped: 2,
-                    restarts: 3
+                    restarts: 3,
                 },
                 services: {
                     healthy: 15,
                     unhealthy: 1,
-                    degraded: 0
-                }
-            }
+                    degraded: 0,
+                },
+            },
         };
     }
     async getUsageMetrics(timeRange) {
         const range = timeRange || {
             start: new Date(Date.now() - 24 * 60 * 60 * 1000), // Last 24 hours
-            end: new Date()
+            end: new Date(),
         };
         const usageData = await this.queryMetrics({
             metrics: ['active-users', 'sessions', 'api-calls', 'feature-usage'],
             timeRange: range,
-            aggregation: 'sum'
+            aggregation: 'sum',
         });
         return {
             users: {
@@ -355,25 +354,25 @@ export class AnalyticsManager extends EventEmitter {
                 active: this.getLatestValue(usageData['active-users']) || 0,
                 new: 50,
                 returning: 1500,
-                churn: 25
+                churn: 25,
             },
             sessions: {
                 total: this.getLatestValue(usageData['sessions']) || 0,
                 duration: {
                     avg: 15 * 60, // 15 minutes
-                    median: 12 * 60
+                    median: 12 * 60,
                 },
                 bounceRate: 25,
-                pagesPerSession: 4.5
+                pagesPerSession: 4.5,
             },
             features: {
                 adoption: {
-                    'dashboard': { users: 800, usage: 5000, retention: 85 },
-                    'reports': { users: 600, usage: 2000, retention: 70 },
-                    'analytics': { users: 400, usage: 1500, retention: 60 }
+                    dashboard: { users: 800, usage: 5000, retention: 85 },
+                    reports: { users: 600, usage: 2000, retention: 70 },
+                    analytics: { users: 400, usage: 1500, retention: 60 },
                 },
                 mostUsed: ['dashboard', 'reports', 'search'],
-                leastUsed: ['advanced-filters', 'export', 'integrations']
+                leastUsed: ['advanced-filters', 'export', 'integrations'],
             },
             api: {
                 calls: this.getLatestValue(usageData['api-calls']) || 0,
@@ -382,15 +381,15 @@ export class AnalyticsManager extends EventEmitter {
                 errorRate: 2.5,
                 rateLimits: {
                     hit: 5,
-                    consumed: 75
-                }
+                    consumed: 75,
+                },
             },
             content: {
                 created: 100,
                 modified: 250,
                 deleted: 25,
-                views: 5000
-            }
+                views: 5000,
+            },
         };
     }
     async getBusinessMetrics(timeRange) {
@@ -401,28 +400,28 @@ export class AnalyticsManager extends EventEmitter {
                 recurring: 800000,
                 growth: 15,
                 arpu: 100,
-                ltv: 2400
+                ltv: 2400,
             },
             customers: {
                 total: 500,
                 new: 25,
                 retained: 450,
                 churned: 10,
-                satisfaction: 4.2
+                satisfaction: 4.2,
             },
             conversion: {
                 leads: 1000,
                 qualified: 400,
                 opportunities: 200,
                 closed: 50,
-                rate: 5
+                rate: 5,
             },
             support: {
                 tickets: 150,
                 resolved: 140,
                 avgResolutionTime: 4 * 60 * 60, // 4 hours
-                satisfaction: 4.5
-            }
+                satisfaction: 4.5,
+            },
         };
     }
     // Private helper methods
@@ -432,57 +431,57 @@ export class AnalyticsManager extends EventEmitter {
                 enabled: true,
                 samplingRate: 1.0,
                 batchSize: 1000,
-                flushInterval: 60000
+                flushInterval: 60000,
             },
             storage: {
                 retention: {
                     raw: '7d',
                     aggregated: '90d',
-                    summary: '1y'
+                    summary: '1y',
                 },
                 compression: true,
-                encryption: false
+                encryption: false,
             },
             processing: {
                 realTime: true,
                 batchProcessing: true,
-                aggregationIntervals: ['1m', '5m', '1h', '1d']
+                aggregationIntervals: ['1m', '5m', '1h', '1d'],
             },
             alerts: {
                 enabled: true,
                 channels: ['email', 'slack'],
                 escalation: {
                     levels: 3,
-                    intervals: [5, 15, 30] // minutes
-                }
+                    intervals: [5, 15, 30], // minutes
+                },
             },
             privacy: {
                 anonymization: true,
                 gdprCompliant: true,
-                dataMinimization: true
+                dataMinimization: true,
             },
-            integrations: {}
+            integrations: {},
         };
     }
     async loadConfigurations() {
         try {
             // Load dashboards
             const dashboardFiles = await readdir(join(this.analyticsPath, 'dashboards'));
-            for (const file of dashboardFiles.filter(f => f.endsWith('.json'))) {
+            for (const file of dashboardFiles.filter((f) => f.endsWith('.json'))) {
                 const content = await readFile(join(this.analyticsPath, 'dashboards', file), 'utf-8');
                 const dashboard = JSON.parse(content);
                 this.dashboards.set(dashboard.id, dashboard);
             }
             // Load insights
             const insightFiles = await readdir(join(this.analyticsPath, 'insights'));
-            for (const file of insightFiles.filter(f => f.endsWith('.json'))) {
+            for (const file of insightFiles.filter((f) => f.endsWith('.json'))) {
                 const content = await readFile(join(this.analyticsPath, 'insights', file), 'utf-8');
                 const insight = JSON.parse(content);
                 this.insights.set(insight.id, insight);
             }
             // Load models
             const modelFiles = await readdir(join(this.analyticsPath, 'models'));
-            for (const file of modelFiles.filter(f => f.endsWith('.json'))) {
+            for (const file of modelFiles.filter((f) => f.endsWith('.json'))) {
                 const content = await readFile(join(this.analyticsPath, 'models', file), 'utf-8');
                 const model = JSON.parse(content);
                 this.models.set(model.id, model);
@@ -510,14 +509,14 @@ export class AnalyticsManager extends EventEmitter {
                             metrics: ['cpu-usage'],
                             aggregation: 'avg',
                             timeRange: '1h',
-                            groupBy: []
+                            groupBy: [],
                         },
                         visualization: {
                             chartType: 'gauge',
                             options: { max: 100, unit: '%' },
-                            thresholds: { warning: 70, critical: 90 }
+                            thresholds: { warning: 70, critical: 90 },
                         },
-                        alerts: { enabled: true, conditions: [] }
+                        alerts: { enabled: true, conditions: [] },
                     },
                     {
                         title: 'Memory Usage',
@@ -529,14 +528,14 @@ export class AnalyticsManager extends EventEmitter {
                             metrics: ['memory-usage'],
                             aggregation: 'avg',
                             timeRange: '1h',
-                            groupBy: []
+                            groupBy: [],
                         },
                         visualization: {
                             chartType: 'gauge',
                             options: { max: 100, unit: '%' },
-                            thresholds: { warning: 80, critical: 95 }
+                            thresholds: { warning: 80, critical: 95 },
                         },
-                        alerts: { enabled: true, conditions: [] }
+                        alerts: { enabled: true, conditions: [] },
                     },
                     {
                         title: 'Response Time',
@@ -548,15 +547,15 @@ export class AnalyticsManager extends EventEmitter {
                             metrics: ['response-time'],
                             aggregation: 'avg',
                             timeRange: '24h',
-                            groupBy: ['service']
+                            groupBy: ['service'],
                         },
                         visualization: {
                             chartType: 'line',
-                            options: { unit: 'ms' }
+                            options: { unit: 'ms' },
                         },
-                        alerts: { enabled: false, conditions: [] }
-                    }
-                ]
+                        alerts: { enabled: false, conditions: [] },
+                    },
+                ],
             },
             {
                 name: 'Business KPIs',
@@ -573,18 +572,18 @@ export class AnalyticsManager extends EventEmitter {
                             metrics: ['active-users'],
                             aggregation: 'count',
                             timeRange: '24h',
-                            groupBy: []
+                            groupBy: [],
                         },
                         visualization: {
-                            options: { unit: 'users' }
+                            options: { unit: 'users' },
                         },
-                        alerts: { enabled: false, conditions: [] }
-                    }
-                ]
-            }
+                        alerts: { enabled: false, conditions: [] },
+                    },
+                ],
+            },
         ];
         for (const dashboardData of defaultDashboards) {
-            if (!Array.from(this.dashboards.values()).some(d => d.name === dashboardData.name)) {
+            if (!Array.from(this.dashboards.values()).some((d) => d.name === dashboardData.name)) {
                 await this.createDashboard(dashboardData);
             }
         }
@@ -612,7 +611,7 @@ export class AnalyticsManager extends EventEmitter {
                 value: Math.random() * 100,
                 tags: { host: 'localhost', service: 'system' },
                 source: 'system-monitor',
-                metadata: {}
+                metadata: {},
             });
             await this.recordMetric({
                 name: 'memory-usage',
@@ -623,7 +622,7 @@ export class AnalyticsManager extends EventEmitter {
                 value: Math.random() * 100,
                 tags: { host: 'localhost', service: 'system' },
                 source: 'system-monitor',
-                metadata: {}
+                metadata: {},
             });
             await this.recordMetric({
                 name: 'disk-usage',
@@ -634,7 +633,7 @@ export class AnalyticsManager extends EventEmitter {
                 value: Math.random() * 100,
                 tags: { host: 'localhost', service: 'system' },
                 source: 'system-monitor',
-                metadata: {}
+                metadata: {},
             });
         }
         catch (error) {
@@ -653,7 +652,7 @@ export class AnalyticsManager extends EventEmitter {
                 value: Math.random() * 1000 + 100,
                 tags: { service: 'api', endpoint: '/users' },
                 source: 'application',
-                metadata: {}
+                metadata: {},
             });
             await this.recordMetric({
                 name: 'request-rate',
@@ -664,7 +663,7 @@ export class AnalyticsManager extends EventEmitter {
                 value: Math.random() * 100 + 10,
                 tags: { service: 'api' },
                 source: 'application',
-                metadata: {}
+                metadata: {},
             });
             await this.recordMetric({
                 name: 'error-rate',
@@ -675,7 +674,7 @@ export class AnalyticsManager extends EventEmitter {
                 value: Math.random() * 5,
                 tags: { service: 'api' },
                 source: 'application',
-                metadata: {}
+                metadata: {},
             });
         }
         catch (error) {
@@ -725,7 +724,7 @@ export class AnalyticsManager extends EventEmitter {
                     timeRange: { start: recent[0].timestamp, end: metric.timestamp },
                     values: { current: metric.value, average, stdDev },
                     baseline: { average, stdDev },
-                    deviation
+                    deviation,
                 },
                 recommendations: [
                     {
@@ -735,13 +734,13 @@ export class AnalyticsManager extends EventEmitter {
                         implementation: [
                             'Check recent deployments or configuration changes',
                             'Review system logs for errors or warnings',
-                            'Monitor related metrics for correlation'
-                        ]
-                    }
+                            'Monitor related metrics for correlation',
+                        ],
+                    },
                 ],
                 status: 'new',
                 createdAt: new Date(),
-                updatedAt: new Date()
+                updatedAt: new Date(),
             };
             this.insights.set(insight.id, insight);
             await this.saveInsight(insight);
@@ -749,7 +748,7 @@ export class AnalyticsManager extends EventEmitter {
             this.logger.warn(`Anomaly detected in ${metric.name}`, {
                 current: metric.value,
                 average,
-                deviation
+                deviation,
             });
         }
     }
@@ -767,7 +766,7 @@ export class AnalyticsManager extends EventEmitter {
         const responseTimeData = await this.queryMetrics({
             metrics: ['response-time'],
             timeRange,
-            aggregation: 'avg'
+            aggregation: 'avg',
         });
         if (responseTimeData['response-time']?.length > 0) {
             const values = responseTimeData['response-time'].map((d) => d.value);
@@ -792,33 +791,35 @@ export class AnalyticsManager extends EventEmitter {
                             timeRange,
                             values: { recent: recentAvg, earlier: earlierAvg, change },
                         },
-                        recommendations: change > 0 ? [
-                            {
-                                action: 'Investigate performance degradation',
-                                effort: 'medium',
-                                impact: 'Restore optimal response times',
-                                implementation: [
-                                    'Check for increased load or traffic',
-                                    'Review recent code deployments',
-                                    'Analyze database query performance',
-                                    'Monitor resource utilization'
-                                ]
-                            }
-                        ] : [
-                            {
-                                action: 'Document performance improvement',
-                                effort: 'low',
-                                impact: 'Understand what caused the improvement',
-                                implementation: [
-                                    'Identify recent optimizations',
-                                    'Document best practices',
-                                    'Monitor sustainability'
-                                ]
-                            }
-                        ],
+                        recommendations: change > 0
+                            ? [
+                                {
+                                    action: 'Investigate performance degradation',
+                                    effort: 'medium',
+                                    impact: 'Restore optimal response times',
+                                    implementation: [
+                                        'Check for increased load or traffic',
+                                        'Review recent code deployments',
+                                        'Analyze database query performance',
+                                        'Monitor resource utilization',
+                                    ],
+                                },
+                            ]
+                            : [
+                                {
+                                    action: 'Document performance improvement',
+                                    effort: 'low',
+                                    impact: 'Understand what caused the improvement',
+                                    implementation: [
+                                        'Identify recent optimizations',
+                                        'Document best practices',
+                                        'Monitor sustainability',
+                                    ],
+                                },
+                            ],
                         status: 'new',
                         createdAt: new Date(),
-                        updatedAt: new Date()
+                        updatedAt: new Date(),
                     });
                 }
             }
@@ -838,7 +839,7 @@ export class AnalyticsManager extends EventEmitter {
         const data = await this.queryMetrics({
             metrics: model.features,
             timeRange: model.trainingData.timeRange,
-            aggregation: 'avg'
+            aggregation: 'avg',
         });
         // Transform data for ML training (simplified)
         return Object.values(data).flat();
@@ -851,12 +852,12 @@ export class AnalyticsManager extends EventEmitter {
             performance: {
                 precision: 0.85,
                 recall: 0.82,
-                f1Score: 0.83
+                f1Score: 0.83,
             },
             trainingData: {
                 ...model.trainingData,
-                samples: data.length
-            }
+                samples: data.length,
+            },
         };
     }
     async executePrediction(model, input) {
@@ -868,12 +869,16 @@ export class AnalyticsManager extends EventEmitter {
     groupMetrics(metrics, groupBy) {
         const groups = {};
         for (const metric of metrics) {
-            const key = groupBy.map(field => {
+            const key = groupBy
+                .map((field) => {
                 if (field === 'tags') {
-                    return Object.entries(metric.tags).map(([k, v]) => `${k}:${v}`).join(',');
+                    return Object.entries(metric.tags)
+                        .map(([k, v]) => `${k}:${v}`)
+                        .join(',');
                 }
                 return metric[field] || 'unknown';
-            }).join('-');
+            })
+                .join('-');
             if (!groups[key]) {
                 groups[key] = [];
             }
@@ -893,8 +898,9 @@ export class AnalyticsManager extends EventEmitter {
             }
             buckets[bucket].push(metric);
         }
-        return Object.entries(buckets).map(([timestamp, bucketMetrics]) => {
-            const values = bucketMetrics.map(m => m.value);
+        return Object.entries(buckets)
+            .map(([timestamp, bucketMetrics]) => {
+            const values = bucketMetrics.map((m) => m.value);
             let aggregatedValue;
             switch (aggregation) {
                 case 'sum':
@@ -924,9 +930,10 @@ export class AnalyticsManager extends EventEmitter {
             return {
                 timestamp: new Date(timestamp),
                 value: aggregatedValue,
-                count: values.length
+                count: values.length,
             };
-        }).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        })
+            .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
     }
     getLatestValue(dataPoints) {
         if (!dataPoints || dataPoints.length === 0)