fixparser-plugin-mcp 9.1.7-5d282a9e → 9.1.7-620b3399

package/build/cjs/MCPLocal.js

@@ -307,1568 +307,9 @@ var toolSchemas = {
       },
       required: ["symbol"]
     }
-  },
-  technicalAnalysis: {
-    description: "Performs comprehensive technical analysis on market data for a given symbol, including indicators like SMA, EMA, RSI, Bollinger Bands, and trading signals",
-    schema: {
-      type: "object",
-      properties: {
-        symbol: {
-          type: "string",
-          description: "The trading symbol to analyze (e.g., AAPL, MSFT, EURUSD)"
-        }
-      },
-      required: ["symbol"]
-    }
   }
 };
 
-// src/tools/analytics.ts
-function sum(numbers) {
-  return numbers.reduce((acc, val) => acc + val, 0);
-}
-var TechnicalAnalyzer = class {
-  prices;
-  volumes;
-  highs;
-  lows;
-  constructor(data) {
-    this.prices = data.map((d) => d.trade > 0 ? d.trade : d.midPrice);
-    this.volumes = data.map((d) => d.volume);
-    this.highs = data.map((d) => d.tradingSessionHighPrice > 0 ? d.tradingSessionHighPrice : d.trade);
-    this.lows = data.map((d) => d.tradingSessionLowPrice > 0 ? d.tradingSessionLowPrice : d.trade);
-  }
-  // Calculate Simple Moving Average
-  calculateSMA(data, period) {
-    const sma = [];
-    for (let i = period - 1; i < data.length; i++) {
-      const sum2 = data.slice(i - period + 1, i + 1).reduce((a, b) => a + b, 0);
-      sma.push(sum2 / period);
-    }
-    return sma;
-  }
-  // Calculate Exponential Moving Average
-  calculateEMA(data, period) {
-    const multiplier = 2 / (period + 1);
-    const ema = [data[0]];
-    for (let i = 1; i < data.length; i++) {
-      ema.push(data[i] * multiplier + ema[i - 1] * (1 - multiplier));
-    }
-    return ema;
-  }
-  // Calculate RSI
-  calculateRSI(data, period = 14) {
-    if (data.length < period + 1) return [];
-    const changes = [];
-    for (let i = 1; i < data.length; i++) {
-      changes.push(data[i] - data[i - 1]);
-    }
-    const gains = changes.map((change) => change > 0 ? change : 0);
-    const losses = changes.map((change) => change < 0 ? Math.abs(change) : 0);
-    let avgGain = gains.slice(0, period).reduce((a, b) => a + b, 0) / period;
-    let avgLoss = losses.slice(0, period).reduce((a, b) => a + b, 0) / period;
-    const rsi = [];
-    for (let i = period; i < changes.length; i++) {
-      const rs = avgGain / avgLoss;
-      rsi.push(100 - 100 / (1 + rs));
-      avgGain = (avgGain * (period - 1) + gains[i]) / period;
-      avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
-    }
-    return rsi;
-  }
-  // Calculate Bollinger Bands
-  calculateBollingerBands(data, period = 20, stdDev = 2) {
-    if (data.length < period) return [];
-    const sma = this.calculateSMA(data, period);
-    const bands = [];
-    for (let i = 0; i < sma.length; i++) {
-      const dataSlice = data.slice(i, i + period);
-      const mean = sma[i];
-      const variance = dataSlice.reduce((sum2, price) => sum2 + (price - mean) ** 2, 0) / period;
-      const standardDeviation = Math.sqrt(variance);
-      const upper = mean + standardDeviation * stdDev;
-      const lower = mean - standardDeviation * stdDev;
-      bands.push({
-        upper,
-        middle: mean,
-        lower,
-        bandwidth: (upper - lower) / mean * 100,
-        percentB: (data[i] - lower) / (upper - lower) * 100
-      });
-    }
-    return bands;
-  }
-  // Calculate maximum drawdown
-  calculateMaxDrawdown(prices) {
-    let maxPrice = prices[0];
-    let maxDrawdown = 0;
-    for (let i = 1; i < prices.length; i++) {
-      if (prices[i] > maxPrice) {
-        maxPrice = prices[i];
-      }
-      const drawdown = (maxPrice - prices[i]) / maxPrice;
-      if (drawdown > maxDrawdown) {
-        maxDrawdown = drawdown;
-      }
-    }
-    return maxDrawdown;
-  }
-  // Calculate Average True Range (ATR)
-  calculateAtr(prices, highs, lows) {
-    if (prices.length < 2) return [];
-    const trueRanges = [];
-    for (let i = 1; i < prices.length; i++) {
-      const high = highs[i] || prices[i];
-      const low = lows[i] || prices[i];
-      const prevClose = prices[i - 1];
-      const tr1 = high - low;
-      const tr2 = Math.abs(high - prevClose);
-      const tr3 = Math.abs(low - prevClose);
-      trueRanges.push(Math.max(tr1, tr2, tr3));
-    }
-    const atr = [];
-    if (trueRanges.length >= 14) {
-      let sum2 = trueRanges.slice(0, 14).reduce((a, b) => a + b, 0);
-      atr.push(sum2 / 14);
-      for (let i = 14; i < trueRanges.length; i++) {
-        sum2 = sum2 - trueRanges[i - 14] + trueRanges[i];
-        atr.push(sum2 / 14);
-      }
-    }
-    return atr;
-  }
-  // Calculate maximum consecutive losses
-  calculateMaxConsecutiveLosses(prices) {
-    let maxConsecutive = 0;
-    let currentConsecutive = 0;
-    for (let i = 1; i < prices.length; i++) {
-      if (prices[i] < prices[i - 1]) {
-        currentConsecutive++;
-        maxConsecutive = Math.max(maxConsecutive, currentConsecutive);
-      } else {
-        currentConsecutive = 0;
-      }
-    }
-    return maxConsecutive;
-  }
-  // Calculate win rate
-  calculateWinRate(prices) {
-    let wins = 0;
-    let total = 0;
-    for (let i = 1; i < prices.length; i++) {
-      if (prices[i] !== prices[i - 1]) {
-        total++;
-        if (prices[i] > prices[i - 1]) {
-          wins++;
-        }
-      }
-    }
-    return total > 0 ? wins / total : 0;
-  }
-  // Calculate profit factor
-  calculateProfitFactor(prices) {
-    let grossProfit = 0;
-    let grossLoss = 0;
-    for (let i = 1; i < prices.length; i++) {
-      const change = prices[i] - prices[i - 1];
-      if (change > 0) {
-        grossProfit += change;
-      } else {
-        grossLoss += Math.abs(change);
-      }
-    }
-    return grossLoss > 0 ? grossProfit / grossLoss : 0;
-  }
-  // Calculate Weighted Moving Average
-  calculateWma(data, period) {
-    const wma = [];
-    const weights = Array.from({ length: period }, (_, i) => i + 1);
-    const weightSum = weights.reduce((a, b) => a + b, 0);
-    for (let i = period - 1; i < data.length; i++) {
-      let weightedSum = 0;
-      for (let j = 0; j < period; j++) {
-        weightedSum += data[i - j] * weights[j];
-      }
-      wma.push(weightedSum / weightSum);
-    }
-    return wma;
-  }
-  // Calculate Volume Weighted Moving Average
-  calculateVwma(prices, period) {
-    const vwma = [];
-    for (let i = period - 1; i < prices.length; i++) {
-      let volumeSum = 0;
-      let priceVolumeSum = 0;
-      for (let j = 0; j < period; j++) {
-        const volume = this.volumes[i - j] || 1;
-        volumeSum += volume;
-        priceVolumeSum += prices[i - j] * volume;
-      }
-      vwma.push(priceVolumeSum / volumeSum);
-    }
-    return vwma;
-  }
-  // Calculate MACD
-  calculateMacd(prices) {
-    const ema12 = this.calculateEMA(prices, 12);
-    const ema26 = this.calculateEMA(prices, 26);
-    const macd = [];
-    const macdLine = [];
-    for (let i = 0; i < Math.min(ema12.length, ema26.length); i++) {
-      macdLine.push(ema12[i] - ema26[i]);
-    }
-    const signalLine = this.calculateEMA(macdLine, 9);
-    for (let i = 0; i < Math.min(macdLine.length, signalLine.length); i++) {
-      macd.push({
-        macd: macdLine[i],
-        signal: signalLine[i],
-        histogram: macdLine[i] - signalLine[i]
-      });
-    }
-    return macd;
-  }
-  // Calculate ADX (Average Directional Index)
-  calculateAdx(prices, highs, lows) {
-    if (prices.length < 14) return [];
-    const period = 14;
-    const adx = [];
-    const trueRanges = [];
-    const plusDM = [];
-    const minusDM = [];
-    trueRanges.push(highs[0] - lows[0]);
-    plusDM.push(0);
-    minusDM.push(0);
-    for (let i = 1; i < prices.length; i++) {
-      const high = highs[i] || prices[i];
-      const low = lows[i] || prices[i];
-      const prevHigh = highs[i - 1] || prices[i - 1];
-      const prevLow = lows[i - 1] || prices[i - 1];
-      const prevClose = prices[i - 1];
-      const tr1 = high - low;
-      const tr2 = Math.abs(high - prevClose);
-      const tr3 = Math.abs(low - prevClose);
-      trueRanges.push(Math.max(tr1, tr2, tr3));
-      const upMove = high - prevHigh;
-      const downMove = prevLow - low;
-      if (upMove > downMove && upMove > 0) {
-        plusDM.push(upMove);
-        minusDM.push(0);
-      } else if (downMove > upMove && downMove > 0) {
-        plusDM.push(0);
-        minusDM.push(downMove);
-      } else {
-        plusDM.push(0);
-        minusDM.push(0);
-      }
-    }
-    const smoothedTR = [];
-    const smoothedPlusDM = [];
-    const smoothedMinusDM = [];
-    let sumTR = 0;
-    let sumPlusDM = 0;
-    let sumMinusDM = 0;
-    for (let i = 0; i < period; i++) {
-      sumTR += trueRanges[i];
-      sumPlusDM += plusDM[i];
-      sumMinusDM += minusDM[i];
-    }
-    smoothedTR.push(sumTR);
-    smoothedPlusDM.push(sumPlusDM);
-    smoothedMinusDM.push(sumMinusDM);
-    for (let i = period; i < trueRanges.length; i++) {
-      const newTR = smoothedTR[smoothedTR.length - 1] - smoothedTR[smoothedTR.length - 1] / period + trueRanges[i];
-      const newPlusDM = smoothedPlusDM[smoothedPlusDM.length - 1] - smoothedPlusDM[smoothedPlusDM.length - 1] / period + plusDM[i];
-      const newMinusDM = smoothedMinusDM[smoothedMinusDM.length - 1] - smoothedMinusDM[smoothedMinusDM.length - 1] / period + minusDM[i];
-      smoothedTR.push(newTR);
-      smoothedPlusDM.push(newPlusDM);
-      smoothedMinusDM.push(newMinusDM);
-    }
-    const plusDI = [];
-    const minusDI = [];
-    for (let i = 0; i < smoothedTR.length; i++) {
-      plusDI.push(smoothedPlusDM[i] / smoothedTR[i] * 100);
-      minusDI.push(smoothedMinusDM[i] / smoothedTR[i] * 100);
-    }
-    const dx = [];
-    for (let i = 0; i < plusDI.length; i++) {
-      const diSum = plusDI[i] + minusDI[i];
-      const diDiff = Math.abs(plusDI[i] - minusDI[i]);
-      dx.push(diSum > 0 ? diDiff / diSum * 100 : 0);
-    }
-    if (dx.length < period) return [];
-    let sumDX = 0;
-    for (let i = 0; i < period; i++) {
-      sumDX += dx[i];
-    }
-    adx.push(sumDX / period);
-    for (let i = period; i < dx.length; i++) {
-      const newADX = adx[adx.length - 1] - adx[adx.length - 1] / period + dx[i];
-      adx.push(newADX);
-    }
-    return adx;
-  }
-  // Calculate DMI (Directional Movement Index)
-  calculateDmi(prices, highs, lows) {
-    if (prices.length < 14) return [];
-    const period = 14;
-    const dmi = [];
-    const trueRanges = [];
-    const plusDM = [];
-    const minusDM = [];
-    trueRanges.push(highs[0] - lows[0]);
-    plusDM.push(0);
-    minusDM.push(0);
-    for (let i = 1; i < prices.length; i++) {
-      const high = highs[i] || prices[i];
-      const low = lows[i] || prices[i];
-      const prevHigh = highs[i - 1] || prices[i - 1];
-      const prevLow = lows[i - 1] || prices[i - 1];
-      const prevClose = prices[i - 1];
-      const tr1 = high - low;
-      const tr2 = Math.abs(high - prevClose);
-      const tr3 = Math.abs(low - prevClose);
-      trueRanges.push(Math.max(tr1, tr2, tr3));
-      const upMove = high - prevHigh;
-      const downMove = prevLow - low;
-      if (upMove > downMove && upMove > 0) {
-        plusDM.push(upMove);
-        minusDM.push(0);
-      } else if (downMove > upMove && downMove > 0) {
-        plusDM.push(0);
-        minusDM.push(downMove);
-      } else {
-        plusDM.push(0);
-        minusDM.push(0);
-      }
-    }
-    const smoothedTR = [];
-    const smoothedPlusDM = [];
-    const smoothedMinusDM = [];
-    let sumTR = 0;
-    let sumPlusDM = 0;
-    let sumMinusDM = 0;
-    for (let i = 0; i < period; i++) {
-      sumTR += trueRanges[i];
-      sumPlusDM += plusDM[i];
-      sumMinusDM += minusDM[i];
-    }
-    smoothedTR.push(sumTR);
-    smoothedPlusDM.push(sumPlusDM);
-    smoothedMinusDM.push(sumMinusDM);
-    for (let i = period; i < trueRanges.length; i++) {
-      const newTR = smoothedTR[smoothedTR.length - 1] - smoothedTR[smoothedTR.length - 1] / period + trueRanges[i];
-      const newPlusDM = smoothedPlusDM[smoothedPlusDM.length - 1] - smoothedPlusDM[smoothedPlusDM.length - 1] / period + plusDM[i];
-      const newMinusDM = smoothedMinusDM[smoothedMinusDM.length - 1] - smoothedMinusDM[smoothedMinusDM.length - 1] / period + minusDM[i];
-      smoothedTR.push(newTR);
-      smoothedPlusDM.push(newPlusDM);
-      smoothedMinusDM.push(newMinusDM);
-    }
-    const plusDI = [];
-    const minusDI = [];
-    for (let i = 0; i < smoothedTR.length; i++) {
-      plusDI.push(smoothedPlusDM[i] / smoothedTR[i] * 100);
-      minusDI.push(smoothedMinusDM[i] / smoothedTR[i] * 100);
-    }
-    const dx = [];
-    for (let i = 0; i < plusDI.length; i++) {
-      const diSum = plusDI[i] + minusDI[i];
-      const diDiff = Math.abs(plusDI[i] - minusDI[i]);
-      dx.push(diSum > 0 ? diDiff / diSum * 100 : 0);
-    }
-    if (dx.length < period) return [];
-    const adx = [];
-    let sumDX = 0;
-    for (let i = 0; i < period; i++) {
-      sumDX += dx[i];
-    }
-    adx.push(sumDX / period);
-    for (let i = period; i < dx.length; i++) {
-      const newADX = adx[adx.length - 1] - adx[adx.length - 1] / period + dx[i];
-      adx.push(newADX);
-    }
-    for (let i = 0; i < adx.length; i++) {
-      dmi.push({
-        plusDI: plusDI[i + period - 1] || 0,
-        minusDI: minusDI[i + period - 1] || 0,
-        adx: adx[i]
-      });
-    }
-    return dmi;
-  }
-  // Calculate Ichimoku Cloud
-  calculateIchimoku(prices, highs, lows) {
-    if (prices.length < 52) return [];
-    const ichimoku = [];
-    const tenkanSen = [];
-    for (let i = 8; i < prices.length; i++) {
-      const periodHigh = Math.max(...highs.slice(i - 8, i + 1));
-      const periodLow = Math.min(...lows.slice(i - 8, i + 1));
-      tenkanSen.push((periodHigh + periodLow) / 2);
-    }
-    const kijunSen = [];
-    for (let i = 25; i < prices.length; i++) {
-      const periodHigh = Math.max(...highs.slice(i - 25, i + 1));
-      const periodLow = Math.min(...lows.slice(i - 25, i + 1));
-      kijunSen.push((periodHigh + periodLow) / 2);
-    }
-    const senkouSpanA = [];
-    for (let i = 0; i < Math.min(tenkanSen.length, kijunSen.length); i++) {
-      senkouSpanA.push((tenkanSen[i] + kijunSen[i]) / 2);
-    }
-    const senkouSpanB = [];
-    for (let i = 51; i < prices.length; i++) {
-      const periodHigh = Math.max(...highs.slice(i - 51, i + 1));
-      const periodLow = Math.min(...lows.slice(i - 51, i + 1));
-      senkouSpanB.push((periodHigh + periodLow) / 2);
-    }
-    const chikouSpan = [];
-    for (let i = 26; i < prices.length; i++) {
-      chikouSpan.push(prices[i - 26]);
-    }
-    const minLength = Math.min(
-      tenkanSen.length,
-      kijunSen.length,
-      senkouSpanA.length,
-      senkouSpanB.length,
-      chikouSpan.length
-    );
-    for (let i = 0; i < minLength; i++) {
-      ichimoku.push({
-        tenkan: tenkanSen[i],
-        kijun: kijunSen[i],
-        senkouA: senkouSpanA[i],
-        senkouB: senkouSpanB[i],
-        chikou: chikouSpan[i]
-      });
-    }
-    return ichimoku;
-  }
-  // Calculate Parabolic SAR
-  calculateParabolicSAR(prices, highs, lows) {
-    if (prices.length < 2) return [];
-    const sar = [];
-    const accelerationFactor = 0.02;
-    const maximumAcceleration = 0.2;
-    let currentSAR = lows[0];
-    let isLong = true;
-    let af = accelerationFactor;
-    let ep = highs[0];
-    sar.push(currentSAR);
-    for (let i = 1; i < prices.length; i++) {
-      const high = highs[i] || prices[i];
-      const low = lows[i] || prices[i];
-      if (isLong) {
-        if (low < currentSAR) {
-          isLong = false;
-          currentSAR = ep;
-          ep = low;
-          af = accelerationFactor;
-        } else {
-          if (high > ep) {
-            ep = high;
-            af = Math.min(af + accelerationFactor, maximumAcceleration);
-          }
-          currentSAR = currentSAR + af * (ep - currentSAR);
-          if (i > 0) {
-            const prevLow = lows[i - 1] || prices[i - 1];
-            currentSAR = Math.min(currentSAR, prevLow);
-          }
-        }
-      } else {
-        if (high > currentSAR) {
-          isLong = true;
-          currentSAR = ep;
-          ep = high;
-          af = accelerationFactor;
-        } else {
-          if (low < ep) {
-            ep = low;
-            af = Math.min(af + accelerationFactor, maximumAcceleration);
-          }
-          currentSAR = currentSAR + af * (ep - currentSAR);
-          if (i > 0) {
-            const prevHigh = highs[i - 1] || prices[i - 1];
-            currentSAR = Math.max(currentSAR, prevHigh);
-          }
-        }
-      }
-      sar.push(currentSAR);
-    }
-    return sar;
-  }
-  // Calculate Stochastic
-  calculateStochastic(prices, highs, lows) {
-    const stochastic = [];
-    const period = 14;
-    const smoothK = 3;
-    const smoothD = 3;
-    if (prices.length < period) return [];
-    const percentK = [];
-    for (let i = period - 1; i < prices.length; i++) {
-      const high = Math.max(...highs.slice(i - period + 1, i + 1));
-      const low = Math.min(...lows.slice(i - period + 1, i + 1));
-      const close = prices[i];
-      const k = (close - low) / (high - low) * 100;
-      percentK.push(k);
-    }
-    const smoothedK = [];
-    for (let i = smoothK - 1; i < percentK.length; i++) {
-      const sum2 = percentK.slice(i - smoothK + 1, i + 1).reduce((a, b) => a + b, 0);
-      smoothedK.push(sum2 / smoothK);
-    }
-    for (let i = smoothD - 1; i < smoothedK.length; i++) {
-      const sum2 = smoothedK.slice(i - smoothD + 1, i + 1).reduce((a, b) => a + b, 0);
-      const d = sum2 / smoothD;
-      stochastic.push({
-        k: smoothedK[i],
-        d
-      });
-    }
-    return stochastic;
-  }
-  // Calculate CCI
-  calculateCci(prices, highs, lows) {
-    const cci = [];
-    const period = 20;
-    if (prices.length < period) return [];
-    for (let i = period - 1; i < prices.length; i++) {
-      const slice = prices.slice(i - period + 1, i + 1);
-      const typicalPrices = slice.map((price, idx) => {
-        const high = highs[i - period + 1 + idx] || price;
-        const low = lows[i - period + 1 + idx] || price;
-        return (high + low + price) / 3;
-      });
-      const sma = typicalPrices.reduce((a, b) => a + b, 0) / period;
-      const meanDeviation = typicalPrices.reduce((sum2, tp) => sum2 + Math.abs(tp - sma), 0) / period;
-      const currentTP = (highs[i] + lows[i] + prices[i]) / 3;
-      const cciValue = meanDeviation !== 0 ? (currentTP - sma) / (0.015 * meanDeviation) : 0;
-      cci.push(cciValue);
-    }
-    return cci;
-  }
-  // Calculate Rate of Change
-  calculateRoc(prices) {
-    const roc = [];
-    for (let i = 10; i < prices.length; i++) {
-      roc.push((prices[i] - prices[i - 10]) / prices[i - 10] * 100);
-    }
-    return roc;
-  }
-  // Calculate Williams %R
-  calculateWilliamsR(prices) {
-    const williamsR = [];
-    const period = 14;
-    if (prices.length < period) return [];
-    for (let i = period - 1; i < prices.length; i++) {
-      const slice = prices.slice(i - period + 1, i + 1);
-      const high = Math.max(...slice);
-      const low = Math.min(...slice);
-      const close = prices[i];
-      const wr = (high - close) / (high - low) * -100;
-      williamsR.push(wr);
-    }
-    return williamsR;
-  }
-  // Calculate Momentum
-  calculateMomentum(prices) {
-    const momentum = [];
-    for (let i = 10; i < prices.length; i++) {
-      momentum.push(prices[i] - prices[i - 10]);
-    }
-    return momentum;
-  }
-  // Calculate Keltner Channels
-  calculateKeltnerChannels(prices, highs, lows) {
-    const keltner = [];
-    const period = 20;
-    const multiplier = 2;
-    if (prices.length < period) return [];
-    const ema = this.calculateEMA(prices, period);
-    const atr = this.calculateAtr(prices, highs, lows);
-    for (let i = 0; i < Math.min(ema.length, atr.length); i++) {
-      const middle = ema[i];
-      const atrValue = atr[i];
-      keltner.push({
-        upper: middle + multiplier * atrValue,
-        middle,
-        lower: middle - multiplier * atrValue
-      });
-    }
-    return keltner;
-  }
-  // Calculate Donchian Channels
-  calculateDonchianChannels(prices) {
-    const donchian = [];
-    for (let i = 20; i < prices.length; i++) {
-      const slice = prices.slice(i - 20, i);
-      donchian.push({
-        upper: Math.max(...slice),
-        middle: (Math.max(...slice) + Math.min(...slice)) / 2,
-        lower: Math.min(...slice)
-      });
-    }
-    return donchian;
-  }
-  // Calculate Chaikin Volatility
-  calculateChaikinVolatility(prices, highs, lows) {
-    const volatility = [];
-    const period = 10;
-    if (prices.length < period * 2) return [];
-    const highLowRange = [];
-    for (let i = 0; i < prices.length; i++) {
-      const high = highs[i] || prices[i];
-      const low = lows[i] || prices[i];
-      highLowRange.push(high - low);
-    }
-    const emaRange = this.calculateEMA(highLowRange, period);
-    for (let i = period; i < emaRange.length; i++) {
-      const currentEMA = emaRange[i];
-      const pastEMA = emaRange[i - period];
-      const volatilityValue = pastEMA !== 0 ? (currentEMA - pastEMA) / pastEMA * 100 : 0;
-      volatility.push(volatilityValue);
-    }
-    return volatility;
-  }
-  // Calculate On Balance Volume
-  calculateObv(volumes) {
-    const obv = [volumes[0]];
-    for (let i = 1; i < volumes.length; i++) {
-      obv.push(obv[i - 1] + volumes[i]);
-    }
-    return obv;
-  }
-  // Calculate Chaikin Money Flow
-  calculateCmf(prices, highs, lows, volumes) {
-    const cmf = [];
-    const period = 20;
-    if (prices.length < period) return [];
-    for (let i = period - 1; i < prices.length; i++) {
-      let totalMoneyFlowVolume = 0;
-      let totalVolume = 0;
-      for (let j = i - period + 1; j <= i; j++) {
-        const high = highs[j] || prices[j];
-        const low = lows[j] || prices[j];
-        const close = prices[j];
-        const volume = volumes[j] || 1;
-        const moneyFlowMultiplier = (close - low - (high - close)) / (high - low);
-        const moneyFlowVolume = moneyFlowMultiplier * volume;
-        totalMoneyFlowVolume += moneyFlowVolume;
-        totalVolume += volume;
-      }
-      const cmfValue = totalVolume !== 0 ? totalMoneyFlowVolume / totalVolume : 0;
-      cmf.push(cmfValue);
-    }
-    return cmf;
-  }
-  // Calculate Accumulation/Distribution Line
-  calculateAdl(prices) {
-    const adl = [0];
-    for (let i = 1; i < prices.length; i++) {
-      const high = this.highs[i] || prices[i];
-      const low = this.lows[i] || prices[i];
-      const close = prices[i];
-      const volume = this.volumes[i] || 1;
-      const moneyFlowMultiplier = (close - low - (high - close)) / (high - low);
-      const moneyFlowVolume = moneyFlowMultiplier * volume;
-      adl.push(adl[i - 1] + moneyFlowVolume);
-    }
-    return adl;
-  }
-  // Calculate Volume Rate of Change
-  calculateVolumeROC() {
-    const volumeROC = [];
-    for (let i = 10; i < this.volumes.length; i++) {
-      volumeROC.push((this.volumes[i] - this.volumes[i - 10]) / this.volumes[i - 10] * 100);
-    }
-    return volumeROC;
-  }
-  // Calculate Money Flow Index
-  calculateMfi(prices, highs, lows, volumes) {
-    const mfi = [];
-    const period = 14;
-    if (prices.length < period + 1) return [];
-    for (let i = period; i < prices.length; i++) {
-      let positiveMoneyFlow = 0;
-      let negativeMoneyFlow = 0;
-      for (let j = i - period + 1; j <= i; j++) {
-        const high = highs[j] || prices[j];
-        const low = lows[j] || prices[j];
-        const close = prices[j];
-        const volume = volumes[j] || 1;
-        const typicalPrice = (high + low + close) / 3;
-        const moneyFlow = typicalPrice * volume;
-        if (j > i - period + 1) {
-          const prevHigh = highs[j - 1] || prices[j - 1];
-          const prevLow = lows[j - 1] || prices[j - 1];
-          const prevClose = prices[j - 1];
-          const prevTypicalPrice = (prevHigh + prevLow + prevClose) / 3;
-          if (typicalPrice > prevTypicalPrice) {
-            positiveMoneyFlow += moneyFlow;
-          } else if (typicalPrice < prevTypicalPrice) {
-            negativeMoneyFlow += moneyFlow;
-          }
-        }
-      }
-      const moneyRatio = negativeMoneyFlow !== 0 ? positiveMoneyFlow / negativeMoneyFlow : 0;
-      const mfiValue = 100 - 100 / (1 + moneyRatio);
-      mfi.push(mfiValue);
-    }
-    return mfi;
-  }
-  // Calculate VWAP
-  calculateVwap(prices, volumes) {
-    const vwap = [];
-    let cumulativePV = 0;
-    let cumulativeVolume = 0;
-    for (let i = 0; i < prices.length; i++) {
-      cumulativePV += prices[i] * (volumes[i] || 1);
-      cumulativeVolume += volumes[i] || 1;
-      vwap.push(cumulativePV / cumulativeVolume);
-    }
-    return vwap;
-  }
-  // Calculate Pivot Points
-  calculatePivotPoints(prices) {
-    const pivotPoints = [];
-    for (let i = 0; i < prices.length; i++) {
-      const high = this.highs[i] || prices[i];
-      const low = this.lows[i] || prices[i];
-      const close = prices[i];
-      const pp = (high + low + close) / 3;
-      const r1 = 2 * pp - low;
-      const s1 = 2 * pp - high;
-      const r2 = pp + (high - low);
-      const s2 = pp - (high - low);
-      const r3 = high + 2 * (pp - low);
-      const s3 = low - 2 * (high - pp);
-      pivotPoints.push({
-        pp,
-        r1,
-        r2,
-        r3,
-        s1,
-        s2,
-        s3
-      });
-    }
-    return pivotPoints;
-  }
-  // Calculate Fibonacci Levels
-  calculateFibonacciLevels(prices) {
-    const fibonacci = [];
-    for (let i = 0; i < prices.length; i++) {
-      const price = prices[i];
-      fibonacci.push({
-        retracement: {
-          level0: price,
-          level236: price * 0.764,
-          level382: price * 0.618,
-          level500: price * 0.5,
-          level618: price * 0.382,
-          level786: price * 0.214,
-          level100: price * 0
-        },
-        extension: {
-          level1272: price * 1.272,
-          level1618: price * 1.618,
-          level2618: price * 2.618,
-          level4236: price * 4.236
-        }
-      });
-    }
-    return fibonacci;
-  }
-  // Calculate Gann Levels
-  calculateGannLevels(prices) {
-    const gannLevels = [];
-    for (let i = 0; i < prices.length; i++) {
-      gannLevels.push(prices[i] * (1 + i * 0.01));
-    }
-    return gannLevels;
-  }
-  // Calculate Elliott Wave
-  calculateElliottWave(prices) {
-    const elliottWave = [];
-    if (prices.length < 10) return [];
-    for (let i = 0; i < prices.length; i++) {
-      const waves = [];
-      let currentWave = 1;
-      let wavePosition = 0.5;
-      if (i >= 4) {
-        const recentPrices = prices.slice(i - 4, i + 1);
-        const swings = this.detectPriceSwings(recentPrices);
-        if (swings.length >= 3) {
-          waves.push(...swings.slice(0, 3));
-          currentWave = Math.min(swings.length, 5);
-          wavePosition = this.calculateWavePosition(recentPrices);
-        }
-      }
-      elliottWave.push({
-        waves: waves.length > 0 ? waves : [prices[i]],
-        currentWave,
-        wavePosition
-      });
-    }
-    return elliottWave;
-  }
-  // Helper method to detect price swings
-  detectPriceSwings(prices) {
-    const swings = [];
-    for (let i = 1; i < prices.length - 1; i++) {
-      const prev = prices[i - 1];
-      const curr = prices[i];
-      const next = prices[i + 1];
-      if (curr > prev && curr > next) {
-        swings.push(curr);
-      } else if (curr < prev && curr < next) {
-        swings.push(curr);
-      }
-    }
-    return swings;
-  }
-  // Helper method to calculate wave position
-  calculateWavePosition(prices) {
-    if (prices.length < 2) return 0.5;
-    const current = prices[prices.length - 1];
-    const min = Math.min(...prices);
-    const max = Math.max(...prices);
-    return max !== min ? (current - min) / (max - min) : 0.5;
-  }
-  // Calculate Harmonic Patterns
-  calculateHarmonicPatterns(prices) {
-    const harmonicPatterns = [];
-    if (prices.length < 5) return [];
-    for (let i = 4; i < prices.length; i++) {
-      const recentPrices = prices.slice(i - 4, i + 1);
-      const pattern = this.detectHarmonicPattern(recentPrices);
-      harmonicPatterns.push(pattern);
-    }
-    return harmonicPatterns;
-  }
-  // Helper method to detect harmonic patterns
-  detectHarmonicPattern(prices) {
-    if (prices.length < 5) {
-      return {
-        type: "Unknown",
-        completion: 0,
-        target: prices[prices.length - 1] * 1.1,
-        stopLoss: prices[prices.length - 1] * 0.9
-      };
-    }
-    const swings = this.detectPriceSwings(prices);
-    if (swings.length < 4) {
-      return {
-        type: "Unknown",
-        completion: 0,
-        target: prices[prices.length - 1] * 1.1,
-        stopLoss: prices[prices.length - 1] * 0.9
-      };
-    }
-    const [A, B, C, D] = swings.slice(-4);
-    const X = prices[0];
-    const abRatio = Math.abs((B - A) / (X - A));
-    const bcRatio = Math.abs((C - B) / (A - B));
-    const cdRatio = Math.abs((D - C) / (B - C));
-    const adRatio = Math.abs((D - A) / (X - A));
-    const isGartley = Math.abs(abRatio - 0.618) < 0.1 && bcRatio >= 0.382 && bcRatio <= 0.886 && cdRatio >= 1.13 && cdRatio <= 1.618 && Math.abs(adRatio - 0.786) < 0.1;
-    if (isGartley) {
-      const completion = this.calculatePatternCompletion(prices);
-      const target = D + (D - C) * 0.618;
-      const stopLoss = D - (D - C) * 0.382;
-      return {
-        type: "Gartley",
-        completion,
-        target,
-        stopLoss
-      };
-    }
-    const isButterfly = Math.abs(abRatio - 0.786) < 0.1 && bcRatio >= 0.382 && bcRatio <= 0.886 && cdRatio >= 1.618 && cdRatio <= 2.618 && Math.abs(adRatio - 1.27) < 0.1;
-    if (isButterfly) {
-      const completion = this.calculatePatternCompletion(prices);
-      const target = D + (D - C) * 1.27;
-      const stopLoss = D - (D - C) * 0.5;
-      return {
-        type: "Butterfly",
-        completion,
-        target,
-        stopLoss
-      };
-    }
-    return {
-      type: "Unknown",
-      completion: 0,
-      target: prices[prices.length - 1] * 1.1,
-      stopLoss: prices[prices.length - 1] * 0.9
-    };
-  }
-  // Helper method to calculate pattern completion
-  calculatePatternCompletion(prices) {
-    if (prices.length < 2) return 0;
-    const current = prices[prices.length - 1];
-    const min = Math.min(...prices);
-    const max = Math.max(...prices);
-    return max !== min ? (current - min) / (max - min) : 0;
-  }
-  // Calculate Position Size
-  calculatePositionSize(currentPrice, targetEntry, stopLoss) {
-    void currentPrice;
-    const riskPerShare = Math.abs(targetEntry - stopLoss);
-    return riskPerShare > 0 ? 100 / riskPerShare : 1;
-  }
-  // Calculate Confidence
-  calculateConfidence(signals) {
-    return Math.min(signals.length * 10, 100);
-  }
-  // Calculate Risk Level
-  calculateRiskLevel(volatility) {
-    if (volatility < 20) return "LOW";
-    if (volatility < 40) return "MEDIUM";
-    return "HIGH";
-  }
-  // Calculate Z-Score
-  calculateZScore(currentPrice, startPrice) {
-    return (currentPrice - startPrice) / (startPrice * 0.1);
-  }
-  // Calculate Ornstein-Uhlenbeck
-  calculateOrnsteinUhlenbeck(currentPrice, startPrice, avgVolume) {
-    const priceChanges = this.calculatePriceChanges();
-    const mean = startPrice;
-    let speed = 0.1;
-    if (priceChanges.length > 1) {
-      const variance = priceChanges.reduce((sum2, change) => sum2 + change * change, 0) / priceChanges.length;
-      speed = Math.max(0.01, Math.min(1, variance * 10));
-    }
-    const volatility = avgVolume * 0.01;
-    return {
-      mean,
-      speed,
-      volatility,
-      currentValue: currentPrice
-    };
-  }
-  // Calculate Kalman Filter
-  calculateKalmanFilter(currentPrice, startPrice, avgVolume) {
-    const measurementNoise = avgVolume * 1e-3;
-    const processNoise = avgVolume * 1e-4;
-    let state = startPrice;
-    let covariance = measurementNoise;
-    const priceChanges = this.calculatePriceChanges();
-    if (priceChanges.length > 0) {
-      const predictedState = state;
-      const predictedCovariance = covariance + processNoise;
-      const kalmanGain = predictedCovariance / (predictedCovariance + measurementNoise);
-      state = predictedState + kalmanGain * (currentPrice - predictedState);
-      covariance = (1 - kalmanGain) * predictedCovariance;
-      return {
-        state,
-        covariance,
-        gain: kalmanGain
-      };
-    }
-    return {
-      state: currentPrice,
-      covariance,
-      gain: 0.5
-    };
-  }
-  // Calculate ARIMA
-  calculateArima(currentPrice) {
-    const priceChanges = this.calculatePriceChanges();
-    if (priceChanges.length < 3) {
-      return {
-        forecast: [currentPrice * 1.01, currentPrice * 1.02],
-        residuals: [0, 0],
-        aic: 100
-      };
-    }
-    const n = priceChanges.length;
-    let sumY = 0;
-    let sumY1 = 0;
-    let sumYY1 = 0;
-    let sumY1Sq = 0;
-    for (let i = 1; i < n; i++) {
-      const y = priceChanges[i];
-      const y1 = priceChanges[i - 1];
-      sumY += y;
-      sumY1 += y1;
-      sumYY1 += y * y1;
-      sumY1Sq += y1 * y1;
-    }
-    const phi = (n * sumYY1 - sumY * sumY1) / (n * sumY1Sq - sumY1 * sumY1);
-    const c = (sumY - phi * sumY1) / n;
-    const residuals = [];
-    for (let i = 1; i < n; i++) {
-      const predicted = c + phi * priceChanges[i - 1];
-      residuals.push(priceChanges[i] - predicted);
-    }
-    const rss = residuals.reduce((sum2, r) => sum2 + r * r, 0);
-    const aic = n * Math.log(rss / n) + 2 * 2;
-    const lastChange = priceChanges[priceChanges.length - 1];
-    const forecast1 = currentPrice + (c + phi * lastChange);
-    const forecast2 = forecast1 + (c + phi * (c + phi * lastChange));
-    return {
-      forecast: [forecast1, forecast2],
-      residuals,
-      aic
-    };
-  }
-  // Calculate GARCH
-  calculateGarch(avgVolume) {
-    const priceChanges = this.calculatePriceChanges();
-    if (priceChanges.length < 5) {
-      return {
-        volatility: avgVolume * 0.01,
-        persistence: 0.9,
-        meanReversion: 0.1
-      };
-    }
-    const squaredReturns = priceChanges.map((change) => change * change);
-    const meanSquaredReturn = squaredReturns.reduce((sum2, sq) => sum2 + sq, 0) / squaredReturns.length;
-    let persistence = 0.9;
-    if (squaredReturns.length > 1) {
-      const variance = squaredReturns.reduce((sum2, sq) => sum2 + sq, 0) / squaredReturns.length;
-      persistence = Math.min(0.99, Math.max(0.5, variance / meanSquaredReturn));
-    }
-    const meanReversion = meanSquaredReturn * (1 - persistence);
-    const volatility = Math.sqrt(meanSquaredReturn);
-    return {
-      volatility,
-      persistence,
-      meanReversion
-    };
-  }
-  // Calculate Hilbert Transform
-  calculateHilbertTransform(currentPrice) {
-    const priceChanges = this.calculatePriceChanges();
-    if (priceChanges.length < 3) {
-      return {
-        analytic: [currentPrice],
-        phase: [0],
-        amplitude: [currentPrice]
-      };
-    }
-    const n = priceChanges.length;
-    const analytic = [];
-    const phase = [];
-    const amplitude = [];
-    for (let i = 0; i < n; i++) {
-      let hilbertValue = 0;
-      for (let j = 0; j < n; j++) {
-        if (i !== j) {
-          hilbertValue += priceChanges[j] / (Math.PI * (i - j));
-        }
-      }
-      const realPart = priceChanges[i];
-      const imagPart = hilbertValue;
-      const analyticValue = Math.sqrt(realPart * realPart + imagPart * imagPart);
-      analytic.push(analyticValue);
-      const phaseValue = Math.atan2(imagPart, realPart);
-      phase.push(phaseValue);
-      amplitude.push(analyticValue);
-    }
-    return {
-      analytic,
-      phase,
-      amplitude
-    };
-  }
-  // Calculate Wavelet Transform
-  calculateWaveletTransform(currentPrice) {
-    const priceChanges = this.calculatePriceChanges();
-    if (priceChanges.length < 4) {
-      return {
-        coefficients: [currentPrice],
-        scales: [1]
-      };
-    }
-    const coefficients = [];
-    const scales = [];
-    const n = priceChanges.length;
-    const maxLevel = Math.floor(Math.log2(n));
-    for (let level = 1; level <= maxLevel; level++) {
-      const step = 2 ** (level - 1);
-      const scale = step;
-      for (let i = 0; i < n - step; i += step * 2) {
-        if (i + step < n) {
-          const coefficient = (priceChanges[i] - priceChanges[i + step]) / Math.sqrt(2);
-          coefficients.push(coefficient);
-          scales.push(scale);
-        }
-      }
-    }
-    if (coefficients.length === 0) {
-      coefficients.push(currentPrice);
-      scales.push(1);
-    }
-    return {
-      coefficients,
-      scales
-    };
-  }
-  // Calculate Black-Scholes
-  calculateBlackScholes(currentPrice, startPrice, avgVolume) {
-    const S = currentPrice;
-    const K = startPrice;
-    const T = 1;
-    const r = 0.05;
-    const sigma = avgVolume * 0.01;
-    const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
-    const d2 = d1 - sigma * Math.sqrt(T);
-    const callPrice = S * this.normalCDF(d1) - K * Math.exp(-r * T) * this.normalCDF(d2);
-    const putPrice = K * Math.exp(-r * T) * this.normalCDF(-d2) - S * this.normalCDF(-d1);
-    return {
-      callPrice,
-      putPrice,
-      delta: this.normalCDF(d1),
-      gamma: this.normalPDF(d1) / (S * sigma * Math.sqrt(T)),
-      theta: -S * this.normalPDF(d1) * sigma / (2 * Math.sqrt(T)) - r * K * Math.exp(-r * T) * this.normalCDF(d2),
-      vega: S * Math.sqrt(T) * this.normalPDF(d1),
-      rho: K * T * Math.exp(-r * T) * this.normalCDF(d2)
-    };
-  }
-  // Normal CDF approximation
-  normalCDF(x) {
-    return 0.5 * (1 + this.erf(x / Math.sqrt(2)));
-  }
-  // Normal PDF
-  normalPDF(x) {
-    return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
-  }
-  // Error function approximation
-  erf(x) {
-    const a1 = 0.254829592;
-    const a2 = -0.284496736;
-    const a3 = 1.421413741;
-    const a4 = -1.453152027;
-    const a5 = 1.061405429;
-    const p = 0.3275911;
-    const sign = x >= 0 ? 1 : -1;
-    const absX = Math.abs(x);
-    const t = 1 / (1 + p * absX);
-    const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
-    return sign * y;
-  }
-  // Calculate price changes for volatility
-  calculatePriceChanges() {
-    const changes = [];
-    for (let i = 1; i < this.prices.length; i++) {
-      changes.push((this.prices[i] - this.prices[i - 1]) / this.prices[i - 1]);
-    }
-    return changes;
-  }
-  // Generate comprehensive market analysis
-  analyze() {
-    const currentPrice = this.prices[this.prices.length - 1];
-    const startPrice = this.prices[0];
-    const sessionHigh = Math.max(...this.highs);
-    const sessionLow = Math.min(...this.lows);
-    const totalVolume = sum(this.volumes);
-    const avgVolume = totalVolume / this.volumes.length;
-    const priceChanges = this.calculatePriceChanges();
-    const volatility = priceChanges.length > 0 ? Math.sqrt(
-      priceChanges.reduce((sum2, change) => sum2 + change ** 2, 0) / priceChanges.length
-    ) * Math.sqrt(252) * 100 : 0;
-    const sessionReturn = (currentPrice - startPrice) / startPrice * 100;
-    const pricePosition = (currentPrice - sessionLow) / (sessionHigh - sessionLow) * 100;
-    const trueVWAP = this.prices.reduce((sum2, price, i) => sum2 + price * this.volumes[i], 0) / totalVolume;
-    const momentum5 = this.prices.length > 5 ? (currentPrice - this.prices[Math.max(0, this.prices.length - 6)]) / this.prices[Math.max(0, this.prices.length - 6)] * 100 : 0;
-    const momentum10 = this.prices.length > 10 ? (currentPrice - this.prices[Math.max(0, this.prices.length - 11)]) / this.prices[Math.max(0, this.prices.length - 11)] * 100 : 0;
-    const maxDrawdown = this.calculateMaxDrawdown(this.prices);
-    const atrValues = this.calculateAtr(this.prices, this.highs, this.lows);
-    const atr = atrValues.length > 0 ? atrValues[atrValues.length - 1] : 0;
-    const impliedVolatility = volatility;
-    const realizedVolatility = volatility;
-    const sharpeRatio = sessionReturn / volatility;
-    const sortinoRatio = sessionReturn / realizedVolatility;
-    const calmarRatio = sessionReturn / maxDrawdown;
-    const maxConsecutiveLosses = this.calculateMaxConsecutiveLosses(this.prices);
-    const winRate = this.calculateWinRate(this.prices);
-    const profitFactor = this.calculateProfitFactor(this.prices);
-    return {
-      currentPrice,
-      startPrice,
-      sessionHigh,
-      sessionLow,
-      totalVolume,
-      avgVolume,
-      volatility,
-      sessionReturn,
-      pricePosition,
-      trueVWAP,
-      momentum5,
-      momentum10,
-      maxDrawdown,
-      atr,
-      impliedVolatility,
-      realizedVolatility,
-      sharpeRatio,
-      sortinoRatio,
-      calmarRatio,
-      maxConsecutiveLosses,
-      winRate,
-      profitFactor
-    };
-  }
-  // Generate technical indicators
-  getTechnicalIndicators() {
-    return {
-      sma5: this.calculateSMA(this.prices, 5),
-      sma10: this.calculateSMA(this.prices, 10),
-      sma20: this.calculateSMA(this.prices, 20),
-      sma50: this.calculateSMA(this.prices, 50),
-      sma200: this.calculateSMA(this.prices, 200),
-      ema8: this.calculateEMA(this.prices, 8),
-      ema12: this.calculateEMA(this.prices, 12),
-      ema21: this.calculateEMA(this.prices, 21),
-      ema26: this.calculateEMA(this.prices, 26),
-      wma20: this.calculateWma(this.prices, 20),
-      vwma20: this.calculateVwma(this.prices, 20),
-      macd: this.calculateMacd(this.prices),
-      adx: this.calculateAdx(this.prices, this.highs, this.lows),
-      dmi: this.calculateDmi(this.prices, this.highs, this.lows),
-      ichimoku: this.calculateIchimoku(this.prices, this.highs, this.lows),
-      parabolicSAR: this.calculateParabolicSAR(this.prices, this.highs, this.lows),
-      rsi: this.calculateRSI(this.prices, 14),
-      stochastic: this.calculateStochastic(this.prices, this.highs, this.lows),
-      cci: this.calculateCci(this.prices, this.highs, this.lows),
-      roc: this.calculateRoc(this.prices),
-      williamsR: this.calculateWilliamsR(this.prices),
-      momentum: this.calculateMomentum(this.prices),
-      bollinger: this.calculateBollingerBands(this.prices, 20, 2),
-      atr: this.calculateAtr(this.prices, this.highs, this.lows),
-      keltner: this.calculateKeltnerChannels(this.prices, this.highs, this.lows),
-      donchian: this.calculateDonchianChannels(this.prices),
-      chaikinVolatility: this.calculateChaikinVolatility(this.prices, this.highs, this.lows),
-      obv: this.calculateObv(this.volumes),
-      cmf: this.calculateCmf(this.prices, this.highs, this.lows, this.volumes),
-      adl: this.calculateAdl(this.prices),
-      volumeROC: this.calculateVolumeROC(),
-      mfi: this.calculateMfi(this.prices, this.highs, this.lows, this.volumes),
-      vwap: this.calculateVwap(this.prices, this.volumes),
-      pivotPoints: this.calculatePivotPoints(this.prices),
-      fibonacci: this.calculateFibonacciLevels(this.prices),
-      gannLevels: this.calculateGannLevels(this.prices),
-      elliottWave: this.calculateElliottWave(this.prices),
-      harmonicPatterns: this.calculateHarmonicPatterns(this.prices)
-    };
-  }
-  // Generate trading signals
-  generateSignals() {
-    const analysis = this.analyze();
-    let bullishSignals = 0;
-    let bearishSignals = 0;
-    const signals = [];
-    if (analysis.currentPrice > analysis.trueVWAP) {
-      signals.push(
-        `\u2713 BULLISH: Price above VWAP (+${((analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100).toFixed(2)}%)`
-      );
-      bullishSignals++;
-    } else {
-      signals.push(
-        `\u2717 BEARISH: Price below VWAP (${((analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100).toFixed(2)}%)`
-      );
-      bearishSignals++;
-    }
-    if (analysis.momentum5 > 0 && analysis.momentum10 > 0) {
-      signals.push("\u2713 BULLISH: Positive momentum on both timeframes");
-      bullishSignals++;
-    } else if (analysis.momentum5 < 0 && analysis.momentum10 < 0) {
-      signals.push("\u2717 BEARISH: Negative momentum on both timeframes");
-      bearishSignals++;
-    } else {
-      signals.push("\u25D0 MIXED: Conflicting momentum signals");
-    }
-    const currentVolume = this.volumes[this.volumes.length - 1];
-    const volumeRatio = currentVolume / analysis.avgVolume;
-    if (volumeRatio > 1.2 && analysis.sessionReturn > 0) {
-      signals.push("\u2713 BULLISH: Above-average volume supporting upward move");
-      bullishSignals++;
-    } else if (volumeRatio > 1.2 && analysis.sessionReturn < 0) {
-      signals.push("\u2717 BEARISH: Above-average volume supporting downward move");
-      bearishSignals++;
-    } else {
-      signals.push("\u25D0 NEUTRAL: Volume not providing clear direction");
-    }
-    if (analysis.pricePosition > 65 && analysis.volatility > 30) {
-      signals.push("\u2717 BEARISH: High in range with elevated volatility - reversal risk");
-      bearishSignals++;
-    } else if (analysis.pricePosition < 35 && analysis.volatility > 30) {
-      signals.push("\u2713 BULLISH: Low in range with volatility - potential bounce");
-      bullishSignals++;
-    } else {
-      signals.push("\u25D0 NEUTRAL: Price position and volatility not extreme");
-    }
-    return { bullishSignals, bearishSignals, signals };
-  }
-  // Generate comprehensive JSON analysis
-  generateJSONAnalysis(symbol) {
-    const analysis = this.analyze();
-    const indicators = this.getTechnicalIndicators();
-    const signals = this.generateSignals();
-    const currentSMA5 = indicators.sma5.length > 0 ? indicators.sma5[indicators.sma5.length - 1] : null;
-    const currentSMA10 = indicators.sma10.length > 0 ? indicators.sma10[indicators.sma10.length - 1] : null;
-    const currentSMA20 = indicators.sma20.length > 0 ? indicators.sma20[indicators.sma20.length - 1] : null;
-    const currentSMA50 = indicators.sma50.length > 0 ? indicators.sma50[indicators.sma50.length - 1] : null;
-    const currentSMA200 = indicators.sma200.length > 0 ? indicators.sma200[indicators.sma200.length - 1] : null;
-    const currentEMA8 = indicators.ema8[indicators.ema8.length - 1];
-    const currentEMA12 = indicators.ema12[indicators.ema12.length - 1];
-    const currentEMA21 = indicators.ema21[indicators.ema21.length - 1];
-    const currentEMA26 = indicators.ema26[indicators.ema26.length - 1];
-    const currentWMA20 = indicators.wma20.length > 0 ? indicators.wma20[indicators.wma20.length - 1] : null;
-    const currentVWMA20 = indicators.vwma20.length > 0 ? indicators.vwma20[indicators.vwma20.length - 1] : null;
-    const currentMACD = indicators.macd.length > 0 ? indicators.macd[indicators.macd.length - 1] : null;
-    const currentADX = indicators.adx.length > 0 ? indicators.adx[indicators.adx.length - 1] : null;
-    const currentDMI = indicators.dmi.length > 0 ? indicators.dmi[indicators.dmi.length - 1] : null;
-    const currentIchimoku = indicators.ichimoku.length > 0 ? indicators.ichimoku[indicators.ichimoku.length - 1] : null;
-    const currentParabolicSAR = indicators.parabolicSAR.length > 0 ? indicators.parabolicSAR[indicators.parabolicSAR.length - 1] : null;
-    const currentRSI = indicators.rsi.length > 0 ? indicators.rsi[indicators.rsi.length - 1] : null;
-    const currentStochastic = indicators.stochastic.length > 0 ? indicators.stochastic[indicators.stochastic.length - 1] : null;
-    const currentCCI = indicators.cci.length > 0 ? indicators.cci[indicators.cci.length - 1] : null;
-    const currentROC = indicators.roc.length > 0 ? indicators.roc[indicators.roc.length - 1] : null;
-    const currentWilliamsR = indicators.williamsR.length > 0 ? indicators.williamsR[indicators.williamsR.length - 1] : null;
-    const currentMomentum = indicators.momentum.length > 0 ? indicators.momentum[indicators.momentum.length - 1] : null;
-    const currentBB = indicators.bollinger.length > 0 ? indicators.bollinger[indicators.bollinger.length - 1] : null;
-    const currentAtr = indicators.atr.length > 0 ? indicators.atr[indicators.atr.length - 1] : null;
-    const currentKeltner = indicators.keltner.length > 0 ? indicators.keltner[indicators.keltner.length - 1] : null;
-    const currentDonchian = indicators.donchian.length > 0 ? indicators.donchian[indicators.donchian.length - 1] : null;
-    const currentChaikinVolatility = indicators.chaikinVolatility.length > 0 ? indicators.chaikinVolatility[indicators.chaikinVolatility.length - 1] : null;
-    const currentObv = indicators.obv.length > 0 ? indicators.obv[indicators.obv.length - 1] : null;
-    const currentCmf = indicators.cmf.length > 0 ? indicators.cmf[indicators.cmf.length - 1] : null;
-    const currentAdl = indicators.adl.length > 0 ? indicators.adl[indicators.adl.length - 1] : null;
-    const currentVolumeROC = indicators.volumeROC.length > 0 ? indicators.volumeROC[indicators.volumeROC.length - 1] : null;
-    const currentMfi = indicators.mfi.length > 0 ? indicators.mfi[indicators.mfi.length - 1] : null;
-    const currentVwap = indicators.vwap.length > 0 ? indicators.vwap[indicators.vwap.length - 1] : null;
-    const currentPivotPoints = indicators.pivotPoints.length > 0 ? indicators.pivotPoints[indicators.pivotPoints.length - 1] : null;
-    const currentFibonacci = indicators.fibonacci.length > 0 ? indicators.fibonacci[indicators.fibonacci.length - 1] : null;
-    const currentGannLevels = indicators.gannLevels.length > 0 ? indicators.gannLevels : [];
-    const currentElliottWave = indicators.elliottWave.length > 0 ? indicators.elliottWave[indicators.elliottWave.length - 1] : null;
-    const currentHarmonicPatterns = indicators.harmonicPatterns.length > 0 ? indicators.harmonicPatterns : [];
-    const currentVolume = this.volumes[this.volumes.length - 1];
-    const volumeRatio = currentVolume / analysis.avgVolume;
-    const currentDrawdown = (analysis.sessionHigh - analysis.currentPrice) / analysis.sessionHigh * 100;
-    const rangeWidth = (analysis.sessionHigh - analysis.sessionLow) / analysis.sessionLow * 100;
-    const priceVsVWAP = (analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100;
-    const totalScore = signals.bullishSignals - signals.bearishSignals;
-    const overallSignal = totalScore > 0 ? "BULLISH_BIAS" : totalScore < 0 ? "BEARISH_BIAS" : "NEUTRAL";
-    const targetEntry = Math.max(analysis.sessionLow * 1.005, analysis.trueVWAP * 0.998);
-    const stopLoss = analysis.sessionLow * 0.995;
-    const profitTarget = analysis.sessionHigh * 0.995;
-    const riskRewardRatio = (profitTarget - analysis.currentPrice) / (analysis.currentPrice - stopLoss);
-    const positionSize = this.calculatePositionSize(analysis.currentPrice, targetEntry, stopLoss);
-    const maxRisk = positionSize * (targetEntry - stopLoss);
-    return {
-      symbol,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      marketStructure: {
-        currentPrice: analysis.currentPrice,
-        startPrice: analysis.startPrice,
-        sessionHigh: analysis.sessionHigh,
-        sessionLow: analysis.sessionLow,
-        rangeWidth,
-        totalVolume: analysis.totalVolume,
-        sessionPerformance: analysis.sessionReturn,
-        positionInRange: analysis.pricePosition
-      },
-      volatility: {
-        impliedVolatility: analysis.impliedVolatility,
-        realizedVolatility: analysis.realizedVolatility,
-        atr: analysis.atr,
-        maxDrawdown: analysis.maxDrawdown * 100,
-        currentDrawdown
-      },
-      technicalIndicators: {
-        sma5: currentSMA5,
-        sma10: currentSMA10,
-        sma20: currentSMA20,
-        sma50: currentSMA50,
-        sma200: currentSMA200,
-        ema8: currentEMA8,
-        ema12: currentEMA12,
-        ema21: currentEMA21,
-        ema26: currentEMA26,
-        wma20: currentWMA20,
-        vwma20: currentVWMA20,
-        macd: currentMACD,
-        adx: currentADX,
-        dmi: currentDMI,
-        ichimoku: currentIchimoku,
-        parabolicSAR: currentParabolicSAR,
-        rsi: currentRSI,
-        stochastic: currentStochastic,
-        cci: currentCCI,
-        roc: currentROC,
-        williamsR: currentWilliamsR,
-        momentum: currentMomentum,
-        bollingerBands: currentBB ? {
-          upper: currentBB.upper,
-          middle: currentBB.middle,
-          lower: currentBB.lower,
-          bandwidth: currentBB.bandwidth,
-          percentB: currentBB.percentB
-        } : null,
-        atr: currentAtr,
-        keltnerChannels: currentKeltner ? {
-          upper: currentKeltner.upper,
-          middle: currentKeltner.middle,
-          lower: currentKeltner.lower
-        } : null,
-        donchianChannels: currentDonchian ? {
-          upper: currentDonchian.upper,
-          middle: currentDonchian.middle,
-          lower: currentDonchian.lower
-        } : null,
-        chaikinVolatility: currentChaikinVolatility,
-        obv: currentObv,
-        cmf: currentCmf,
-        adl: currentAdl,
-        volumeROC: currentVolumeROC,
-        mfi: currentMfi,
-        vwap: currentVwap
-      },
-      volumeAnalysis: {
-        currentVolume,
-        averageVolume: Math.round(analysis.avgVolume),
-        volumeRatio,
-        trueVWAP: analysis.trueVWAP,
-        priceVsVWAP,
-        obv: currentObv,
-        cmf: currentCmf,
-        mfi: currentMfi
-      },
-      momentum: {
-        momentum5: analysis.momentum5,
-        momentum10: analysis.momentum10,
-        sessionROC: analysis.sessionReturn,
-        rsi: currentRSI,
-        stochastic: currentStochastic,
-        cci: currentCCI
-      },
-      supportResistance: {
-        pivotPoints: currentPivotPoints,
-        fibonacci: currentFibonacci,
-        gannLevels: currentGannLevels,
-        elliottWave: currentElliottWave,
-        harmonicPatterns: currentHarmonicPatterns
-      },
-      tradingSignals: {
-        ...signals,
-        overallSignal,
-        signalScore: totalScore,
-        confidence: this.calculateConfidence(signals.signals),
-        riskLevel: this.calculateRiskLevel(analysis.volatility)
-      },
-      statisticalModels: {
-        zScore: this.calculateZScore(analysis.currentPrice, analysis.startPrice),
-        ornsteinUhlenbeck: this.calculateOrnsteinUhlenbeck(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        ),
-        kalmanFilter: this.calculateKalmanFilter(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        ),
-        arima: this.calculateArima(analysis.currentPrice),
-        garch: this.calculateGarch(analysis.avgVolume),
-        hilbertTransform: this.calculateHilbertTransform(analysis.currentPrice),
-        waveletTransform: this.calculateWaveletTransform(analysis.currentPrice)
-      },
-      optionsAnalysis: (() => {
-        const blackScholes = this.calculateBlackScholes(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        );
-        if (!blackScholes) return null;
-        return {
-          blackScholes,
-          impliedVolatility: analysis.impliedVolatility,
-          delta: blackScholes.delta,
-          gamma: blackScholes.gamma,
-          theta: blackScholes.theta,
-          vega: blackScholes.vega,
-          rho: blackScholes.rho,
-          greeks: {
-            delta: blackScholes.delta,
-            gamma: blackScholes.gamma,
-            theta: blackScholes.theta,
-            vega: blackScholes.vega,
-            rho: blackScholes.rho
-          }
-        };
-      })(),
-      riskManagement: {
-        targetEntry,
-        stopLoss,
-        profitTarget,
-        riskRewardRatio,
-        positionSize,
-        maxRisk
-      },
-      performance: {
-        sharpeRatio: analysis.sharpeRatio,
-        sortinoRatio: analysis.sortinoRatio,
-        calmarRatio: analysis.calmarRatio,
-        maxDrawdown: analysis.maxDrawdown * 100,
-        winRate: analysis.winRate,
-        profitFactor: analysis.profitFactor,
-        totalReturn: analysis.sessionReturn,
-        volatility: analysis.volatility
-      }
-    };
-  }
-};
-var createTechnicalAnalysisHandler = (marketDataPrices) => {
-  return async (args) => {
-    try {
-      const symbol = args.symbol;
-      const priceHistory = marketDataPrices.get(symbol) || [];
-      if (priceHistory.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No price data available for ${symbol}. Please request market data first.`,
-              uri: "technicalAnalysis"
-            }
-          ]
-        };
-      }
-      const hasValidData = priceHistory.every(
-        (entry) => typeof entry.trade === "number" && !Number.isNaN(entry.trade) && typeof entry.midPrice === "number" && !Number.isNaN(entry.midPrice)
-      );
-      if (!hasValidData) {
-        throw new Error("Invalid market data");
-      }
-      const analyzer = new TechnicalAnalyzer(priceHistory);
-      const analysis = analyzer.generateJSONAnalysis(symbol);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Technical Analysis for ${symbol}:
-
-${JSON.stringify(analysis, null, 2)}`,
-            uri: "technicalAnalysis"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error performing technical analysis: ${error instanceof Error ? error.message : "Unknown error"}`,
-            uri: "technicalAnalysis"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
 // src/tools/marketData.ts
 var import_fixparser = require("fixparser");
 var import_quickchart_js = __toESM(require("quickchart-js"), 1);
@@ -2001,72 +442,6 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
     }
   };
 };
-var aggregateMarketData = (priceHistory, maxPoints = 490) => {
-  if (priceHistory.length <= maxPoints) {
-    return priceHistory;
-  }
-  const result = [];
-  const step = priceHistory.length / maxPoints;
-  result.push(priceHistory[0]);
-  for (let i = 1; i < maxPoints - 1; i++) {
-    const startIndex = Math.floor(i * step);
-    const endIndex = Math.floor((i + 1) * step);
-    const segment = priceHistory.slice(startIndex, endIndex);
-    if (segment.length === 0) continue;
-    const aggregatedPoint = {
-      timestamp: segment[0].timestamp,
-      // Use timestamp of first point in segment
-      bid: segment.reduce((sum2, p) => sum2 + p.bid, 0) / segment.length,
-      offer: segment.reduce((sum2, p) => sum2 + p.offer, 0) / segment.length,
-      spread: segment.reduce((sum2, p) => sum2 + p.spread, 0) / segment.length,
-      volume: segment.reduce((sum2, p) => sum2 + p.volume, 0) / segment.length,
-      trade: segment.reduce((sum2, p) => sum2 + p.trade, 0) / segment.length,
-      indexValue: segment.reduce((sum2, p) => sum2 + p.indexValue, 0) / segment.length,
-      openingPrice: segment.reduce((sum2, p) => sum2 + p.openingPrice, 0) / segment.length,
-      closingPrice: segment.reduce((sum2, p) => sum2 + p.closingPrice, 0) / segment.length,
-      settlementPrice: segment.reduce((sum2, p) => sum2 + p.settlementPrice, 0) / segment.length,
-      tradingSessionHighPrice: segment.reduce((sum2, p) => sum2 + p.tradingSessionHighPrice, 0) / segment.length,
-      tradingSessionLowPrice: segment.reduce((sum2, p) => sum2 + p.tradingSessionLowPrice, 0) / segment.length,
-      vwap: segment.reduce((sum2, p) => sum2 + p.vwap, 0) / segment.length,
-      imbalance: segment.reduce((sum2, p) => sum2 + p.imbalance, 0) / segment.length,
-      openInterest: segment.reduce((sum2, p) => sum2 + p.openInterest, 0) / segment.length,
-      compositeUnderlyingPrice: segment.reduce((sum2, p) => sum2 + p.compositeUnderlyingPrice, 0) / segment.length,
-      simulatedSellPrice: segment.reduce((sum2, p) => sum2 + p.simulatedSellPrice, 0) / segment.length,
-      simulatedBuyPrice: segment.reduce((sum2, p) => sum2 + p.simulatedBuyPrice, 0) / segment.length,
-      marginRate: segment.reduce((sum2, p) => sum2 + p.marginRate, 0) / segment.length,
-      midPrice: segment.reduce((sum2, p) => sum2 + p.midPrice, 0) / segment.length,
-      emptyBook: segment.reduce((sum2, p) => sum2 + p.emptyBook, 0) / segment.length,
-      settleHighPrice: segment.reduce((sum2, p) => sum2 + p.settleHighPrice, 0) / segment.length,
-      settleLowPrice: segment.reduce((sum2, p) => sum2 + p.settleLowPrice, 0) / segment.length,
-      priorSettlePrice: segment.reduce((sum2, p) => sum2 + p.priorSettlePrice, 0) / segment.length,
-      sessionHighBid: segment.reduce((sum2, p) => sum2 + p.sessionHighBid, 0) / segment.length,
-      sessionLowOffer: segment.reduce((sum2, p) => sum2 + p.sessionLowOffer, 0) / segment.length,
-      earlyPrices: segment.reduce((sum2, p) => sum2 + p.earlyPrices, 0) / segment.length,
-      auctionClearingPrice: segment.reduce((sum2, p) => sum2 + p.auctionClearingPrice, 0) / segment.length,
-      swapValueFactor: segment.reduce((sum2, p) => sum2 + p.swapValueFactor, 0) / segment.length,
-      dailyValueAdjustmentForLongPositions: segment.reduce((sum2, p) => sum2 + p.dailyValueAdjustmentForLongPositions, 0) / segment.length,
-      cumulativeValueAdjustmentForLongPositions: segment.reduce((sum2, p) => sum2 + p.cumulativeValueAdjustmentForLongPositions, 0) / segment.length,
-      dailyValueAdjustmentForShortPositions: segment.reduce((sum2, p) => sum2 + p.dailyValueAdjustmentForShortPositions, 0) / segment.length,
-      cumulativeValueAdjustmentForShortPositions: segment.reduce((sum2, p) => sum2 + p.cumulativeValueAdjustmentForShortPositions, 0) / segment.length,
-      fixingPrice: segment.reduce((sum2, p) => sum2 + p.fixingPrice, 0) / segment.length,
-      cashRate: segment.reduce((sum2, p) => sum2 + p.cashRate, 0) / segment.length,
-      recoveryRate: segment.reduce((sum2, p) => sum2 + p.recoveryRate, 0) / segment.length,
-      recoveryRateForLong: segment.reduce((sum2, p) => sum2 + p.recoveryRateForLong, 0) / segment.length,
-      recoveryRateForShort: segment.reduce((sum2, p) => sum2 + p.recoveryRateForShort, 0) / segment.length,
-      marketBid: segment.reduce((sum2, p) => sum2 + p.marketBid, 0) / segment.length,
-      marketOffer: segment.reduce((sum2, p) => sum2 + p.marketOffer, 0) / segment.length,
-      shortSaleMinPrice: segment.reduce((sum2, p) => sum2 + p.shortSaleMinPrice, 0) / segment.length,
-      previousClosingPrice: segment.reduce((sum2, p) => sum2 + p.previousClosingPrice, 0) / segment.length,
-      thresholdLimitPriceBanding: segment.reduce((sum2, p) => sum2 + p.thresholdLimitPriceBanding, 0) / segment.length,
-      dailyFinancingValue: segment.reduce((sum2, p) => sum2 + p.dailyFinancingValue, 0) / segment.length,
-      accruedFinancingValue: segment.reduce((sum2, p) => sum2 + p.accruedFinancingValue, 0) / segment.length,
-      twap: segment.reduce((sum2, p) => sum2 + p.twap, 0) / segment.length
-    };
-    result.push(aggregatedPoint);
-  }
-  result.push(priceHistory[priceHistory.length - 1]);
-  return result;
-};
 var createGetStockGraphHandler = (marketDataPrices) => {
   return async (args) => {
     try {
@@ -2083,22 +458,18 @@ var createGetStockGraphHandler = (marketDataPrices) => {
           ]
         };
       }
-      const aggregatedData = aggregateMarketData(priceHistory, 500);
       const chart = new import_quickchart_js.default();
       chart.setWidth(1200);
       chart.setHeight(600);
       chart.setBackgroundColor("transparent");
-      const labels = aggregatedData.map((point) => new Date(point.timestamp).toLocaleTimeString());
-      const bidData = aggregatedData.map((point) => point.bid);
-      const offerData = aggregatedData.map((point) => point.offer);
-      const spreadData = aggregatedData.map((point) => point.spread);
-      const volumeData = aggregatedData.map((point) => point.volume);
-      const tradeData = aggregatedData.map((point) => point.trade);
-      const vwapData = aggregatedData.map((point) => point.vwap);
-      const twapData = aggregatedData.map((point) => point.twap);
-      const maxVolume = Math.max(...volumeData.filter((v) => v > 0));
-      const maxPrice = Math.max(...bidData, ...offerData, ...tradeData, ...vwapData, ...twapData);
-      const normalizedVolumeData = volumeData.map((v) => v / maxVolume * maxPrice * 0.3);
+      const labels = priceHistory.map((point) => new Date(point.timestamp).toLocaleTimeString());
+      const bidData = priceHistory.map((point) => point.bid);
+      const offerData = priceHistory.map((point) => point.offer);
+      const spreadData = priceHistory.map((point) => point.spread);
+      const volumeData = priceHistory.map((point) => point.volume);
+      const tradeData = priceHistory.map((point) => point.trade);
+      const vwapData = priceHistory.map((point) => point.vwap);
+      const twapData = priceHistory.map((point) => point.twap);
       const config = {
         type: "line",
         data: {
@@ -2153,8 +524,8 @@ var createGetStockGraphHandler = (marketDataPrices) => {
               tension: 0.4
             },
             {
-              label: "Volume (Normalized)",
-              data: normalizedVolumeData,
+              label: "Volume",
+              data: volumeData,
               borderColor: "#007bff",
               backgroundColor: "rgba(0, 123, 255, 0.1)",
               fill: true,
@@ -2167,16 +538,12 @@ var createGetStockGraphHandler = (marketDataPrices) => {
           plugins: {
             title: {
               display: true,
-              text: `${symbol} Market Data (Volume normalized to 30% of max price)`
+              text: `${symbol} Market Data`
             }
           },
           scales: {
             y: {
-              beginAtZero: false,
-              title: {
-                display: true,
-                text: "Price / Normalized Volume"
-              }
+              beginAtZero: false
             }
           }
         }
@@ -2226,7 +593,6 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
           ]
         };
       }
-      const aggregatedData = aggregateMarketData(priceHistory, 500);
       return {
         content: [
           {
@@ -2234,9 +600,8 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
             text: JSON.stringify(
               {
                 symbol,
-                count: aggregatedData.length,
-                originalCount: priceHistory.length,
-                data: aggregatedData.map((point) => ({
+                count: priceHistory.length,
+                data: priceHistory.map((point) => ({
                   timestamp: new Date(point.timestamp).toISOString(),
                   bid: point.bid,
                   offer: point.offer,
@@ -2378,7 +743,6 @@ var handlInstNames = {
 };
 var createVerifyOrderHandler = (parser, verifiedOrders) => {
   return async (args) => {
-    void parser;
     try {
       verifiedOrders.set(args.clOrdID, {
         clOrdID: args.clOrdID,
@@ -2602,22 +966,29 @@ var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPri
   executeOrder: createExecuteOrderHandler(parser, verifiedOrders, pendingRequests),
   marketDataRequest: createMarketDataRequestHandler(parser, pendingRequests),
   getStockGraph: createGetStockGraphHandler(marketDataPrices),
-  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices),
-  technicalAnalysis: createTechnicalAnalysisHandler(marketDataPrices)
+  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices)
 });
 
 // src/utils/messageHandler.ts
 var import_fixparser3 = require("fixparser");
-function getEnumValue(enumObj, name) {
-  return enumObj[name] || name;
-}
 function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
-  void parser;
+  parser.logger.log({
+    level: "info",
+    message: `MCP Server received message: ${message.messageType}: ${message.description}`
+  });
   const msgType = message.messageType;
   if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser3.Messages.MarketDataIncrementalRefresh) {
     const symbol = message.getField(import_fixparser3.Fields.Symbol)?.value;
+    parser.logger.log({
+      level: "info",
+      message: `Processing market data for symbol: ${symbol}`
+    });
     const fixJson = message.toFIXJSON();
     const entries = fixJson.Body?.NoMDEntries || [];
+    parser.logger.log({
+      level: "info",
+      message: `Found ${entries.length} market data entries`
+    });
     const data = {
       timestamp: Date.now(),
       bid: 0,
@@ -2670,8 +1041,13 @@ function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPr
       const entryType = entry.MDEntryType;
       const price = entry.MDEntryPx ? Number.parseFloat(entry.MDEntryPx) : 0;
       const size = entry.MDEntrySize ? Number.parseFloat(entry.MDEntrySize) : 0;
-      const enumValue = getEnumValue(import_fixparser3.MDEntryType, entryType);
-      switch (enumValue) {
+      if (entryType === import_fixparser3.MDEntryType.Bid || entryType === import_fixparser3.MDEntryType.Offer || entryType === import_fixparser3.MDEntryType.TradeVolume) {
+        parser.logger.log({
+          level: "info",
+          message: `Market Data Entry - Type: ${entryType}, Price: ${price}, Size: ${size}`
+        });
+      }
+      switch (entryType) {
         case import_fixparser3.MDEntryType.Bid:
           data.bid = price;
           break;
@@ -2808,12 +1184,24 @@ function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPr
     }
     data.spread = data.offer - data.bid;
     if (!marketDataPrices.has(symbol)) {
+      parser.logger.log({
+        level: "info",
+        message: `Creating new price history array for symbol: ${symbol}`
+      });
       marketDataPrices.set(symbol, []);
     }
     const prices = marketDataPrices.get(symbol);
     prices.push(data);
+    parser.logger.log({
+      level: "info",
+      message: `Updated price history for ${symbol}. Current size: ${prices.length}`
+    });
     if (prices.length > maxPriceHistory) {
       prices.splice(0, prices.length - maxPriceHistory);
+      parser.logger.log({
+        level: "info",
+        message: `Trimmed price history for ${symbol} to ${maxPriceHistory} entries`
+      });
     }
     onPriceUpdate?.(symbol, data);
     const mdReqID = message.getField(import_fixparser3.Fields.MDReqID)?.value;
@@ -2822,6 +1210,10 @@ function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPr
       if (callback) {
         callback(message);
         pendingRequests.delete(mdReqID);
+        parser.logger.log({
+          level: "info",
+          message: `Resolved market data request for ID: ${mdReqID}`
+        });
       }
     }
   } else if (msgType === import_fixparser3.Messages.ExecutionReport) {