fixparser-plugin-mcp 9.1.7-c415bb75 → 9.1.7-c6228661

package/build/esm/MCPLocal.mjs

@@ -273,8 +273,331 @@ 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);
+      bands.push({
+        upper: mean + standardDeviation * stdDev,
+        middle: mean,
+        lower: mean - standardDeviation * stdDev
+      });
+    }
+    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 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);
+    return {
+      currentPrice,
+      startPrice,
+      sessionHigh,
+      sessionLow,
+      totalVolume,
+      avgVolume,
+      volatility,
+      sessionReturn,
+      pricePosition,
+      trueVWAP,
+      momentum5,
+      momentum10,
+      maxDrawdown
+    };
+  }
+  // Generate technical indicators
+  getTechnicalIndicators() {
+    return {
+      sma5: this.calculateSMA(this.prices, 5),
+      sma10: this.calculateSMA(this.prices, 10),
+      ema8: this.calculateEMA(this.prices, 8),
+      ema21: this.calculateEMA(this.prices, 21),
+      rsi: this.calculateRSI(this.prices, 14),
+      bollinger: this.calculateBollingerBands(this.prices, 20, 2)
+    };
+  }
+  // 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 currentEMA8 = indicators.ema8[indicators.ema8.length - 1];
+    const currentEMA21 = indicators.ema21[indicators.ema21.length - 1];
+    const currentRSI = indicators.rsi.length > 0 ? indicators.rsi[indicators.rsi.length - 1] : null;
+    const currentBB = indicators.bollinger.length > 0 ? indicators.bollinger[indicators.bollinger.length - 1] : null;
+    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);
+    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.volatility,
+        maxDrawdown: analysis.maxDrawdown * 100,
+        currentDrawdown
+      },
+      technicalIndicators: {
+        sma5: currentSMA5,
+        sma10: currentSMA10,
+        ema8: currentEMA8,
+        ema21: currentEMA21,
+        rsi: currentRSI,
+        bollingerBands: currentBB ? {
+          upper: currentBB.upper,
+          middle: currentBB.middle,
+          lower: currentBB.lower,
+          position: (analysis.currentPrice - currentBB.lower) / (currentBB.upper - currentBB.lower) * 100
+        } : null
+      },
+      volumeAnalysis: {
+        currentVolume,
+        averageVolume: Math.round(analysis.avgVolume),
+        volumeRatio,
+        trueVWAP: analysis.trueVWAP,
+        priceVsVWAP
+      },
+      momentum: {
+        momentum5: analysis.momentum5,
+        momentum10: analysis.momentum10,
+        sessionROC: analysis.sessionReturn
+      },
+      tradingSignals: {
+        ...signals,
+        overallSignal,
+        signalScore: totalScore
+      },
+      riskManagement: {
+        targetEntry,
+        stopLoss,
+        profitTarget,
+        riskRewardRatio
+      }
+    };
   }
 };
+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 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
 import { Field, Fields, MDEntryType, Messages } from "fixparser";
