@jagilber-org/index-server 1.19.1

package/dist/config/serverConfig.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseServerConfig = parseServerConfig;
+exports.parseLoggingConfig = parseLoggingConfig;
+exports.parseMetricsConfig = parseMetricsConfig;
+exports.parseAtomicFsConfig = parseAtomicFsConfig;
+exports.parsePreflightConfig = parsePreflightConfig;
+exports.parseTracingConfig = parseTracingConfig;
+/**
+ * Server domain config: MCP server, bootstrap, transport, protocol, logging,
+ * metrics, tracing, atomicFs, and preflight settings.
+ */
+const path_1 = __importDefault(require("path"));
+const envUtils_1 = require("../utils/envUtils");
+const configUtils_1 = require("./configUtils");
+const dirConstants_1 = require("./dirConstants");
+const defaultValues_1 = require("./defaultValues");
+function parseServerConfig() {
+    const sharedSentinel = process.env.INDEX_SERVER_SHARED_SERVER_SENTINEL;
+    const rawMode = (process.env.INDEX_SERVER_MODE || 'standalone').trim().toLowerCase();
+    const validModes = ['standalone', 'leader', 'follower', 'auto'];
+    const instanceMode = validModes.includes(rawMode)
+        ? rawMode
+        : 'standalone';
+    return {
+        disableEarlyStdinBuffer: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DISABLE_EARLY_STDIN_BUFFER'),
+        fatalExitDelayMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_FATAL_EXIT_DELAY_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.FATAL_EXIT_DELAY),
+        idleKeepaliveMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_IDLE_KEEPALIVE_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.IDLE_KEEPALIVE),
+        sharedSentinel: sharedSentinel && sharedSentinel.trim().length ? sharedSentinel : undefined,
+        bootstrap: {
+            autoconfirm: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_BOOTSTRAP_AUTOCONFIRM'),
+            tokenTtlSec: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_BOOTSTRAP_TOKEN_TTL_SEC', defaultValues_1.DEFAULT_PORTS.BOOTSTRAP_TOKEN_TTL_SEC),
+            referenceMode: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_REFERENCE_MODE'),
+        },
+        indexPolling: {
+            enabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_ENABLE_INDEX_SERVER_POLLER'),
+            proactive: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_POLL_PROACTIVE'),
+            intervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_POLL_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.POLL_INTERVAL),
+        },
+        multicoreTrace: (0, envUtils_1.getBooleanEnv)('MULTICLIENT_TRACE'),
+        instanceMode,
+        leaderPort: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_LEADER_PORT', defaultValues_1.DEFAULT_PORTS.LEADER),
+        heartbeatIntervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_HEARTBEAT_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.HEARTBEAT),
+        staleThresholdMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_STALE_THRESHOLD_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.STALE_THRESHOLD),
+    };
+}
+function resolveLogFile() {
+    const raw = process.env.INDEX_SERVER_LOG_FILE;
+    if (!raw)
+        return { raw: undefined, sentinelRequested: false };
+    const normalized = raw.trim().toLowerCase();
+    const isSentinel = raw === '1' || ['true', 'yes', 'on'].includes(normalized);
+    if (isSentinel) {
+        return {
+            file: (0, configUtils_1.toAbsolute)(path_1.default.join(dirConstants_1.DIR.LOGS_MCP_SERVER)),
+            raw,
+            sentinelRequested: true,
+        };
+    }
+    return { file: (0, configUtils_1.toAbsolute)(raw), raw, sentinelRequested: false };
+}
+function parseLoggingConfig(level) {
+    const fileInfo = resolveLogFile();
+    return {
+        level,
+        verbose: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_VERBOSE_LOGGING') || (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DEBUG'),
+        json: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_JSON'),
+        sync: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_SYNC'),
+        diagnostics: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_DIAG'),
+        protocol: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_LOG_PROTOCOL'),
+        file: fileInfo.file,
+        rawFileValue: fileInfo.raw,
+        sentinelRequested: fileInfo.sentinelRequested,
+    };
+}
+function parseMetricsConfig() {
+    return {
+        dir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_METRICS_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.METRICS)),
+        resourceCapacity: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_RESOURCE_CAPACITY', defaultValues_1.DEFAULT_THRESHOLDS.RESOURCE_CAPACITY),
+        sampleIntervalMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_RESOURCE_SAMPLE_INTERVAL_MS', defaultValues_1.DEFAULT_THRESHOLDS.RESOURCE_SAMPLE_INTERVAL_MS),
+        toolcall: {
+            chunkSize: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_TOOLCALL_CHUNK_SIZE', defaultValues_1.DEFAULT_LIMITS.TOOLCALL_CHUNK_SIZE),
+            flushMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_TOOLCALL_FLUSH_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.TOOLCALL_FLUSH),
+            compactMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_TOOLCALL_COMPACT_MS', defaultValues_1.DEFAULT_TIMEOUTS_MS.TOOLCALL_COMPACT),
+            appendLogEnabled: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TOOLCALL_APPEND_LOG'),
+        },
+        health: {
+            memoryThreshold: (0, configUtils_1.floatFromEnv)('INDEX_SERVER_HEALTH_MEMORY_THRESHOLD', defaultValues_1.DEFAULT_THRESHOLDS.MEMORY_THRESHOLD),
+            errorRateThreshold: (0, configUtils_1.floatFromEnv)('INDEX_SERVER_HEALTH_ERROR_THRESHOLD', defaultValues_1.DEFAULT_THRESHOLDS.ERROR_RATE_THRESHOLD),
+            minUptimeMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_HEALTH_MIN_UPTIME', defaultValues_1.DEFAULT_TIMEOUTS_MS.HEALTH_MIN_UPTIME),
+        },
+        fileStorage: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_METRICS_FILE_STORAGE'),
+    };
+}
+function parseAtomicFsConfig() {
+    return {
+        retries: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_ATOMIC_WRITE_RETRIES', defaultValues_1.DEFAULT_LIMITS.ATOMIC_WRITE_RETRIES),
+        backoffMs: (0, configUtils_1.numberFromEnv)('INDEX_SERVER_ATOMIC_WRITE_BACKOFF_MS', defaultValues_1.DEFAULT_LIMITS.ATOMIC_WRITE_BACKOFF_MS),
+    };
+}
+function parsePreflightConfig() {
+    const modules = (0, configUtils_1.parseCsvEnv)('INDEX_SERVER_PREFLIGHT_MODULES');
+    return {
+        modules: modules.length ? modules : ['mime-db', 'ajv', 'ajv-formats'],
+        strict: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_PREFLIGHT_STRICT'),
+    };
+}
+function resolveTraceLevel(traceSet, fallbackLevel) {
+    const raw = process.env.INDEX_SERVER_TRACE_LEVEL?.toLowerCase();
+    switch (raw) {
+        case 'verbose': return 'verbose';
+        case 'trace':
+        case 'files':
+        case 'perf':
+            return 'trace';
+        case 'debug':
+        case 'core':
+            return 'debug';
+        case 'warn':
+            return 'warn';
+        case 'error':
+            return 'error';
+        default:
+            if (traceSet.has('verbose'))
+                return 'verbose';
+            if (traceSet.size > 0)
+                return 'trace';
+            return fallbackLevel;
+    }
+}
+function resolveTracingBuffer() {
+    const rawFile = process.env.INDEX_SERVER_TRACE_BUFFER_FILE;
+    const trimmed = rawFile?.trim();
+    const file = trimmed && trimmed.length ? (0, configUtils_1.toAbsolute)(trimmed) : undefined;
+    const sizeBytes = (0, configUtils_1.optionalNumberFromEnv)('INDEX_SERVER_TRACE_BUFFER_SIZE') ?? 0;
+    const dumpOnExit = (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_BUFFER_DUMP_ON_EXIT');
+    return { file, sizeBytes, dumpOnExit };
+}
+function parseTracingConfig(traceSet, fallbackLevel) {
+    const categories = new Set((0, configUtils_1.parseCsvEnv)('INDEX_SERVER_TRACE_CATEGORIES'));
+    const buffer = resolveTracingBuffer();
+    const filePath = (() => {
+        const raw = process.env.INDEX_SERVER_TRACE_FILE;
+        if (!raw)
+            return undefined;
+        const trimmed = raw.trim();
+        return trimmed.length ? (0, configUtils_1.toAbsolute)(trimmed) : undefined;
+    })();
+    return {
+        level: resolveTraceLevel(traceSet, fallbackLevel),
+        categories,
+        buffer,
+        file: filePath,
+        persist: (0, envUtils_1.parseBooleanEnv)(process.env.INDEX_SERVER_TRACE_PERSIST, !!filePath),
+        dir: (0, configUtils_1.toAbsolute)(process.env.INDEX_SERVER_TRACE_DIR, path_1.default.join(configUtils_1.CWD, dirConstants_1.DIR.LOGS_TRACE)),
+        fsync: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_FSYNC'),
+        maxFileSizeBytes: (0, configUtils_1.optionalIntFromEnv)('INDEX_SERVER_TRACE_MAX_FILE_SIZE') ?? 0,
+        sessionId: process.env.INDEX_SERVER_TRACE_SESSION || undefined,
+        callsite: (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_TRACE_CALLSITE'),
+    };
+}

package/dist/dashboard/analytics/AnalyticsEngine.d.ts

@@ -0,0 +1,142 @@
+/**
+ * AnalyticsEngine - Phase 3 Advanced Analytics & Business Intelligence
+ *
+ * Analytics engine providing:
+ * - Real-time trend analysis and forecasting
+ * - Business intelligence metrics and KPIs
+ * - Performance analytics and optimization insights
+ * - Usage pattern recognition and anomaly detection
+ */
+export interface TimeSeriesData {
+    timestamp: number;
+    value: number;
+    metadata?: Record<string, string | number | boolean>;
+}
+export interface TrendAnalysis {
+    trend: 'increasing' | 'decreasing' | 'stable' | 'volatile';
+    confidence: number;
+    slope: number;
+    correlation: number;
+    forecast: TimeSeriesData[];
+    seasonality?: {
+        detected: boolean;
+        period: number;
+        strength: number;
+    };
+}
+export interface BusinessMetrics {
+    totalRequests: number;
+    successRate: number;
+    averageResponseTime: number;
+    errorRate: number;
+    throughput: number;
+    latencyPercentiles: {
+        p50: number;
+        p90: number;
+        p95: number;
+        p99: number;
+    };
+    topTools: Array<{
+        name: string;
+        usage: number;
+        trend: number;
+        revenue?: number;
+    }>;
+    userSegmentation: {
+        powerUsers: number;
+        regularUsers: number;
+        casualUsers: number;
+    };
+    growthRate: number;
+    retentionRate: number;
+    churnRate: number;
+}
+export interface AnomalyDetection {
+    anomalies: Array<{
+        timestamp: number;
+        value: number;
+        severity: 'low' | 'medium' | 'high' | 'critical';
+        type: 'spike' | 'drop' | 'outlier' | 'pattern_break';
+        description: string;
+        confidence: number;
+    }>;
+    patterns: Array<{
+        name: string;
+        description: string;
+        frequency: number;
+        lastSeen: number;
+    }>;
+}
+export interface PredictiveInsights {
+    nextHourForecast: TimeSeriesData[];
+    nextDayForecast: TimeSeriesData[];
+    nextWeekForecast: TimeSeriesData[];
+    recommendations: Array<{
+        type: 'optimization' | 'scaling' | 'maintenance' | 'business';
+        priority: 'low' | 'medium' | 'high' | 'critical';
+        title: string;
+        description: string;
+        impact: string;
+        effort: 'low' | 'medium' | 'high';
+        expectedRoi?: number;
+    }>;
+    alerts: Array<{
+        id: string;
+        type: 'performance' | 'capacity' | 'security' | 'business';
+        severity: 'info' | 'warning' | 'error' | 'critical';
+        message: string;
+        timestamp: number;
+        actionRequired: boolean;
+    }>;
+}
+export declare class AnalyticsEngine {
+    private timeSeriesData;
+    private businessMetrics;
+    private anomaliesHistory;
+    constructor();
+    private initializeMetrics;
+    /**
+     * Add time series data point for analysis
+     */
+    addDataPoint(metric: string, value: number, metadata?: Record<string, string | number | boolean>): void;
+    /**
+     * Perform trend analysis on time series data
+     */
+    analyzeTrend(metric: string, lookbackHours?: number): TrendAnalysis | null;
+    /**
+     * Detect anomalies in time series data
+     */
+    detectAnomalies(metric: string): AnomalyDetection;
+    /**
+     * Generate predictive insights and recommendations
+     */
+    generateInsights(): PredictiveInsights;
+    /**
+     * Get current business metrics
+     */
+    getBusinessMetrics(): BusinessMetrics;
+    /**
+     * Get time series data for visualization
+     */
+    getTimeSeriesData(metric: string, hours?: number): TimeSeriesData[];
+    /**
+     * Get available metrics list
+     */
+    getAvailableMetrics(): string[];
+    private calculateLinearRegression;
+    private determineTrend;
+    private calculateVolatility;
+    private generateForecast;
+    private detectSeasonality;
+    private calculateSeasonalStrength;
+    private findAnomalies;
+    private identifyPatterns;
+    private calculateHourlyAverages;
+    private generateRecommendations;
+    private generateAlerts;
+    private generateMetricForecast;
+    private updateBusinessMetrics;
+    private startAnalyticsLoop;
+    private performBackgroundAnalytics;
+}
+export declare function getAnalyticsEngine(): AnalyticsEngine;

package/dist/dashboard/analytics/AnalyticsEngine.js

@@ -0,0 +1,373 @@
+"use strict";
+/**
+ * AnalyticsEngine - Phase 3 Advanced Analytics & Business Intelligence
+ *
+ * Analytics engine providing:
+ * - Real-time trend analysis and forecasting
+ * - Business intelligence metrics and KPIs
+ * - Performance analytics and optimization insights
+ * - Usage pattern recognition and anomaly detection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsEngine = void 0;
+exports.getAnalyticsEngine = getAnalyticsEngine;
+class AnalyticsEngine {
+    timeSeriesData = new Map();
+    businessMetrics;
+    anomaliesHistory = [];
+    constructor() {
+        this.businessMetrics = this.initializeMetrics();
+        this.startAnalyticsLoop();
+    }
+    initializeMetrics() {
+        return {
+            totalRequests: 0,
+            successRate: 0.0,
+            averageResponseTime: 0,
+            errorRate: 0.0,
+            throughput: 0,
+            latencyPercentiles: { p50: 0, p90: 0, p95: 0, p99: 0 },
+            topTools: [],
+            userSegmentation: { powerUsers: 0, regularUsers: 0, casualUsers: 0 },
+            growthRate: 0,
+            retentionRate: 0,
+            churnRate: 0
+        };
+    }
+    /**
+     * Add time series data point for analysis
+     */
+    addDataPoint(metric, value, metadata) {
+        const dataPoint = {
+            timestamp: Date.now(),
+            value,
+            metadata
+        };
+        if (!this.timeSeriesData.has(metric)) {
+            this.timeSeriesData.set(metric, []);
+        }
+        const series = this.timeSeriesData.get(metric);
+        series.push(dataPoint);
+        // Keep only last 24 hours of data for performance
+        const twentyFourHoursAgo = Date.now() - (24 * 60 * 60 * 1000);
+        this.timeSeriesData.set(metric, series.filter(point => point.timestamp > twentyFourHoursAgo));
+        this.updateBusinessMetrics(metric, value, metadata);
+    }
+    /**
+     * Perform trend analysis on time series data
+     */
+    analyzeTrend(metric, lookbackHours = 1) {
+        const series = this.timeSeriesData.get(metric);
+        if (!series || series.length < 10)
+            return null;
+        const lookbackMs = lookbackHours * 60 * 60 * 1000;
+        const cutoff = Date.now() - lookbackMs;
+        const recentData = series.filter(point => point.timestamp >= cutoff);
+        if (recentData.length < 5)
+            return null;
+        // Calculate linear regression
+        const { slope, correlation } = this.calculateLinearRegression(recentData);
+        // Determine trend direction
+        const trend = this.determineTrend(slope, recentData);
+        // Calculate confidence based on correlation and data points
+        const confidence = Math.min(0.95, Math.abs(correlation) * (recentData.length / 100));
+        // Generate forecast
+        const forecast = this.generateForecast(recentData, slope, 12); // 12 future points
+        // Detect seasonality
+        const seasonality = this.detectSeasonality(series);
+        return {
+            trend,
+            confidence,
+            slope,
+            correlation,
+            forecast,
+            seasonality
+        };
+    }
+    /**
+     * Detect anomalies in time series data
+     */
+    detectAnomalies(metric) {
+        const series = this.timeSeriesData.get(metric) || [];
+        if (series.length < 20) {
+            return { anomalies: [], patterns: [] };
+        }
+        const anomalies = this.findAnomalies(series);
+        const patterns = this.identifyPatterns(series);
+        return { anomalies, patterns };
+    }
+    /**
+     * Generate predictive insights and recommendations
+     */
+    generateInsights() {
+        const recommendations = this.generateRecommendations();
+        const alerts = this.generateAlerts();
+        // Generate forecasts for key metrics
+        const nextHourForecast = this.generateMetricForecast('requests_per_minute', 60);
+        const nextDayForecast = this.generateMetricForecast('requests_per_hour', 24);
+        const nextWeekForecast = this.generateMetricForecast('requests_per_day', 7);
+        return {
+            nextHourForecast,
+            nextDayForecast,
+            nextWeekForecast,
+            recommendations,
+            alerts
+        };
+    }
+    /**
+     * Get current business metrics
+     */
+    getBusinessMetrics() {
+        return { ...this.businessMetrics };
+    }
+    /**
+     * Get time series data for visualization
+     */
+    getTimeSeriesData(metric, hours = 1) {
+        const series = this.timeSeriesData.get(metric) || [];
+        const cutoff = Date.now() - (hours * 60 * 60 * 1000);
+        return series.filter(point => point.timestamp >= cutoff);
+    }
+    /**
+     * Get available metrics list
+     */
+    getAvailableMetrics() {
+        return Array.from(this.timeSeriesData.keys());
+    }
+    // Private helper methods
+    calculateLinearRegression(data) {
+        const n = data.length;
+        if (n < 2)
+            return { slope: 0, correlation: 0 };
+        const x = data.map(point => point.timestamp);
+        const y = data.map(point => point.value);
+        const sumX = x.reduce((a, b) => a + b, 0);
+        const sumY = y.reduce((a, b) => a + b, 0);
+        const sumXY = x.reduce((total, xi, i) => total + xi * y[i], 0);
+        const sumXX = x.reduce((total, xi) => total + xi * xi, 0);
+        const sumYY = y.reduce((total, yi) => total + yi * yi, 0);
+        const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+        const numerator = n * sumXY - sumX * sumY;
+        const denominator = Math.sqrt((n * sumXX - sumX * sumX) * (n * sumYY - sumY * sumY));
+        const correlation = denominator === 0 ? 0 : numerator / denominator;
+        return { slope, correlation };
+    }
+    determineTrend(slope, data) {
+        const values = data.map(point => point.value);
+        const volatility = this.calculateVolatility(values);
+        if (volatility > 0.5)
+            return 'volatile';
+        if (Math.abs(slope) < 0.001)
+            return 'stable';
+        return slope > 0 ? 'increasing' : 'decreasing';
+    }
+    calculateVolatility(values) {
+        if (values.length < 2)
+            return 0;
+        const mean = values.reduce((a, b) => a + b, 0) / values.length;
+        const variance = values.reduce((total, value) => total + Math.pow(value - mean, 2), 0) / values.length;
+        const stdDev = Math.sqrt(variance);
+        return mean === 0 ? 0 : stdDev / Math.abs(mean);
+    }
+    generateForecast(data, slope, points) {
+        if (data.length === 0)
+            return [];
+        const lastPoint = data[data.length - 1];
+        const timeInterval = data.length > 1 ?
+            (lastPoint.timestamp - data[data.length - 2].timestamp) : 60000; // 1 minute default
+        const forecast = [];
+        for (let i = 1; i <= points; i++) {
+            const timestamp = lastPoint.timestamp + (i * timeInterval);
+            const value = Math.max(0, lastPoint.value + (slope * i * timeInterval));
+            forecast.push({
+                timestamp,
+                value,
+                metadata: { forecasted: true }
+            });
+        }
+        return forecast;
+    }
+    detectSeasonality(data) {
+        if (data.length < 48)
+            return { detected: false, period: 0, strength: 0 };
+        // Simple seasonality detection - check for repeating patterns
+        const values = data.map(point => point.value);
+        const periods = [12, 24, 48, 96]; // 5min, 10min, 20min, 40min intervals
+        let bestPeriod = 0;
+        let bestStrength = 0;
+        for (const period of periods) {
+            if (period * 2 > values.length)
+                continue;
+            const strength = this.calculateSeasonalStrength(values, period);
+            if (strength > bestStrength) {
+                bestStrength = strength;
+                bestPeriod = period;
+            }
+        }
+        return {
+            detected: bestStrength > 0.3,
+            period: bestPeriod,
+            strength: bestStrength
+        };
+    }
+    calculateSeasonalStrength(values, period) {
+        if (values.length < period * 2)
+            return 0;
+        let correlation = 0;
+        let count = 0;
+        for (let i = period; i < values.length; i++) {
+            correlation += values[i] * values[i - period];
+            count++;
+        }
+        return count === 0 ? 0 : Math.abs(correlation / count) / Math.max(1, Math.max(...values));
+    }
+    findAnomalies(data) {
+        if (data.length < 10)
+            return [];
+        const values = data.map(point => point.value);
+        const mean = values.reduce((a, b) => a + b, 0) / values.length;
+        const stdDev = Math.sqrt(values.reduce((total, value) => total + Math.pow(value - mean, 2), 0) / values.length);
+        const anomalies = [];
+        for (let i = 0; i < data.length; i++) {
+            const point = data[i];
+            const zScore = stdDev === 0 ? 0 : Math.abs(point.value - mean) / stdDev;
+            if (zScore > 2.5) {
+                const severity = zScore > 4 ? 'critical' : zScore > 3.5 ? 'high' : zScore > 3 ? 'medium' : 'low';
+                const type = point.value > mean ? 'spike' : 'drop';
+                anomalies.push({
+                    timestamp: point.timestamp,
+                    value: point.value,
+                    severity,
+                    type,
+                    description: `${type === 'spike' ? 'Unusual spike' : 'Unusual drop'} detected (${zScore.toFixed(1)}σ from mean)`,
+                    confidence: Math.min(0.95, zScore / 4)
+                });
+            }
+        }
+        return anomalies;
+    }
+    identifyPatterns(data) {
+        // Simple pattern identification - could be enhanced with more sophisticated algorithms
+        const patterns = [];
+        if (data.length >= 24) {
+            const hourlyAverages = this.calculateHourlyAverages(data);
+            const peakHour = hourlyAverages.indexOf(Math.max(...hourlyAverages));
+            patterns.push({
+                name: 'Daily Peak Pattern',
+                description: `Peak usage typically occurs around hour ${peakHour}`,
+                frequency: 1.0, // daily
+                lastSeen: Date.now()
+            });
+        }
+        return patterns;
+    }
+    calculateHourlyAverages(data) {
+        const hourlyBuckets = Array(24).fill(0).map(() => []);
+        data.forEach(point => {
+            const hour = new Date(point.timestamp).getHours();
+            hourlyBuckets[hour].push(point.value);
+        });
+        return hourlyBuckets.map(bucket => bucket.length === 0 ? 0 : bucket.reduce((a, b) => a + b, 0) / bucket.length);
+    }
+    generateRecommendations() {
+        const recommendations = [];
+        // Analyze current metrics and generate recommendations
+        if (this.businessMetrics.errorRate > 0.05) {
+            recommendations.push({
+                type: 'optimization',
+                priority: 'high',
+                title: 'Reduce Error Rate',
+                description: `Current error rate is ${(this.businessMetrics.errorRate * 100).toFixed(1)}%, which is above the 5% threshold`,
+                impact: 'Improve user experience and system reliability',
+                effort: 'medium',
+                expectedRoi: 0.15
+            });
+        }
+        if (this.businessMetrics.averageResponseTime > 1000) {
+            recommendations.push({
+                type: 'optimization',
+                priority: 'medium',
+                title: 'Optimize Response Times',
+                description: `Average response time is ${this.businessMetrics.averageResponseTime}ms, consider optimization`,
+                impact: 'Better user experience and increased throughput',
+                effort: 'medium',
+                expectedRoi: 0.12
+            });
+        }
+        return recommendations;
+    }
+    generateAlerts() {
+        const alerts = [];
+        const now = Date.now();
+        // Generate alerts based on current metrics
+        if (this.businessMetrics.errorRate > 0.1) {
+            alerts.push({
+                id: `error-rate-${now}`,
+                type: 'performance',
+                severity: 'critical',
+                message: `Error rate critically high: ${(this.businessMetrics.errorRate * 100).toFixed(1)}%`,
+                timestamp: now,
+                actionRequired: true
+            });
+        }
+        if (this.businessMetrics.throughput < 1) {
+            alerts.push({
+                id: `low-throughput-${now}`,
+                type: 'performance',
+                severity: 'warning',
+                message: 'Low throughput detected, consider investigating performance',
+                timestamp: now,
+                actionRequired: false
+            });
+        }
+        return alerts;
+    }
+    generateMetricForecast(metric, points) {
+        const trend = this.analyzeTrend(metric, 1);
+        return trend?.forecast.slice(0, points) || [];
+    }
+    updateBusinessMetrics(metric, value, _metadata) {
+        // Update business metrics based on incoming data
+        switch (metric) {
+            case 'total_requests':
+                this.businessMetrics.totalRequests = value;
+                break;
+            case 'response_time':
+                this.businessMetrics.averageResponseTime = value;
+                break;
+            case 'error_rate':
+                this.businessMetrics.errorRate = value;
+                break;
+            case 'throughput':
+                this.businessMetrics.throughput = value;
+                break;
+        }
+    }
+    startAnalyticsLoop() {
+        // Start background analytics processing
+        setInterval(() => {
+            this.performBackgroundAnalytics();
+        }, 60000); // Every minute
+    }
+    performBackgroundAnalytics() {
+        // Background processing for continuous analytics
+        const metrics = this.getAvailableMetrics();
+        metrics.forEach(metric => {
+            const anomalies = this.detectAnomalies(metric);
+            if (anomalies.anomalies.length > 0) {
+                this.anomaliesHistory.push(anomalies);
+                // Keep only recent history
+                this.anomaliesHistory = this.anomaliesHistory.slice(-100);
+            }
+        });
+    }
+}
+exports.AnalyticsEngine = AnalyticsEngine;
+// Singleton instance
+let analyticsEngine = null;
+function getAnalyticsEngine() {
+    if (!analyticsEngine) {
+        analyticsEngine = new AnalyticsEngine();
+    }
+    return analyticsEngine;
+}