fixparser-plugin-mcp 9.2.2-f927a4e7 → 9.2.3-175e9b8c

package/types/mcp/schemas/schemas.d.ts

@@ -0,0 +1,181 @@
+export declare const toolSchemas: {
+    parse: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                fixString: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    parseToJSON: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                fixString: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    verifyOrder: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                clOrdID: {
+                    type: string;
+                };
+                handlInst: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                quantity: {
+                    type: string;
+                };
+                price: {
+                    type: string;
+                };
+                ordType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                side: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                symbol: {
+                    type: string;
+                };
+                timeInForce: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    executeOrder: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                clOrdID: {
+                    type: string;
+                };
+                handlInst: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                quantity: {
+                    type: string;
+                };
+                price: {
+                    type: string;
+                };
+                ordType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                side: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                symbol: {
+                    type: string;
+                };
+                timeInForce: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    marketDataRequest: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                mdUpdateType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                symbols: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                mdReqID: {
+                    type: string;
+                };
+                subscriptionRequestType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                mdEntryTypes: {
+                    type: string;
+                    items: {
+                        type: string;
+                        enum: string[];
+                    };
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    getStockGraph: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                symbol: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    getStockPriceHistory: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                symbol: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    technicalAnalysis: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                symbol: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+};

package/types/mcp/tools/analytics.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { MarketDataEntry } from '../schemas';
+export declare const createTechnicalAnalysisHandler: (marketDataPrices: Map<string, MarketDataEntry[]>) => ((args: {
+    symbol: string;
+}) => Promise<CallToolResult>);

package/types/mcp/tools/index.d.ts

@@ -0,0 +1,3 @@
+import type { IFIXParser, Message } from 'fixparser';
+import type { MarketDataEntry, ToolHandlers, VerifiedOrder } from '../schemas';
+export declare const createToolHandlers: (parser: IFIXParser, verifiedOrders: Map<string, VerifiedOrder>, pendingRequests: Map<string, (data: Message) => void>, marketDataPrices: Map<string, MarketDataEntry[]>) => ToolHandlers;

package/types/mcp/tools/indicators/index.d.ts

@@ -0,0 +1,11 @@
+export * from '../../schemas/indicatortypes';
+export { MomentumIndicators } from './momentum';
+export { MovingAverages } from './movingAverages';
+export { OptionsAnalysis } from './options';
+export { PerformanceAnalysis } from './performance';
+export { TradingSignalsGenerator } from './signals';
+export { StatisticalModels } from './statistical';
+export { SupportResistanceIndicators } from './supportResistance';
+export { TrendIndicators } from './trend';
+export { VolatilityIndicators } from './volatility';
+export { VolumeIndicators } from './volume';

package/types/mcp/tools/indicators/momentum.d.ts

@@ -0,0 +1,27 @@
+import type { Stochastic } from '../../schemas/indicatortypes';
+export declare class MomentumIndicators {
+    /**
+     * Calculate RSI (Relative Strength Index)
+     */
+    static calculateRSI(data: number[], period?: number): number[];
+    /**
+     * Calculate Stochastic Oscillator
+     */
+    static calculateStochastic(prices: number[], highs: number[], lows: number[]): Stochastic[];
+    /**
+     * Calculate CCI (Commodity Channel Index)
+     */
+    static calculateCCI(prices: number[], highs: number[], lows: number[]): number[];
+    /**
+     * Calculate Rate of Change
+     */
+    static calculateROC(prices: number[]): number[];
+    /**
+     * Calculate Williams %R
+     */
+    static calculateWilliamsR(prices: number[]): number[];
+    /**
+     * Calculate Momentum
+     */
+    static calculateMomentum(prices: number[]): number[];
+}

package/types/mcp/tools/indicators/movingAverages.d.ts

@@ -0,0 +1,18 @@
+export declare class MovingAverages {
+    /**
+     * Calculate Simple Moving Average
+     */
+    static calculateSMA(data: number[], period: number): number[];
+    /**
+     * Calculate Exponential Moving Average
+     */
+    static calculateEMA(data: number[], period: number): number[];
+    /**
+     * Calculate Weighted Moving Average
+     */
+    static calculateWMA(data: number[], period: number): number[];
+    /**
+     * Calculate Volume Weighted Moving Average
+     */
+    static calculateVWMA(prices: number[], volumes: number[], period: number): number[];
+}

package/types/mcp/tools/indicators/options.d.ts

@@ -0,0 +1,102 @@
+import type { BlackScholes } from '../../schemas/indicatortypes';
+export declare class OptionsAnalysis {
+    /**
+     * Calculate Black-Scholes Option Pricing
+     */
+    static calculateBlackScholes(currentPrice: number, startPrice: number, avgVolume: number): BlackScholes | null;
+    /**
+     * Calculate Binomial Tree Option Pricing
+     */
+    static calculateBinomialTree(currentPrice: number, strikePrice: number, timeToExpiry?: number, riskFreeRate?: number, volatility?: number, steps?: number): {
+        callPrice: number;
+        putPrice: number;
+        delta: number;
+        gamma: number;
+        theta: number;
+        vega: number;
+        rho: number;
+    };
+    /**
+     * Calculate Trinomial Tree Option Pricing
+     */
+    static calculateTrinomialTree(currentPrice: number, strikePrice: number, timeToExpiry?: number, riskFreeRate?: number, volatility?: number, steps?: number): {
+        callPrice: number;
+        putPrice: number;
+        delta: number;
+        gamma: number;
+        theta: number;
+        vega: number;
+        rho: number;
+    };
+    /**
+     * Calculate Monte Carlo Option Pricing
+     */
+    static calculateMonteCarlo(currentPrice: number, strikePrice: number, timeToExpiry?: number, riskFreeRate?: number, volatility?: number, simulations?: number): {
+        callPrice: number;
+        putPrice: number;
+        delta: number;
+        gamma: number;
+        theta: number;
+        vega: number;
+        rho: number;
+        confidenceInterval: {
+            lower: number;
+            upper: number;
+        };
+    };
+    /**
+     * Calculate Heston Model (Stochastic Volatility)
+     */
+    static calculateHestonModel(currentPrice: number, strikePrice: number, timeToExpiry?: number, riskFreeRate?: number, _initialVolatility?: number, _longTermVolatility?: number, _meanReversionSpeed?: number, _volatilityOfVolatility?: number, _correlation?: number): {
+        callPrice: number;
+        putPrice: number;
+        impliedVolatility: number;
+        delta: number;
+        gamma: number;
+        theta: number;
+        vega: number;
+        rho: number;
+    };
+    /**
+     * Calculate SABR Model
+     */
+    static calculateSABRModel(currentPrice: number, strikePrice: number, timeToExpiry?: number, riskFreeRate?: number, alpha?: number, beta?: number, rho?: number, nu?: number): {
+        callPrice: number;
+        putPrice: number;
+        impliedVolatility: number;
+        delta: number;
+        gamma: number;
+        theta: number;
+        vega: number;
+        rho: number;
+    };
+    /**
+     * Calculate Variance Gamma Model
+     */
+    static calculateVarianceGamma(currentPrice: number, strikePrice: number, timeToExpiry?: number, riskFreeRate?: number, _sigma?: number, _theta?: number, _nu?: number): {
+        callPrice: number;
+        putPrice: number;
+        impliedVolatility: number;
+        delta: number;
+        gamma: number;
+        theta: number;
+        vega: number;
+        rho: number;
+    };
+    /**
+     * Normal CDF approximation
+     */
+    private static normalCDF;
+    /**
+     * Normal PDF
+     */
+    private static normalPDF;
+    /**
+     * Error function approximation
+     */
+    private static erf;
+    /**
+     * Box-Muller transform for normal random numbers
+     */
+    private static boxMuller;
+}

package/types/mcp/tools/indicators/performance.d.ts

@@ -0,0 +1,42 @@
+export declare class PerformanceAnalysis {
+    /**
+     * Calculate maximum drawdown
+     */
+    static calculateMaxDrawdown(prices: number[]): number;
+    /**
+     * Calculate maximum consecutive losses
+     */
+    static calculateMaxConsecutiveLosses(prices: number[]): number;
+    /**
+     * Calculate win rate
+     */
+    static calculateWinRate(prices: number[]): number;
+    /**
+     * Calculate profit factor
+     */
+    static calculateProfitFactor(prices: number[]): number;
+    /**
+     * Calculate Sharpe Ratio
+     */
+    static calculateSharpeRatio(returns: number[], riskFreeRate?: number): number;
+    /**
+     * Calculate Sortino Ratio
+     */
+    static calculateSortinoRatio(returns: number[], riskFreeRate?: number): number;
+    /**
+     * Calculate Calmar Ratio
+     */
+    static calculateCalmarRatio(returns: number[], maxDrawdown: number): number;
+    /**
+     * Calculate Position Size
+     */
+    static calculatePositionSize(targetEntry: number, stopLoss: number): number;
+    /**
+     * Calculate Confidence
+     */
+    static calculateConfidence(signals: string[]): number;
+    /**
+     * Calculate Risk Level
+     */
+    static calculateRiskLevel(volatility: number): string;
+}

package/types/mcp/tools/indicators/signals.d.ts

@@ -0,0 +1,23 @@
+import type { TradingSignals } from '../../schemas/indicatortypes';
+export declare class TradingSignalsGenerator {
+    /**
+     * Generate trading signals based on market analysis
+     */
+    static generateSignals(currentPrice: number, trueVWAP: number, momentum5: number, momentum10: number, sessionReturn: number, currentVolume: number, avgVolume: number, pricePosition: number, volatility: number): {
+        bullishSignals: number;
+        bearishSignals: number;
+        signals: string[];
+    };
+    /**
+     * Calculate overall signal and confidence
+     */
+    static calculateOverallSignal(bullishSignals: number, bearishSignals: number, signals: string[], volatility: number): TradingSignals;
+    /**
+     * Calculate confidence based on number of signals
+     */
+    private static calculateConfidence;
+    /**
+     * Calculate risk level based on volatility
+     */
+    private static calculateRiskLevel;
+}

package/types/mcp/tools/indicators/statistical.d.ts

@@ -0,0 +1,102 @@
+export declare class StatisticalModels {
+    /**
+     * Calculate Z-Score
+     */
+    static calculateZScore(currentPrice: number, startPrice: number): number;
+    /**
+     * Calculate Ornstein-Uhlenbeck
+     */
+    static calculateOrnsteinUhlenbeck(currentPrice: number, startPrice: number, avgVolume: number, priceChanges: number[]): {
+        mean: number;
+        speed: number;
+        volatility: number;
+        currentValue: number;
+    };
+    /**
+     * Calculate Kalman Filter
+     */
+    static calculateKalmanFilter(currentPrice: number, startPrice: number, avgVolume: number, priceChanges: number[]): {
+        state: number;
+        covariance: number;
+        gain: number;
+    };
+    /**
+     * Calculate ARIMA
+     */
+    static calculateARIMA(currentPrice: number, priceChanges: number[]): {
+        forecast: number[];
+        residuals: number[];
+        aic: number;
+    };
+    /**
+     * Calculate GARCH
+     */
+    static calculateGARCH(avgVolume: number, priceChanges: number[]): {
+        volatility: number;
+        persistence: number;
+        meanReversion: number;
+    };
+    /**
+     * Calculate VAR (Vector AutoRegression)
+     */
+    static calculateVAR(prices: number[], volumes: number[], lags?: number): {
+        priceForecast: number[];
+        volumeForecast: number[];
+        coefficients: number[][];
+        residuals: number[][];
+    };
+    /**
+     * Calculate Gaussian Process Regression
+     */
+    static calculateGaussianProcess(prices: number[], periods?: number): {
+        mean: number[];
+        variance: number[];
+        confidenceInterval: {
+            lower: number[];
+            upper: number[];
+        };
+    };
+    /**
+     * Calculate Pairs Trading Strategy
+     */
+    static calculatePairsTrading(asset1Prices: number[], asset2Prices: number[]): {
+        spread: number[];
+        zScore: number[];
+        hedgeRatio: number;
+        entrySignal: string;
+        exitSignal: string;
+        position: string;
+    };
+    /**
+     * Calculate Hilbert Transform
+     */
+    static calculateHilbertTransform(currentPrice: number, priceChanges: number[]): {
+        analytic: number[];
+        phase: number[];
+        amplitude: number[];
+    };
+    /**
+     * Calculate Wavelet Transform
+     */
+    static calculateWaveletTransform(currentPrice: number, priceChanges: number[]): {
+        coefficients: number[];
+        scales: number[];
+    };
+    /**
+     * Calculate Fourier Transform
+     */
+    static calculateFourierTransform(prices: number[]): {
+        frequencies: number[];
+        amplitudes: number[];
+        phases: number[];
+        dominantFrequencies: number[];
+    };
+    /**
+     * Calculate Empirical Mode Decomposition (EMD)
+     */
+    static calculateEMD(prices: number[]): {
+        imfs: number[][];
+        residual: number[];
+        frequencies: number[];
+    };
+}

package/types/mcp/tools/indicators/supportResistance.d.ts

@@ -0,0 +1,51 @@
+import type { ElliottWave, FibonacciLevels, HarmonicPattern, PivotPoints } from '../../schemas/indicatortypes';
+export declare class SupportResistanceIndicators {
+    /**
+     * Calculate Pivot Points (Classic)
+     */
+    static calculatePivotPoints(prices: number[], highs: number[], lows: number[]): PivotPoints[];
+    /**
+     * Calculate Fibonacci Pivot Points
+     */
+    static calculateFibonacciPivotPoints(prices: number[], highs: number[], lows: number[]): PivotPoints[];
+    /**
+     * Calculate Camarilla Pivot Points
+     */
+    static calculateCamarillaPivotPoints(prices: number[], highs: number[], lows: number[]): PivotPoints[];
+    /**
+     * Calculate Fibonacci Levels
+     */
+    static calculateFibonacciLevels(prices: number[]): FibonacciLevels[];
+    /**
+     * Calculate Gann Levels
+     */
+    static calculateGannLevels(prices: number[]): number[];
+    /**
+     * Calculate Elliott Wave
+     */
+    static calculateElliottWave(prices: number[]): ElliottWave[];
+    /**
+     * Helper method to detect price swings
+     */
+    private static detectPriceSwings;
+    /**
+     * Helper method to calculate wave position
+     */
+    private static calculateWavePosition;
+    /**
+     * Calculate Harmonic Patterns
+     */
+    static calculateHarmonicPatterns(prices: number[]): HarmonicPattern[];
+    /**
+     * Helper method to detect harmonic patterns
+     */
+    private static detectHarmonicPattern;
+    /**
+     * Helper method to check if a value is within a range
+     */
+    private static isInRange;
+    /**
+     * Helper method to calculate pattern completion percentage
+     */
+    private static calculatePatternCompletion;
+}

package/types/mcp/tools/indicators/trend.d.ts

@@ -0,0 +1,23 @@
+import type { DMI, IchimokuCloud, MACD } from '../../schemas/indicatortypes';
+export declare class TrendIndicators {
+    /**
+     * Calculate MACD (Moving Average Convergence Divergence)
+     */
+    static calculateMACD(prices: number[]): MACD[];
+    /**
+     * Calculate ADX (Average Directional Index)
+     */
+    static calculateADX(prices: number[], highs: number[], lows: number[]): number[];
+    /**
+     * Calculate DMI (Directional Movement Index)
+     */
+    static calculateDMI(prices: number[], highs: number[], lows: number[]): DMI[];
+    /**
+     * Calculate Ichimoku Cloud
+     */
+    static calculateIchimoku(prices: number[], highs: number[], lows: number[]): IchimokuCloud[];
+    /**
+     * Calculate Parabolic SAR
+     */
+    static calculateParabolicSAR(prices: number[], highs: number[], lows: number[]): number[];
+}

package/types/mcp/tools/indicators/volatility.d.ts

@@ -0,0 +1,23 @@
+import type { BollingerBands, DonchianChannels, KeltnerChannels } from '../../schemas/indicatortypes';
+export declare class VolatilityIndicators {
+    /**
+     * Calculate Bollinger Bands
+     */
+    static calculateBollingerBands(data: number[], period?: number, stdDev?: number): BollingerBands[];
+    /**
+     * Calculate Average True Range (ATR)
+     */
+    static calculateATR(prices: number[], highs: number[], lows: number[]): number[];
+    /**
+     * Calculate Keltner Channels
+     */
+    static calculateKeltnerChannels(prices: number[], highs: number[], lows: number[]): KeltnerChannels[];
+    /**
+     * Calculate Donchian Channels
+     */
+    static calculateDonchianChannels(prices: number[]): DonchianChannels[];
+    /**
+     * Calculate Chaikin Volatility
+     */
+    static calculateChaikinVolatility(prices: number[], highs: number[], lows: number[]): number[];
+}

package/types/mcp/tools/indicators/volume.d.ts

@@ -0,0 +1,26 @@
+export declare class VolumeIndicators {
+    /**
+     * Calculate On Balance Volume (OBV)
+     */
+    static calculateOBV(prices: number[], volumes: number[]): number[];
+    /**
+     * Calculate Chaikin Money Flow (CMF)
+     */
+    static calculateCMF(prices: number[], highs: number[], lows: number[], volumes: number[]): number[];
+    /**
+     * Calculate Accumulation/Distribution Line (ADL)
+     */
+    static calculateADL(prices: number[], highs: number[], lows: number[], volumes: number[]): number[];
+    /**
+     * Calculate Volume Rate of Change
+     */
+    static calculateVolumeROC(volumes: number[]): number[];
+    /**
+     * Calculate Money Flow Index (MFI)
+     */
+    static calculateMFI(prices: number[], highs: number[], lows: number[], volumes: number[]): number[];
+    /**
+     * Calculate Volume Weighted Average Price (VWAP)
+     */
+    static calculateVWAP(prices: number[], volumes: number[]): number[];
+}

package/types/mcp/tools/marketData.d.ts

@@ -0,0 +1,16 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type IFIXParser, type Message } from 'fixparser';
+import type { MarketDataEntry } from '../schemas';
+export declare const createMarketDataRequestHandler: (parser: IFIXParser, pendingRequests: Map<string, (data: Message) => void>) => ((args: {
+    mdUpdateType: string;
+    symbols: string[];
+    mdReqID: string;
+    subscriptionRequestType: string;
+    mdEntryTypes?: string[];
+}) => Promise<CallToolResult>);
+export declare const createGetStockGraphHandler: (marketDataPrices: Map<string, MarketDataEntry[]>) => ((args: {
+    symbol: string;
+}) => Promise<CallToolResult>);
+export declare const createGetStockPriceHistoryHandler: (marketDataPrices: Map<string, MarketDataEntry[]>) => ((args: {
+    symbol: string;
+}) => Promise<CallToolResult>);

package/types/mcp/tools/order.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type IFIXParser, type Message } from 'fixparser';
+import type { VerifiedOrder } from '../schemas';
+export declare const createVerifyOrderHandler: (parser: IFIXParser, verifiedOrders: Map<string, VerifiedOrder>) => ((args: VerifiedOrder) => Promise<CallToolResult>);
+export declare const createExecuteOrderHandler: (parser: IFIXParser, verifiedOrders: Map<string, VerifiedOrder>, pendingRequests: Map<string, (data: Message) => void>) => ((args: VerifiedOrder) => Promise<CallToolResult>);

package/types/mcp/tools/parse.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IFIXParser } from 'fixparser';
+export declare const createParseHandler: (parser: IFIXParser) => ((args: {
+    fixString: string;
+}) => Promise<CallToolResult>);

package/types/mcp/tools/parseToJSON.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IFIXParser } from 'fixparser';
+export declare const createParseToJSONHandler: (parser: IFIXParser) => ((args: {
+    fixString: string;
+}) => Promise<CallToolResult>);