@@ -282,8 +605,16 @@ import QuickChart from "quickchart-js";
 var createMarketDataRequestHandler = (parser, pendingRequests) => {
   return async (args) => {
     try {
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request for symbols: ${args.symbols.join(", ")}`
+      });
       const response = new Promise((resolve) => {
         pendingRequests.set(args.mdReqID, resolve);
+        parser.logger.log({
+          level: "info",
+          message: `Registered callback for market data request ID: ${args.mdReqID}`
+        });
       });
       const entryTypes = args.mdEntryTypes || [
         MDEntryType.Bid,
@@ -352,6 +683,10 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
       });
       const mdr = parser.createMessage(...messageFields);
       if (!parser.connected) {
+        parser.logger.log({
+          level: "error",
+          message: "Not connected. Cannot send market data request."
+        });
         return {
           content: [
             {
@@ -363,8 +698,16 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
           isError: true
         };
       }
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request message: ${JSON.stringify(mdr?.toFIXJSON())}`
+      });
       parser.send(mdr);
       const fixData = await response;
+      parser.logger.log({
+        level: "info",
+        message: `Received market data response for request ID: ${args.mdReqID}`
+      });
       return {
         content: [
           {
@@ -413,6 +756,9 @@ var createGetStockGraphHandler = (marketDataPrices) => {
       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: {
@@ -442,6 +788,30 @@ var createGetStockGraphHandler = (marketDataPrices) => {
               fill: false,
               tension: 0.4
             },
+            {
+              label: "Trade",
+              data: tradeData,
+              borderColor: "#ffc107",
+              backgroundColor: "rgba(255, 193, 7, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "VWAP",
+              data: vwapData,
+              borderColor: "#17a2b8",
+              backgroundColor: "rgba(23, 162, 184, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "TWAP",
+              data: twapData,
+              borderColor: "#6610f2",
+              backgroundColor: "rgba(102, 16, 242, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
             {
               label: "Volume",
               data: volumeData,
@@ -487,7 +857,7 @@ var createGetStockGraphHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to generate chart"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate graph"}`,
             uri: "getStockGraph"
           }
         ],
@@ -525,7 +895,48 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
                   bid: point.bid,
                   offer: point.offer,
                   spread: point.spread,
-                  volume: point.volume
+                  volume: point.volume,
+                  trade: point.trade,
+                  indexValue: point.indexValue,
+                  openingPrice: point.openingPrice,
+                  closingPrice: point.closingPrice,
+                  settlementPrice: point.settlementPrice,
+                  tradingSessionHighPrice: point.tradingSessionHighPrice,
+                  tradingSessionLowPrice: point.tradingSessionLowPrice,
+                  vwap: point.vwap,
+                  imbalance: point.imbalance,
+                  openInterest: point.openInterest,
+                  compositeUnderlyingPrice: point.compositeUnderlyingPrice,
+                  simulatedSellPrice: point.simulatedSellPrice,
+                  simulatedBuyPrice: point.simulatedBuyPrice,
+                  marginRate: point.marginRate,
+                  midPrice: point.midPrice,
+                  emptyBook: point.emptyBook,
+                  settleHighPrice: point.settleHighPrice,
+                  settleLowPrice: point.settleLowPrice,
+                  priorSettlePrice: point.priorSettlePrice,
+                  sessionHighBid: point.sessionHighBid,
+                  sessionLowOffer: point.sessionLowOffer,
+                  earlyPrices: point.earlyPrices,
+                  auctionClearingPrice: point.auctionClearingPrice,
+                  swapValueFactor: point.swapValueFactor,
+                  dailyValueAdjustmentForLongPositions: point.dailyValueAdjustmentForLongPositions,
+                  cumulativeValueAdjustmentForLongPositions: point.cumulativeValueAdjustmentForLongPositions,
+                  dailyValueAdjustmentForShortPositions: point.dailyValueAdjustmentForShortPositions,
+                  cumulativeValueAdjustmentForShortPositions: point.cumulativeValueAdjustmentForShortPositions,
+                  fixingPrice: point.fixingPrice,
+                  cashRate: point.cashRate,
+                  recoveryRate: point.recoveryRate,
+                  recoveryRateForLong: point.recoveryRateForLong,
+                  recoveryRateForShort: point.recoveryRateForShort,
+                  marketBid: point.marketBid,
+                  marketOffer: point.marketOffer,
+                  shortSaleMinPrice: point.shortSaleMinPrice,
+                  previousClosingPrice: point.previousClosingPrice,
+                  thresholdLimitPriceBanding: point.thresholdLimitPriceBanding,
+                  dailyFinancingValue: point.dailyFinancingValue,
+                  accruedFinancingValue: point.accruedFinancingValue,
+                  twap: point.twap
                 }))
               },
               null,
@@ -540,7 +951,7 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to get price history"}`,
             uri: "getStockPriceHistory"
           }
         ],
@@ -648,7 +1059,7 @@ Parameters verified:
 - Symbol: ${args.symbol}
 - TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
 
-To execute this order, call the executeOrder tool with these exact same parameters.`,
+To execute this order, call the executeOrder tool with these exact same parameters. Important: The user has to explicitly confirm before executeOrder is called!`,
             uri: "verifyOrder"
           }
         ]
@@ -844,16 +1255,16 @@ var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPri
   executeOrder: createExecuteOrderHandler(parser, verifiedOrders, pendingRequests),
   marketDataRequest: createMarketDataRequestHandler(parser, pendingRequests),
   getStockGraph: createGetStockGraphHandler(marketDataPrices),
-  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices)
+  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices),
+  technicalAnalysis: createTechnicalAnalysisHandler(marketDataPrices)
 });
 
 // src/utils/messageHandler.ts
 import { Fields as Fields3, MDEntryType as MDEntryType2, Messages as Messages3 } from "fixparser";
+function getEnumValue(enumObj, name) {
+  return enumObj[name] || name;
+}
 function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
-  parser.logger.log({
-    level: "info",
-    message: `MCP Server received message: ${message.messageType}: ${message.description}`
-  });
   const msgType = message.messageType;
   if (msgType === Messages3.MarketDataSnapshotFullRefresh || msgType === Messages3.MarketDataIncrementalRefresh) {
     const symbol = message.getField(Fields3.Symbol)?.value;
@@ -911,7 +1322,8 @@ 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;
-      switch (entryType) {
+      const enumValue = getEnumValue(MDEntryType2, entryType);
+      switch (enumValue) {
         case MDEntryType2.Bid:
           data.bid = price;
           break;