@anyshift/mcp-proxy 0.3.5 → 0.4.0

package/dist/timeseries/algorithms/moving-average.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Moving Average based anomaly detection
+ *
+ * Detects points that deviate significantly from a rolling moving average.
+ * Good for detecting sudden changes in time series with trends.
+ */
+import type { DataPoint, Anomaly, MovingAverageParams } from '../types.js';
+/**
+ * Detect anomalies using Moving Average method
+ *
+ * @param data - Array of data points (should be in time order)
+ * @param params - Moving Average parameters
+ * @returns Array of detected anomalies
+ */
+export declare function detectMovingAverageAnomalies(data: DataPoint[], params: MovingAverageParams): Anomaly[];

package/dist/timeseries/algorithms/moving-average.js

@@ -0,0 +1,72 @@
+/**
+ * Moving Average based anomaly detection
+ *
+ * Detects points that deviate significantly from a rolling moving average.
+ * Good for detecting sudden changes in time series with trends.
+ */
+import { movingAverage, movingStandardDeviation } from './stats.js';
+const DEFAULT_THRESHOLD = 2;
+/**
+ * Detect anomalies using Moving Average method
+ *
+ * @param data - Array of data points (should be in time order)
+ * @param params - Moving Average parameters
+ * @returns Array of detected anomalies
+ */
+export function detectMovingAverageAnomalies(data, params) {
+    const { window_size: windowSize, threshold = DEFAULT_THRESHOLD } = params;
+    if (windowSize <= 0) {
+        throw new Error('window_size must be greater than 0');
+    }
+    if (windowSize > data.length) {
+        throw new Error(`window_size (${windowSize}) cannot be larger than data length (${data.length})`);
+    }
+    const values = data.map((d) => d.value);
+    const ma = movingAverage(values, windowSize);
+    const mstd = movingStandardDeviation(values, windowSize);
+    const anomalies = [];
+    for (let i = 0; i < data.length; i++) {
+        // Skip points where we don't have enough data for the window
+        if (isNaN(ma[i]) || isNaN(mstd[i])) {
+            continue;
+        }
+        const point = data[i];
+        const expectedValue = ma[i];
+        const stdDev = mstd[i];
+        // If standard deviation is 0, all values in window are the same
+        if (stdDev === 0) {
+            // Only flag as anomaly if current value differs from the constant
+            if (point.value !== expectedValue) {
+                anomalies.push({
+                    index: point.index,
+                    timestamp: point.timestamp,
+                    value: point.value,
+                    reason: `Value ${point.value} differs from constant window value ${expectedValue}`,
+                    metadata: {
+                        moving_average: expectedValue,
+                        moving_std_dev: stdDev,
+                        window_size: windowSize,
+                    },
+                });
+            }
+            continue;
+        }
+        const deviation = Math.abs(point.value - expectedValue);
+        const deviationScore = deviation / stdDev;
+        if (deviationScore > threshold) {
+            anomalies.push({
+                index: point.index,
+                timestamp: point.timestamp,
+                value: point.value,
+                reason: `Value deviates ${deviationScore.toFixed(2)} std devs from moving average (expected: ${expectedValue.toFixed(2)}, threshold: ${threshold})`,
+                metadata: {
+                    moving_average: expectedValue,
+                    moving_std_dev: stdDev,
+                    deviation_score: deviationScore,
+                    window_size: windowSize,
+                },
+            });
+        }
+    }
+    return anomalies;
+}

