@jagilber-org/index-server 1.22.0

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;
+}

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

@@ -0,0 +1,187 @@
+/**
+ * BusinessIntelligence - Phase 3 Advanced BI Components
+ *
+ * Comprehensive business intelligence dashboard components providing:
+ * - Executive dashboards with KPI visualizations
+ * - Advanced charting and data visualization
+ * - Interactive reporting and drill-down capabilities
+ * - Real-time business metrics monitoring
+ */
+export interface KPIWidget {
+    id: string;
+    title: string;
+    value: number | string;
+    previousValue?: number | string;
+    trend: 'up' | 'down' | 'stable';
+    trendPercentage: number;
+    format: 'number' | 'percentage' | 'currency' | 'duration' | 'bytes';
+    color: 'success' | 'warning' | 'danger' | 'info' | 'primary';
+    icon: string;
+    description?: string;
+}
+export interface ChartConfiguration {
+    id: string;
+    type: 'line' | 'bar' | 'doughnut' | 'radar' | 'scatter' | 'area' | 'heatmap';
+    title: string;
+    data: ChartDataset[];
+    options: ChartOptions;
+    responsive: boolean;
+    realTime: boolean;
+}
+export interface ChartDataset {
+    label: string;
+    data: Array<{
+        x: number | string;
+        y: number;
+    }>;
+    backgroundColor?: string | string[];
+    borderColor?: string;
+    borderWidth?: number;
+    fill?: boolean;
+    tension?: number;
+}
+export interface ChartOptions {
+    responsive: boolean;
+    maintainAspectRatio: boolean;
+    plugins: {
+        legend: {
+            display: boolean;
+            position: 'top' | 'bottom' | 'left' | 'right';
+        };
+        title: {
+            display: boolean;
+            text: string;
+        };
+        tooltip: {
+            enabled: boolean;
+            mode: 'index' | 'point' | 'dataset';
+        };
+    };
+    scales?: {
+        x: {
+            type: 'linear' | 'time' | 'category';
+            display: boolean;
+            title: {
+                display: boolean;
+                text: string;
+            };
+        };
+        y: {
+            type: 'linear' | 'logarithmic';
+            display: boolean;
+            beginAtZero: boolean;
+            title: {
+                display: boolean;
+                text: string;
+            };
+        };
+    };
+    animation?: {
+        duration: number;
+        easing: 'linear' | 'easeInQuad' | 'easeOutQuad';
+    };
+}
+export interface DashboardLayout {
+    sections: DashboardSection[];
+    theme: 'light' | 'dark' | 'auto';
+    layout: 'grid' | 'masonry' | 'flex';
+    columns: number;
+    refreshInterval: number;
+}
+export interface DashboardSection {
+    id: string;
+    title: string;
+    type: 'kpi' | 'chart' | 'table' | 'alert' | 'text' | 'custom';
+    position: {
+        row: number;
+        col: number;
+        width: number;
+        height: number;
+    };
+    config: KPIWidget | ChartConfiguration | TableConfiguration | AlertConfiguration;
+    visible: boolean;
+    minimized: boolean;
+}
+export interface TableConfiguration {
+    id: string;
+    title: string;
+    columns: Array<{
+        key: string;
+        label: string;
+        type: 'text' | 'number' | 'date' | 'badge' | 'progress';
+        sortable: boolean;
+        filterable: boolean;
+    }>;
+    data: Record<string, unknown>[];
+    pagination: {
+        enabled: boolean;
+        pageSize: number;
+        currentPage: number;
+    };
+    search: {
+        enabled: boolean;
+        placeholder: string;
+    };
+}
+export interface AlertConfiguration {
+    id: string;
+    title: string;
+    alerts: Array<{
+        id: string;
+        message: string;
+        severity: 'info' | 'warning' | 'error' | 'critical';
+        timestamp: number;
+        acknowledged: boolean;
+        actionUrl?: string;
+    }>;
+    maxVisible: number;
+    autoRefresh: boolean;
+}
+export declare class BusinessIntelligence {
+    private analyticsEngine;
+    private dashboardLayouts;
+    private realtimeSubscriptions;
+    constructor();
+    /**
+     * Generate KPI widgets based on current business metrics
+     */
+    generateKPIWidgets(): KPIWidget[];
+    /**
+     * Generate advanced chart configurations
+     */
+    generateChartConfigurations(): ChartConfiguration[];
+    /**
+     * Create executive dashboard layout
+     */
+    createExecutiveDashboard(): DashboardLayout;
+    /**
+     * Create operational dashboard layout
+     */
+    createOperationalDashboard(): DashboardLayout;
+    /**
+     * Get dashboard layout by name
+     */
+    getDashboardLayout(name: string): DashboardLayout | null;
+    /**
+     * Subscribe to real-time updates for a dashboard
+     */
+    subscribeToRealTimeUpdates(dashboardId: string, callback: (data: unknown) => void): string;
+    /**
+     * Unsubscribe from real-time updates
+     */
+    unsubscribeFromRealTimeUpdates(subscriptionId: string): void;
+    private initializeDefaultDashboards;
+    private formatNumber;
+    private calculateTrend;
+    private calculateTrendPercentage;
+    private getTimeSeriesChartData;
+    private getResponseTimeDistributionData;
+    private getTopToolsData;
+    private createTimeSeriesChartOptions;
+    private createBarChartOptions;
+    private createDoughnutChartOptions;
+    private createMultiAxisChartOptions;
+    private generateAlertConfiguration;
+    private generateMetricsTable;
+}
+export declare function getBusinessIntelligence(): BusinessIntelligence;