@jagilber-org/index-server 1.19.1

package/dist/dashboard/server/metricsAggregation.d.ts

@@ -0,0 +1,252 @@
+/**
+ * metricsAggregation.ts
+ *
+ * All shared type definitions and pure aggregation math for the metrics subsystem:
+ * averages, percentiles, window calculations, trend detection, and tool-cleanup logic.
+ * No side effects — every function here is deterministic given its inputs.
+ */
+export interface ToolMetrics {
+    callCount: number;
+    successCount: number;
+    errorCount: number;
+    totalResponseTime: number;
+    lastCalled?: number;
+    errorTypes: {
+        [errorType: string]: number;
+    };
+}
+export interface ServerMetrics {
+    uptime: number;
+    version: string;
+    memoryUsage: NodeJS.MemoryUsage;
+    cpuUsage?: NodeJS.CpuUsage;
+    startTime: number;
+}
+export interface ConnectionMetrics {
+    activeConnections: number;
+    totalConnections: number;
+    disconnectedConnections: number;
+    avgSessionDuration: number;
+}
+export interface MetricsSnapshot {
+    timestamp: number;
+    server: ServerMetrics;
+    tools: {
+        [toolName: string]: ToolMetrics;
+    };
+    connections: ConnectionMetrics;
+    performance: {
+        requestsPerMinute: number;
+        successRate: number;
+        avgResponseTime: number;
+        errorRate: number;
+    };
+}
+export interface MetricsTimeSeriesEntry {
+    timestamp: number;
+    snapshot: MetricsSnapshot;
+    performanceData: {
+        responseTimeMs: number;
+        requestCount: number;
+        errorCount: number;
+        connectionCount: number;
+    };
+}
+export interface ToolCallEvent {
+    timestamp: number;
+    toolName: string;
+    success: boolean;
+    responseTimeMs: number;
+    errorType?: string;
+    clientId?: string;
+}
+export interface MetricsBufferConfig {
+    historicalSnapshots: {
+        capacity: number;
+        retentionMinutes: number;
+        persistenceFile?: string;
+    };
+    toolCallEvents: {
+        capacity: number;
+        retentionMinutes: number;
+        persistenceFile?: string;
+    };
+    performanceMetrics: {
+        capacity: number;
+        persistenceFile?: string;
+    };
+}
+export interface ChartDataPoint {
+    timestamp: number;
+    value: number;
+    label?: string;
+}
+export interface ToolUsageChartData {
+    toolName: string;
+    data: ChartDataPoint[];
+    color?: string;
+}
+export interface PerformanceChartData {
+    responseTime: ChartDataPoint[];
+    requestRate: ChartDataPoint[];
+    errorRate: ChartDataPoint[];
+    successRate: ChartDataPoint[];
+}
+export interface RealtimeMetrics {
+    currentRpm: number;
+    activeConnections: number;
+    avgResponseTime: number;
+    successRate: number;
+    errorRate: number;
+    topTools: Array<{
+        name: string;
+        calls: number;
+        avgTime: number;
+    }>;
+    recentErrors: Array<{
+        tool: string;
+        error: string;
+        timestamp: number;
+    }>;
+}
+export interface RealtimeStreamingData {
+    timestamp: number;
+    systemHealth: SystemHealth;
+    performanceMetrics: EnhancedPerformanceMetrics;
+    recentActivity: ActivityEvent[];
+    streamingStats: StreamingStats;
+}
+export interface SystemHealth {
+    cpuUsage: number;
+    memoryUsage: number;
+    diskUsage: number;
+    networkLatency: number;
+    uptime: number;
+    lastHealthCheck: Date;
+    status: 'healthy' | 'warning' | 'critical';
+}
+export interface EnhancedPerformanceMetrics {
+    requestThroughput: number;
+    averageResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    errorRate: number;
+    concurrentConnections: number;
+    totalRequests: number;
+    successfulRequests: number;
+    requestsPerSecond: number;
+    bytesTransferred: number;
+}
+export interface StreamingStats {
+    totalStreamingConnections: number;
+    dataTransferRate: number;
+    latency: number;
+    compressionRatio: number;
+}
+export interface ActivityEvent {
+    tool: string;
+    lastActivity: Date | null;
+    recentCalls: number;
+}
+export interface AdvancedAnalytics {
+    timeRange: string;
+    hourlyStats: HourlyStats[];
+    toolUsageBreakdown: ToolUsageStats[];
+    errorAnalysis: ErrorAnalysis;
+    performanceTrends: PerformanceTrend[];
+    predictionData: PredictionData | null;
+    anomalies: Anomaly[];
+}
+export interface HourlyStats {
+    hour: string;
+    requestCount: number;
+    errorCount: number;
+    avgResponseTime: number;
+}
+export interface ToolUsageStats {
+    toolName: string;
+    callCount: number;
+    successRate: number;
+    avgResponseTime: number;
+    lastCalled: Date | null;
+}
+export interface ErrorAnalysis {
+    errorTypes: {
+        [type: string]: number;
+    };
+    totalErrors: number;
+    errorRate: number;
+}
+export interface PerformanceTrend {
+    timestamp: Date;
+    responseTime: number;
+    throughput: number;
+    errorRate: number;
+}
+export interface PredictionData {
+    responseTimeProjection: number;
+    throughputProjection: number;
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface Anomaly {
+    type: string;
+    timestamp: Date;
+    value: number;
+    severity: 'low' | 'medium' | 'high';
+}
+export interface Alert {
+    id: string;
+    type: 'error_rate' | 'response_time' | 'memory' | 'cpu' | 'system' | 'network';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    message: string;
+    timestamp: Date;
+    resolved: boolean;
+    resolvedAt?: Date;
+    value: number;
+    threshold: number;
+    source: string;
+    category: string;
+}
+export interface MetricsCollectorOptions {
+    retentionMinutes?: number;
+    maxSnapshots?: number;
+    collectInterval?: number;
+}
+export interface ResourceSample {
+    timestamp: number;
+    cpuPercent: number;
+    heapUsed: number;
+    rss: number;
+}
+export declare function getTotalRequests(tools: Map<string, ToolMetrics>): number;
+export declare function getTotalErrors(tools: Map<string, ToolMetrics>): number;
+export declare function getAverageResponseTime(tools: Map<string, ToolMetrics>): number;
+export declare function getErrorRate(tools: Map<string, ToolMetrics>): number;
+/** Requests per second derived from a sliding window of recent snapshots. */
+export declare function calculateRequestsPerSecond(snapshots: MetricsSnapshot[]): number;
+/** Linear trend slope via ordinary least squares over an array of values. */
+export declare function calculateTrend(values: number[]): number;
+/** Parse time-range strings like "1h", "30m", "2d" into whole hours. */
+export declare function parseTimeRange(timeRange: string): number;
+/** Return an estimated percentile response-time given the average. */
+export declare function calculatePercentileFromAvg(avg: number, percentile: number): number;
+export declare function categorizeAlert(type: string): string;
+export declare function getOverallHealthStatus(cpu: number, memory: number, errorRate: number): 'healthy' | 'warning' | 'critical';
+/** Estimate CPU % from recent RPM (simple heuristic, single-core basis). */
+export declare function estimateCPUUsage(recentSnapshots: MetricsSnapshot[]): number;
+export declare function estimateMemoryUsage(connectionCount: number, snapshotCount: number): number;
+export declare function estimateDiskUsage(snapshotCount: number): number;
+/** Detect response-time spikes in a set of snapshots. */
+export declare function detectAnomalies(snapshots: MetricsSnapshot[]): Anomaly[];
+/** Compute RPM from a series of snapshots (used for historical charting). */
+export declare function calculateRPMFromSnapshots(snapshots: MetricsSnapshot[]): number;
+/** Compute per-second OLS slope for CPU % and heap memory over a sample window. */
+export declare function calculateLinearSlopes(samples: ResourceSample[]): {
+    cpuSlope: number;
+    memSlope: number;
+};
+/**
+ * Return the set of tool names that should be evicted to keep the map under maxSize.
+ * Lowest-score (least-recently-used + fewest calls) tools are evicted first.
+ */
+export declare function computeToolsToCleanup(tools: Map<string, ToolMetrics>, maxSize: number, staleThreshold: number, minCallsToKeep?: number): string[];

package/dist/dashboard/server/metricsAggregation.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * metricsAggregation.ts
+ *
+ * All shared type definitions and pure aggregation math for the metrics subsystem:
+ * averages, percentiles, window calculations, trend detection, and tool-cleanup logic.
+ * No side effects — every function here is deterministic given its inputs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalRequests = getTotalRequests;
+exports.getTotalErrors = getTotalErrors;
+exports.getAverageResponseTime = getAverageResponseTime;
+exports.getErrorRate = getErrorRate;
+exports.calculateRequestsPerSecond = calculateRequestsPerSecond;
+exports.calculateTrend = calculateTrend;
+exports.parseTimeRange = parseTimeRange;
+exports.calculatePercentileFromAvg = calculatePercentileFromAvg;
+exports.categorizeAlert = categorizeAlert;
+exports.getOverallHealthStatus = getOverallHealthStatus;
+exports.estimateCPUUsage = estimateCPUUsage;
+exports.estimateMemoryUsage = estimateMemoryUsage;
+exports.estimateDiskUsage = estimateDiskUsage;
+exports.detectAnomalies = detectAnomalies;
+exports.calculateRPMFromSnapshots = calculateRPMFromSnapshots;
+exports.calculateLinearSlopes = calculateLinearSlopes;
+exports.computeToolsToCleanup = computeToolsToCleanup;
+// ── Pure Aggregation Functions ──────────────────────────────────────────────
+function getTotalRequests(tools) {
+    let total = 0;
+    tools.forEach(m => { total += m.callCount; });
+    return total;
+}
+function getTotalErrors(tools) {
+    let total = 0;
+    tools.forEach(m => { total += m.errorCount; });
+    return total;
+}
+function getAverageResponseTime(tools) {
+    let totalTime = 0;
+    let totalCalls = 0;
+    tools.forEach(m => { totalTime += m.totalResponseTime; totalCalls += m.callCount; });
+    return totalCalls > 0 ? totalTime / totalCalls : 0;
+}
+function getErrorRate(tools) {
+    const totalCalls = getTotalRequests(tools);
+    const totalErrors = getTotalErrors(tools);
+    return totalCalls > 0 ? (totalErrors / totalCalls) * 100 : 0;
+}
+/** Requests per second derived from a sliding window of recent snapshots. */
+function calculateRequestsPerSecond(snapshots) {
+    const recent = snapshots.slice(-10);
+    if (recent.length < 2)
+        return 0;
+    const latest = recent[recent.length - 1];
+    const earliest = recent[0];
+    const timeDiff = (latest.timestamp - earliest.timestamp) / 1000;
+    const latestReqs = Object.values(latest.tools).reduce((s, t) => s + t.callCount, 0);
+    const earliestReqs = Object.values(earliest.tools).reduce((s, t) => s + t.callCount, 0);
+    return timeDiff > 0 ? (latestReqs - earliestReqs) / timeDiff : 0;
+}
+/** Linear trend slope via ordinary least squares over an array of values. */
+function calculateTrend(values) {
+    if (values.length < 2)
+        return 0;
+    const n = values.length;
+    const sumX = (n * (n - 1)) / 2;
+    const sumY = values.reduce((s, v) => s + v, 0);
+    const sumXY = values.reduce((s, v, i) => s + i * v, 0);
+    const sumX2 = (n * (n - 1) * (2 * n - 1)) / 6;
+    return (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+}
+/** Parse time-range strings like "1h", "30m", "2d" into whole hours. */
+function parseTimeRange(timeRange) {
+    const match = timeRange.match(/(\d+)([hmd])/);
+    if (!match)
+        return 1;
+    const value = parseInt(match[1]);
+    switch (match[2]) {
+        case 'h': return value;
+        case 'd': return value * 24;
+        case 'm': return Math.max(1, Math.floor(value / 60));
+        default: return 1;
+    }
+}
+/** Return an estimated percentile response-time given the average. */
+function calculatePercentileFromAvg(avg, percentile) {
+    const multiplier = percentile === 95 ? 2.5 : percentile === 99 ? 4.0 : 1.0;
+    return Math.round(avg * multiplier);
+}
+function categorizeAlert(type) {
+    const categories = {
+        error_rate: 'Performance',
+        response_time: 'Performance',
+        memory: 'System',
+        cpu: 'System',
+        disk: 'System',
+        network: 'Network',
+    };
+    return categories[type] ?? 'General';
+}
+function getOverallHealthStatus(cpu, memory, errorRate) {
+    if (cpu > 90 || memory > 90 || errorRate > 10)
+        return 'critical';
+    if (cpu > 75 || memory > 75 || errorRate > 5)
+        return 'warning';
+    return 'healthy';
+}
+/** Estimate CPU % from recent RPM (simple heuristic, single-core basis). */
+function estimateCPUUsage(recentSnapshots) {
+    if (recentSnapshots.length === 0)
+        return 0;
+    const avgRpm = recentSnapshots.reduce((s, snap) => s + snap.performance.requestsPerMinute, 0) / recentSnapshots.length;
+    return Math.min(Math.max(avgRpm / 10, 5), 95);
+}
+function estimateMemoryUsage(connectionCount, snapshotCount) {
+    return Math.min(20 + connectionCount * 0.5 + snapshotCount * 0.1, 95);
+}
+function estimateDiskUsage(snapshotCount) {
+    return Math.min(30 + snapshotCount * 0.05, 80);
+}
+/** Detect response-time spikes in a set of snapshots. */
+function detectAnomalies(snapshots) {
+    const anomalies = [];
+    if (snapshots.length <= 10)
+        return anomalies;
+    const avg = snapshots.reduce((s, snap) => s + snap.performance.avgResponseTime, 0) / snapshots.length;
+    for (const snapshot of snapshots) {
+        if (snapshot.performance.avgResponseTime > avg * 2) {
+            anomalies.push({
+                type: 'response_time_spike',
+                timestamp: new Date(snapshot.timestamp),
+                value: snapshot.performance.avgResponseTime,
+                severity: 'medium',
+            });
+        }
+    }
+    return anomalies;
+}
+/** Compute RPM from a series of snapshots (used for historical charting). */
+function calculateRPMFromSnapshots(snapshots) {
+    if (snapshots.length < 2)
+        return 0;
+    let totalRequests = 0;
+    snapshots.forEach(s => { Object.values(s.tools).forEach(t => { totalRequests += t.callCount; }); });
+    const spanMinutes = (snapshots[snapshots.length - 1].timestamp - snapshots[0].timestamp) / 60000;
+    return spanMinutes > 0 ? totalRequests / spanMinutes : 0;
+}
+/** Compute per-second OLS slope for CPU % and heap memory over a sample window. */
+function calculateLinearSlopes(samples) {
+    if (samples.length <= 5)
+        return { cpuSlope: 0, memSlope: 0 };
+    const n = samples.length;
+    const firstTs = samples[0].timestamp;
+    let sumX = 0, sumCpu = 0, sumMem = 0, sumXcpu = 0, sumXmem = 0, sumX2 = 0;
+    for (const s of samples) {
+        const x = (s.timestamp - firstTs) / 1000;
+        sumX += x;
+        sumCpu += s.cpuPercent;
+        sumMem += s.heapUsed;
+        sumXcpu += x * s.cpuPercent;
+        sumXmem += x * s.heapUsed;
+        sumX2 += x * x;
+    }
+    const denom = (n * sumX2 - sumX * sumX) || 1;
+    return {
+        cpuSlope: (n * sumXcpu - sumX * sumCpu) / denom,
+        memSlope: (n * sumXmem - sumX * sumMem) / denom,
+    };
+}
+/**
+ * Return the set of tool names that should be evicted to keep the map under maxSize.
+ * Lowest-score (least-recently-used + fewest calls) tools are evicted first.
+ */
+function computeToolsToCleanup(tools, maxSize, staleThreshold, minCallsToKeep = 10) {
+    const keepCount = Math.floor(maxSize * 0.8);
+    const sorted = Array.from(tools.entries())
+        .map(([name, m]) => ({ name, m, score: (m.lastCalled ?? 0) + m.callCount * 1000 }))
+        .sort((a, b) => b.score - a.score);
+    const candidates = sorted.slice(keepCount);
+    const toRemove = [];
+    if (tools.size > maxSize) {
+        for (const { name, m } of candidates) {
+            const isStale = (m.lastCalled ?? 0) < staleThreshold;
+            if ((isStale && m.callCount < minCallsToKeep) || (!isStale && m.callCount < 5)) {
+                toRemove.push(name);
+            }
+        }
+        // Hard-cap: evict more aggressively if still over capacity
+        const remaining = tools.size - toRemove.length;
+        if (remaining > maxSize) {
+            const extra = candidates
+                .filter(({ name }) => !toRemove.includes(name))
+                .slice(0, remaining - keepCount)
+                .map(({ name }) => name);
+            toRemove.push(...extra);
+        }
+    }
+    else {
+        for (const { name, m } of candidates) {
+            if ((m.lastCalled ?? 0) < staleThreshold && m.callCount < minCallsToKeep) {
+                toRemove.push(name);
+            }
+        }
+    }
+    return toRemove;
+}

package/dist/dashboard/server/metricsSerializer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * metricsSerializer.ts
+ *
+ * Pure builder functions that convert raw metrics state into JSON-ready output shapes
+ * for dashboard charts, analytics, and streaming endpoints.
+ * Every function here is side-effect-free and receives all data it needs as parameters.
+ */
+import { type ToolMetrics, type MetricsSnapshot, type ToolCallEvent, type RealtimeMetrics, type ToolUsageChartData, type PerformanceChartData, type ToolUsageStats, type HourlyStats, type ErrorAnalysis, type PerformanceTrend, type PredictionData, type AdvancedAnalytics, type ActivityEvent } from './metricsAggregation.js';
+export declare function buildRealtimeMetrics(snapshot: MetricsSnapshot, tools: Map<string, ToolMetrics>): RealtimeMetrics;
+export declare function buildRecentActivity(tools: Map<string, ToolMetrics>): ActivityEvent[];
+export declare function buildToolUsageChartData(snapshots: MetricsSnapshot[], minutes: number): ToolUsageChartData[];
+export declare function buildPerformanceChartData(snapshots: MetricsSnapshot[], minutes: number): PerformanceChartData;
+export declare function buildPerformanceTimeSeriesData(performanceData: Array<{
+    timestamp: number;
+    responseTime: number;
+    throughput: number;
+    errorRate: number;
+}>, minutes: number): PerformanceChartData;
+export declare function buildToolUsageAnalytics(events: ToolCallEvent[], minutes: number): ToolUsageStats[];
+export declare function buildHourlyStats(snapshots: MetricsSnapshot[], timeRange: string, errorRate: number): HourlyStats[];
+export declare function buildToolUsageBreakdown(tools: Map<string, ToolMetrics>): ToolUsageStats[];
+export declare function buildErrorAnalysis(tools: Map<string, ToolMetrics>, errorRate: number): ErrorAnalysis;
+export declare function buildPerformanceTrends(snapshots: MetricsSnapshot[]): PerformanceTrend[];
+export declare function buildPredictionData(snapshots: MetricsSnapshot[]): PredictionData | null;
+export declare function buildAdvancedAnalytics(timeRange: string, snapshots: MetricsSnapshot[], tools: Map<string, ToolMetrics>, errorRate: number, anomalies: import('./metricsAggregation.js').Anomaly[]): AdvancedAnalytics;

package/dist/dashboard/server/metricsSerializer.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * metricsSerializer.ts
+ *
+ * Pure builder functions that convert raw metrics state into JSON-ready output shapes
+ * for dashboard charts, analytics, and streaming endpoints.
+ * Every function here is side-effect-free and receives all data it needs as parameters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRealtimeMetrics = buildRealtimeMetrics;
+exports.buildRecentActivity = buildRecentActivity;
+exports.buildToolUsageChartData = buildToolUsageChartData;
+exports.buildPerformanceChartData = buildPerformanceChartData;
+exports.buildPerformanceTimeSeriesData = buildPerformanceTimeSeriesData;
+exports.buildToolUsageAnalytics = buildToolUsageAnalytics;
+exports.buildHourlyStats = buildHourlyStats;
+exports.buildToolUsageBreakdown = buildToolUsageBreakdown;
+exports.buildErrorAnalysis = buildErrorAnalysis;
+exports.buildPerformanceTrends = buildPerformanceTrends;
+exports.buildPredictionData = buildPredictionData;
+exports.buildAdvancedAnalytics = buildAdvancedAnalytics;
+const metricsAggregation_js_1 = require("./metricsAggregation.js");
+// ── Real-time widgets ────────────────────────────────────────────────────────
+function buildRealtimeMetrics(snapshot, tools) {
+    const topTools = Array.from(tools.entries())
+        .sort((a, b) => b[1].callCount - a[1].callCount)
+        .slice(0, 5)
+        .map(([name, m]) => ({
+        name,
+        calls: m.callCount,
+        avgTime: m.callCount > 0 ? m.totalResponseTime / m.callCount : 0,
+    }));
+    return {
+        currentRpm: snapshot.performance.requestsPerMinute,
+        activeConnections: snapshot.connections.activeConnections,
+        avgResponseTime: snapshot.performance.avgResponseTime,
+        successRate: snapshot.performance.successRate,
+        errorRate: snapshot.performance.errorRate,
+        topTools,
+        recentErrors: [],
+    };
+}
+function buildRecentActivity(tools) {
+    const cutoff = Date.now() - 300_000; // 5 min
+    return Array.from(tools.entries())
+        .filter(([, m]) => m.lastCalled && m.lastCalled >= cutoff)
+        .map(([name, m]) => ({
+        tool: name,
+        lastActivity: m.lastCalled ? new Date(m.lastCalled) : null,
+        recentCalls: m.callCount,
+    }))
+        .sort((a, b) => (b.lastActivity?.getTime() ?? 0) - (a.lastActivity?.getTime() ?? 0))
+        .slice(0, 10);
+}
+// ── Chart data builders ──────────────────────────────────────────────────────
+const CHART_COLORS = [
+    '#FF6384', '#36A2EB', '#FFCE56', '#4BC0C0',
+    '#9966FF', '#FF9F40', '#FF6384', '#C9CBCF',
+];
+function buildToolUsageChartData(snapshots, minutes) {
+    const cutoff = Date.now() - minutes * 60_000;
+    const relevant = snapshots.filter(s => s.timestamp >= cutoff);
+    if (relevant.length === 0)
+        return [];
+    const toolNames = new Set();
+    relevant.forEach(s => Object.keys(s.tools).forEach(n => toolNames.add(n)));
+    return Array.from(toolNames).map((toolName, i) => ({
+        toolName,
+        color: CHART_COLORS[i % CHART_COLORS.length],
+        data: relevant.map(s => ({
+            timestamp: s.timestamp,
+            value: s.tools[toolName]?.callCount ?? 0,
+            label: new Date(s.timestamp).toLocaleTimeString(),
+        })),
+    }));
+}
+function buildPerformanceChartData(snapshots, minutes) {
+    const cutoff = Date.now() - minutes * 60_000;
+    const relevant = snapshots.filter(s => s.timestamp >= cutoff);
+    const toPoint = (s, value) => ({
+        timestamp: s.timestamp,
+        value,
+        label: new Date(s.timestamp).toLocaleTimeString(),
+    });
+    return {
+        responseTime: relevant.map(s => toPoint(s, s.performance.avgResponseTime)),
+        requestRate: relevant.map(s => toPoint(s, s.performance.requestsPerMinute)),
+        errorRate: relevant.map(s => toPoint(s, s.performance.errorRate)),
+        successRate: relevant.map(s => toPoint(s, s.performance.successRate)),
+    };
+}
+function buildPerformanceTimeSeriesData(performanceData, minutes) {
+    const cutoff = Date.now() - minutes * 60_000;
+    const recent = performanceData.filter(m => m.timestamp >= cutoff);
+    return {
+        responseTime: recent.map(m => ({ timestamp: m.timestamp, value: m.responseTime })),
+        requestRate: recent.map(m => ({ timestamp: m.timestamp, value: m.throughput })),
+        errorRate: recent.map(m => ({ timestamp: m.timestamp, value: m.errorRate })),
+        successRate: recent.map(m => ({ timestamp: m.timestamp, value: 100 - m.errorRate })),
+    };
+}
+// ── Analytics builders ───────────────────────────────────────────────────────
+function buildToolUsageAnalytics(events, minutes) {
+    const cutoff = Date.now() - minutes * 60_000;
+    const recent = events.filter(e => e.timestamp >= cutoff);
+    const map = new Map();
+    recent.forEach(e => {
+        const s = map.get(e.toolName) ?? { calls: 0, successes: 0, totalTime: 0, lastUsed: 0 };
+        s.calls++;
+        if (e.success)
+            s.successes++;
+        s.totalTime += e.responseTimeMs;
+        s.lastUsed = Math.max(s.lastUsed, e.timestamp);
+        map.set(e.toolName, s);
+    });
+    return Array.from(map.entries()).map(([toolName, s]) => ({
+        toolName,
+        callCount: s.calls,
+        successRate: s.calls > 0 ? (s.successes / s.calls) * 100 : 100,
+        avgResponseTime: s.calls > 0 ? s.totalTime / s.calls : 0,
+        lastCalled: s.lastUsed > 0 ? new Date(s.lastUsed) : null,
+    }));
+}
+function buildHourlyStats(snapshots, timeRange, errorRate) {
+    const hours = (0, metricsAggregation_js_1.parseTimeRange)(timeRange);
+    const now = Date.now();
+    const stats = [];
+    for (let i = hours - 1; i >= 0; i--) {
+        const hourStart = now - i * 3_600_000;
+        const hourEnd = hourStart + 3_600_000;
+        const hourSnaps = snapshots.filter(s => s.timestamp >= hourStart && s.timestamp < hourEnd);
+        if (hourSnaps.length === 0)
+            continue;
+        const latestReqs = Object.values(hourSnaps[hourSnaps.length - 1].tools).reduce((s, t) => s + t.callCount, 0);
+        const earliestReqs = Object.values(hourSnaps[0].tools).reduce((s, t) => s + t.callCount, 0);
+        const requests = latestReqs - earliestReqs;
+        stats.push({
+            hour: new Date(hourStart).toISOString().slice(11, 16),
+            requestCount: requests,
+            errorCount: Math.round(requests * errorRate / 100),
+            avgResponseTime: hourSnaps.reduce((s, snap) => s + snap.performance.avgResponseTime, 0) / hourSnaps.length,
+        });
+    }
+    return stats;
+}
+function buildToolUsageBreakdown(tools) {
+    return Array.from(tools.entries()).map(([name, m]) => ({
+        toolName: name,
+        callCount: m.callCount,
+        successRate: m.callCount > 0 ? ((m.callCount - m.errorCount) / m.callCount) * 100 : 100,
+        avgResponseTime: m.totalResponseTime / Math.max(m.callCount, 1),
+        lastCalled: m.lastCalled ? new Date(m.lastCalled) : null,
+    }));
+}
+function buildErrorAnalysis(tools, errorRate) {
+    const errors = {};
+    let totalErrors = 0;
+    tools.forEach(m => {
+        totalErrors += m.errorCount;
+        errors['TimeoutError'] = (errors['TimeoutError'] ?? 0) + Math.floor(m.errorCount * 0.3);
+        errors['ValidationError'] = (errors['ValidationError'] ?? 0) + Math.floor(m.errorCount * 0.4);
+        errors['SystemError'] = (errors['SystemError'] ?? 0) + Math.floor(m.errorCount * 0.3);
+    });
+    return { errorTypes: errors, totalErrors, errorRate };
+}
+function buildPerformanceTrends(snapshots) {
+    const points = Math.min(snapshots.length, 20);
+    return snapshots.slice(-points).map(s => ({
+        timestamp: new Date(s.timestamp),
+        responseTime: s.performance.avgResponseTime,
+        throughput: s.performance.requestsPerMinute,
+        errorRate: s.performance.errorRate,
+    }));
+}
+function buildPredictionData(snapshots) {
+    const recent = snapshots.slice(-10);
+    if (recent.length < 2)
+        return null;
+    return {
+        responseTimeProjection: (0, metricsAggregation_js_1.calculateTrend)(recent.map(s => s.performance.avgResponseTime)),
+        throughputProjection: (0, metricsAggregation_js_1.calculateTrend)(recent.map(s => s.performance.requestsPerMinute)),
+        confidence: recent.length >= 5 ? 'high' : 'low',
+    };
+}
+function buildAdvancedAnalytics(timeRange, snapshots, tools, errorRate, anomalies) {
+    return {
+        timeRange,
+        hourlyStats: buildHourlyStats(snapshots, timeRange, errorRate),
+        toolUsageBreakdown: buildToolUsageBreakdown(tools),
+        errorAnalysis: buildErrorAnalysis(tools, errorRate),
+        performanceTrends: buildPerformanceTrends(snapshots),
+        predictionData: buildPredictionData(snapshots),
+        anomalies,
+    };
+}