package/dist/timeseries/algorithms/rolling-quantile.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rolling Quantile based anomaly detection (similar to Datadog's Basic algorithm)
+ *
+ * Uses a sliding window to compute rolling percentiles, then flags points
+ * outside the expected range. This is non-parametric and works well for
+ * any distribution without assuming normality.
+ */
+import type { DataPoint, Anomaly, RollingQuantileParams } from '../types.js';
+/**
+ * Detect anomalies using Rolling Quantile method
+ *
+ * @param data - Array of data points (should be in time order)
+ * @param params - Rolling Quantile parameters
+ * @returns Array of detected anomalies
+ */
+export declare function detectRollingQuantileAnomalies(data: DataPoint[], params: RollingQuantileParams): Anomaly[];

package/dist/timeseries/algorithms/rolling-quantile.js

@@ -0,0 +1,78 @@
+/**
+ * Rolling Quantile based anomaly detection (similar to Datadog's Basic algorithm)
+ *
+ * Uses a sliding window to compute rolling percentiles, then flags points
+ * outside the expected range. This is non-parametric and works well for
+ * any distribution without assuming normality.
+ */
+import { rollingQuantiles } from './stats.js';
+const DEFAULT_LOWER_QUANTILE = 0.05;
+const DEFAULT_UPPER_QUANTILE = 0.95;
+/**
+ * Detect anomalies using Rolling Quantile method
+ *
+ * @param data - Array of data points (should be in time order)
+ * @param params - Rolling Quantile parameters
+ * @returns Array of detected anomalies
+ */
+export function detectRollingQuantileAnomalies(data, params) {
+    const { window_size: windowSize, lower_quantile: lowerQuantile = DEFAULT_LOWER_QUANTILE, upper_quantile: upperQuantile = DEFAULT_UPPER_QUANTILE, } = params;
+    if (windowSize <= 0) {
+        throw new Error('window_size must be greater than 0');
+    }
+    if (windowSize > data.length) {
+        throw new Error(`window_size (${windowSize}) cannot be larger than data length (${data.length})`);
+    }
+    if (lowerQuantile < 0 || lowerQuantile > 1) {
+        throw new Error('lower_quantile must be between 0 and 1');
+    }
+    if (upperQuantile < 0 || upperQuantile > 1) {
+        throw new Error('upper_quantile must be between 0 and 1');
+    }
+    if (lowerQuantile >= upperQuantile) {
+        throw new Error('lower_quantile must be less than upper_quantile');
+    }
+    const values = data.map((d) => d.value);
+    const { lower, upper } = rollingQuantiles(values, windowSize, lowerQuantile, upperQuantile);
+    const anomalies = [];
+    for (let i = 0; i < data.length; i++) {
+        // Skip points where we don't have enough data for the window
+        if (isNaN(lower[i]) || isNaN(upper[i])) {
+            continue;
+        }
+        const point = data[i];
+        const lowerBound = lower[i];
+        const upperBound = upper[i];
+        if (point.value < lowerBound) {
+            anomalies.push({
+                index: point.index,
+                timestamp: point.timestamp,
+                value: point.value,
+                reason: `Value ${point.value.toFixed(2)} below rolling ${(lowerQuantile * 100).toFixed(0)}th percentile ${lowerBound.toFixed(2)}`,
+                metadata: {
+                    lower_bound: lowerBound,
+                    upper_bound: upperBound,
+                    lower_quantile: lowerQuantile,
+                    upper_quantile: upperQuantile,
+                    window_size: windowSize,
+                },
+            });
+        }
+        else if (point.value > upperBound) {
+            anomalies.push({
+                index: point.index,
+                timestamp: point.timestamp,
+                value: point.value,
+                reason: `Value ${point.value.toFixed(2)} above rolling ${(upperQuantile * 100).toFixed(0)}th percentile ${upperBound.toFixed(2)}`,
+                metadata: {
+                    lower_bound: lowerBound,
+                    upper_bound: upperBound,
+                    lower_quantile: lowerQuantile,
+                    upper_quantile: upperQuantile,
+                    window_size: windowSize,
+                },
+            });
+        }
+    }
+    return anomalies;
+}

package/dist/timeseries/algorithms/stats.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Statistical utility functions for anomaly detection
+ * Implemented in pure TypeScript for zero dependencies and fast execution
+ */
+/**
+ * Calculate the mean (average) of an array of numbers
+ */
+export declare function mean(values: number[]): number;
+/**
+ * Calculate the median of an array of numbers
+ */
+export declare function median(values: number[]): number;
+/**
+ * Calculate the standard deviation of an array of numbers
+ */
+export declare function standardDeviation(values: number[]): number;
+/**
+ * Calculate the Median Absolute Deviation (MAD)
+ * MAD = median(|Xi - median(X)|)
+ */
+export declare function medianAbsoluteDeviation(values: number[]): number;
+/**
+ * Calculate modified Z-score using MAD
+ * Modified Z-score = 0.6745 * (Xi - median) / MAD
+ * The constant 0.6745 makes it comparable to standard Z-scores for normal distributions
+ */
+export declare function modifiedZScore(value: number, med: number, mad: number): number;
+/**
+ * Calculate a simple moving average for an array at each position
+ * Returns an array of the same length, with NaN for positions where window is incomplete
+ */
+export declare function movingAverage(values: number[], windowSize: number): number[];
+/**
+ * Calculate the standard deviation of a moving window at each position
+ */
+export declare function movingStandardDeviation(values: number[], windowSize: number): number[];
+/**
+ * Calculate a specific quantile (percentile) of an array
+ * Uses linear interpolation between closest ranks
+ */
+export declare function quantile(values: number[], q: number): number;
+/**
+ * Calculate rolling quantiles (lower and upper bounds) at each position
+ * Returns arrays of the same length as input, with NaN for positions where window is incomplete
+ */
+export declare function rollingQuantiles(values: number[], windowSize: number, lowerQuantile: number, upperQuantile: number): {
+    lower: number[];
+    upper: number[];
+};

package/dist/timeseries/algorithms/stats.js

@@ -0,0 +1,139 @@
+/**
+ * Statistical utility functions for anomaly detection
+ * Implemented in pure TypeScript for zero dependencies and fast execution
+ */
+/**
+ * Calculate the mean (average) of an array of numbers
+ */
+export function mean(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+/**
+ * Calculate the median of an array of numbers
+ */
+export function median(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0
+        ? sorted[mid]
+        : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/**
+ * Calculate the standard deviation of an array of numbers
+ */
+export function standardDeviation(values) {
+    if (values.length < 2)
+        return 0;
+    const avg = mean(values);
+    const squaredDiffs = values.map((v) => Math.pow(v - avg, 2));
+    return Math.sqrt(mean(squaredDiffs));
+}
+/**
+ * Calculate the Median Absolute Deviation (MAD)
+ * MAD = median(|Xi - median(X)|)
+ */
+export function medianAbsoluteDeviation(values) {
+    if (values.length === 0)
+        return 0;
+    const med = median(values);
+    const absoluteDeviations = values.map((v) => Math.abs(v - med));
+    return median(absoluteDeviations);
+}
+/**
+ * Calculate modified Z-score using MAD
+ * Modified Z-score = 0.6745 * (Xi - median) / MAD
+ * The constant 0.6745 makes it comparable to standard Z-scores for normal distributions
+ */
+export function modifiedZScore(value, med, mad) {
+    if (mad === 0)
+        return 0;
+    return (0.6745 * (value - med)) / mad;
+}
+/**
+ * Calculate a simple moving average for an array at each position
+ * Returns an array of the same length, with NaN for positions where window is incomplete
+ */
+export function movingAverage(values, windowSize) {
+    if (windowSize <= 0 || values.length === 0)
+        return [];
+    const result = [];
+    for (let i = 0; i < values.length; i++) {
+        if (i < windowSize - 1) {
+            // Not enough data points yet
+            result.push(NaN);
+        }
+        else {
+            // Calculate average of the window
+            const window = values.slice(i - windowSize + 1, i + 1);
+            result.push(mean(window));
+        }
+    }
+    return result;
+}
+/**
+ * Calculate the standard deviation of a moving window at each position
+ */
+export function movingStandardDeviation(values, windowSize) {
+    if (windowSize <= 0 || values.length === 0)
+        return [];
+    const result = [];
+    for (let i = 0; i < values.length; i++) {
+        if (i < windowSize - 1) {
+            result.push(NaN);
+        }
+        else {
+            const window = values.slice(i - windowSize + 1, i + 1);
+            result.push(standardDeviation(window));
+        }
+    }
+    return result;
+}
+/**
+ * Calculate a specific quantile (percentile) of an array
+ * Uses linear interpolation between closest ranks
+ */
+export function quantile(values, q) {
+    if (values.length === 0)
+        return 0;
+    if (q <= 0)
+        return Math.min(...values);
+    if (q >= 1)
+        return Math.max(...values);
+    const sorted = [...values].sort((a, b) => a - b);
+    const pos = (sorted.length - 1) * q;
+    const lower = Math.floor(pos);
+    const upper = Math.ceil(pos);
+    const weight = pos - lower;
+    if (upper >= sorted.length)
+        return sorted[sorted.length - 1];
+    return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+}
+/**
+ * Calculate rolling quantiles (lower and upper bounds) at each position
+ * Returns arrays of the same length as input, with NaN for positions where window is incomplete
+ */
+export function rollingQuantiles(values, windowSize, lowerQuantile, upperQuantile) {
+    if (windowSize <= 0 || values.length === 0) {
+        return { lower: [], upper: [] };
+    }
+    const lower = [];
+    const upper = [];
+    for (let i = 0; i < values.length; i++) {
+        if (i < windowSize - 1) {
+            // Not enough data points yet
+            lower.push(NaN);
+            upper.push(NaN);
+        }
+        else {
+            // Calculate quantiles of the window
+            const window = values.slice(i - windowSize + 1, i + 1);
+            lower.push(quantile(window, lowerQuantile));
+            upper.push(quantile(window, upperQuantile));
+        }
+    }
+    return { lower, upper };
+}

package/dist/timeseries/algorithms/threshold.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Threshold-based anomaly detection
+ *
+ * Detects points that cross one or more named thresholds.
+ * Supports multiple thresholds with names and directions (upper/lower).
+ */
+import type { DataPoint, Anomaly, ThresholdParams } from '../types.js';
+/**
+ * Detect anomalies using threshold method
+ *
+ * @param data - Array of data points
+ * @param params - Threshold parameters with named thresholds
+ * @returns Array of detected anomalies
+ */
+export declare function detectThresholdAnomalies(data: DataPoint[], params: ThresholdParams): Anomaly[];

package/dist/timeseries/algorithms/threshold.js

@@ -0,0 +1,49 @@
+/**
+ * Threshold-based anomaly detection
+ *
+ * Detects points that cross one or more named thresholds.
+ * Supports multiple thresholds with names and directions (upper/lower).
+ */
+/**
+ * Detect anomalies using threshold method
+ *
+ * @param data - Array of data points
+ * @param params - Threshold parameters with named thresholds
+ * @returns Array of detected anomalies
+ */
+export function detectThresholdAnomalies(data, params) {
+    const { thresholds } = params;
+    if (!thresholds || thresholds.length === 0) {
+        throw new Error('At least one threshold must be specified');
+    }
+    const anomalies = [];
+    for (const point of data) {
+        const crossedThresholds = [];
+        for (const threshold of thresholds) {
+            if (threshold.direction === 'upper' && point.value > threshold.value) {
+                crossedThresholds.push(threshold);
+            }
+            else if (threshold.direction === 'lower' && point.value < threshold.value) {
+                crossedThresholds.push(threshold);
+            }
+        }
+        if (crossedThresholds.length > 0) {
+            const thresholdNames = crossedThresholds.map((t) => t.name);
+            const thresholdDetails = crossedThresholds
+                .map((t) => `${t.name} (${t.direction}: ${t.value})`)
+                .join(', ');
+            anomalies.push({
+                index: point.index,
+                timestamp: point.timestamp,
+                value: point.value,
+                reason: `Value ${point.value} crossed threshold(s): ${thresholdDetails}`,
+                crossed_thresholds: thresholdNames,
+                metadata: crossedThresholds.reduce((acc, t) => {
+                    acc[`threshold_${t.name}`] = t.value;
+                    return acc;
+                }, {}),
+            });
+        }
+    }
+    return anomalies;
+}

package/dist/timeseries/handler.d.ts

@@ -0,0 +1,10 @@
+import type { TimeseriesConfig, DetectionType, DetectionParams } from './types.js';
+/**
+ * Main handler for time series anomaly detection
+ */
+export declare function detectTimeseriesAnomalies(config: TimeseriesConfig, filePath: string, jqQuery: string, valueField: string, detectionType: DetectionType, detectionParams?: DetectionParams, timestampField?: string): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;