tradeblocks-mcp 3.0.2 → 3.0.3

package/src/utils/ticker.ts

@@ -37,7 +37,7 @@ export function normalizeTicker(value: string | null | undefined): string | null
  * Resolve ticker from arbitrary object fields (case/alias tolerant).
  */
 export function resolveTickerFromFields(
-  fields: Record<string, unknown> | null | undefined
+  fields: Record<string, unknown> | null | undefined,
 ): string | null {
   if (!fields) return null;
   for (const field of TICKER_FIELD_CANDIDATES) {
@@ -55,11 +55,10 @@ export function resolveTickerFromFields(
  */
 export function resolveTradeTicker(
   trade: Pick<Trade, "customFields">,
-  fallback: string = DEFAULT_MARKET_TICKER
+  fallback: string = DEFAULT_MARKET_TICKER,
 ): string {
   return (
-    resolveTickerFromFields(trade.customFields as Record<string, unknown> | undefined) ??
-    fallback
+    resolveTickerFromFields(trade.customFields as Record<string, unknown> | undefined) ?? fallback
   );
 }
 
@@ -68,12 +67,9 @@ export function resolveTradeTicker(
  */
 export function resolveTickerFromCsvRow(
   row: Record<string, string>,
-  fallback: string = DEFAULT_MARKET_TICKER
+  fallback: string = DEFAULT_MARKET_TICKER,
 ): string {
-  return (
-    resolveTickerFromFields(row as Record<string, unknown>) ??
-    fallback
-  );
+  return resolveTickerFromFields(row as Record<string, unknown>) ?? fallback;
 }
 
 /**

package/src/utils/trade-replay.ts

@@ -7,8 +7,8 @@
  * All functions are pure — no fetch, no DuckDB.
  */
 
-import type { BarRow } from './market-provider.ts';
-import { computeLegGreeks, type GreeksResult } from './black-scholes.ts';
+import type { BarRow } from "./market-provider.ts";
+import { computeLegGreeks, type GreeksResult } from "./black-scholes.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -16,25 +16,25 @@ import { computeLegGreeks, type GreeksResult } from './black-scholes.ts';
 
 /** A parsed leg from a tradelog "legs" string (before OCC ticker resolution). */
 export interface ParsedLeg {
-  root: string;            // "SPY", "SPX", "SPXW"
-  strike: number;          // Numeric strike price
-  type: 'C' | 'P';        // Call or Put
-  quantity: number;        // +1 or -1 (direction derived from position in spread)
+  root: string; // "SPY", "SPX", "SPXW"
+  strike: number; // Numeric strike price
+  type: "C" | "P"; // Call or Put
+  quantity: number; // +1 or -1 (direction derived from position in spread)
 }
 
 /** A fully resolved leg ready for replay (after OCC ticker construction). */
 export interface ReplayLeg {
-  occTicker: string;       // Full OCC ticker for Massive API fetch
-  quantity: number;        // Positive = long, negative = short
-  entryPrice: number;      // Per-contract entry price
-  multiplier: number;      // 100 for standard equity/index options
+  occTicker: string; // Full OCC ticker for Massive API fetch
+  quantity: number; // Positive = long, negative = short
+  entryPrice: number; // Per-contract entry price
+  multiplier: number; // 100 for standard equity/index options
 }
 
 /** A single point on the strategy P&L path. */
 export interface PnlPoint {
-  timestamp: string;       // "YYYY-MM-DD HH:MM" ET
-  strategyPnl: number;     // Combined P&L across all legs at this minute
-  legPrices: number[];     // Mark price for each leg at this minute (bid/ask mid or HL2 fallback)
+  timestamp: string; // "YYYY-MM-DD HH:MM" ET
+  strategyPnl: number; // Combined P&L across all legs at this minute
+  legPrices: number[]; // Mark price for each leg at this minute (bid/ask mid or HL2 fallback)
   underlyingPrice?: number; // Underlying price used for greeks / decomposition at this timestamp
   // Per-leg greeks (Phase 69) — array parallel to legPrices
   legGreeks?: GreeksResult[];
@@ -55,11 +55,11 @@ export interface PnlPoint {
 
 /** Configuration for greeks computation in P&L path. */
 export interface GreeksConfig {
-  underlyingPrices: Map<string, number>;  // timestamp -> underlying price
-  legs: Array<{ strike: number; type: 'C' | 'P'; expiryDate: string }>;  // per-leg BS inputs
-  riskFreeRate: number;       // e.g. 0.045
-  dividendYield: number;      // e.g. 0.015 for SPX, 0 otherwise
-  ivpByDate?: Map<string, number>;  // date -> IVP value
+  underlyingPrices: Map<string, number>; // timestamp -> underlying price
+  legs: Array<{ strike: number; type: "C" | "P"; expiryDate: string }>; // per-leg BS inputs
+  riskFreeRate: number; // e.g. 0.045
+  dividendYield: number; // e.g. 0.015 for SPX, 0 otherwise
+  ivpByDate?: Map<string, number>; // date -> IVP value
   /** Sorted intraday timestamps from underlyingPrices for nearest-timestamp binary search. */
   sortedTimestamps?: string[];
 }
@@ -67,14 +67,14 @@ export interface GreeksConfig {
 /** Complete replay result with P&L path, MFE/MAE, and metadata. */
 export interface ReplayResult {
   pnlPath: PnlPoint[];
-  mfe: number;             // Max of strategyPnl series
-  mae: number;             // Min of strategyPnl series
-  mfeTimestamp: string;    // When MFE occurred
-  maeTimestamp: string;    // When MAE occurred
-  totalPnl: number;        // Final P&L at last bar
-  totalBars?: number;      // Total minute bars before format filtering
-  legs: ReplayLeg[];       // The legs that were replayed
-  greeksWarning?: string | null;  // D-12: warning when >50% of leg-timestamps have null greeks
+  mfe: number; // Max of strategyPnl series
+  mae: number; // Min of strategyPnl series
+  mfeTimestamp: string; // When MFE occurred
+  maeTimestamp: string; // When MAE occurred
+  totalPnl: number; // Final P&L at last bar
+  totalBars?: number; // Total minute bars before format filtering
+  legs: ReplayLeg[]; // The legs that were replayed
+  greeksWarning?: string | null; // D-12: warning when >50% of leg-timestamps have null greeks
 }
 
 // ---------------------------------------------------------------------------
@@ -91,7 +91,7 @@ export interface ReplayResult {
  * Guards against broken exchange quotes (crossed bid>ask; blown ask>10×bid
  * with mid>$1) by falling back to HL2.
  */
-export function markPrice(bar: Pick<BarRow, 'high' | 'low' | 'bid' | 'ask'>): number {
+export function markPrice(bar: Pick<BarRow, "high" | "low" | "bid" | "ask">): number {
   const { bid, ask } = bar;
   const hl2 = (bar.high + bar.low) / 2;
   if (bid != null && ask != null && (bid > 0 || ask > 0)) {
@@ -127,17 +127,24 @@ export function findNearestTimestamp(
   const targetMin = timestampToMinutes(target);
   if (targetMin === null) return undefined;
 
-  let lo = 0, hi = sortedTimestamps.length - 1;
+  let lo = 0,
+    hi = sortedTimestamps.length - 1;
   let bestIdx = 0;
   let bestDiff = Infinity;
 
   while (lo <= hi) {
     const mid = (lo + hi) >>> 1;
     const midMin = timestampToMinutes(sortedTimestamps[mid]);
-    if (midMin === null) { lo = mid + 1; continue; }
+    if (midMin === null) {
+      lo = mid + 1;
+      continue;
+    }
 
     const diff = Math.abs(midMin - targetMin);
-    if (diff < bestDiff) { bestDiff = diff; bestIdx = mid; }
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestIdx = mid;
+    }
     if (midMin < targetMin) lo = mid + 1;
     else if (midMin > targetMin) hi = mid - 1;
     else break; // exact match
@@ -148,9 +155,9 @@ export function findNearestTimestamp(
 }
 
 function timestampToMinutes(ts: string): number | null {
-  const timePart = ts.split(' ')[1];
+  const timePart = ts.split(" ")[1];
   if (!timePart) return null;
-  const [h, m] = timePart.split(':').map(Number);
+  const [h, m] = timePart.split(":").map(Number);
   if (isNaN(h) || isNaN(m)) return null;
   return h * 60 + m;
 }
@@ -171,13 +178,14 @@ const VERBOSE_LEG_RE = /^([A-Z]+)\s+\w+\s+(\d+(?:\.\d+)?)\s+(Call|Put)$/i;
 // Option Omega format: "{contracts} {Mon} {day} {strike} {P|C} {STO|BTO} {price}"
 // Example: "397 Mar 12 6610 P STO 35.85"
 // Captures: (1)contracts (2)month (3)day (4)strike (5)C|P (6)STO|BTO (7)price
-const OO_LEG_RE = /^(\d+)\s+(\w+)\s+(\d+)\s+(\d+(?:\.\d+)?)\s+(C|P)\s+(STO|BTO|STC|BTC)\s+(\d+(?:\.\d+)?)$/i;
+const OO_LEG_RE =
+  /^(\d+)\s+(\w+)\s+(\d+)\s+(\d+(?:\.\d+)?)\s+(C|P)\s+(STO|BTO|STC|BTC)\s+(\d+(?:\.\d+)?)$/i;
 
 /** Extended parsed leg with entry price from OO format. */
 export interface ParsedLegOO extends ParsedLeg {
-  entryPrice?: number;   // Fill price from OO leg (e.g., 35.85)
-  contracts?: number;    // Contract count from OO leg
-  expiryHint?: string;   // "Mon DD" from OO format (e.g., "Mar 12") for multi-expiry strategies
+  entryPrice?: number; // Fill price from OO leg (e.g., 35.85)
+  contracts?: number; // Contract count from OO leg
+  expiryHint?: string; // "Mon DD" from OO format (e.g., "Mar 12") for multi-expiry strategies
 }
 
 /**
@@ -196,46 +204,46 @@ export interface ParsedLegOO extends ParsedLeg {
  * @throws Error if legs string is empty or cannot be parsed
  */
 export function parseLegsString(legsStr: string): ParsedLegOO[] {
-  if (!legsStr || legsStr.trim() === '') {
+  if (!legsStr || legsStr.trim() === "") {
     throw new Error('Cannot parse legs "" — use hypothetical mode with explicit strikes');
   }
 
   // Detect Option Omega pipe-delimited format
-  if (legsStr.includes('|')) {
+  if (legsStr.includes("|")) {
     return parseOOLegs(legsStr);
   }
 
-  const parts = legsStr.includes('/') ? legsStr.split('/') : [legsStr];
+  const parts = legsStr.includes("/") ? legsStr.split("/") : [legsStr];
   const legs: ParsedLegOO[] = [];
-  let inheritedRoot = '';
+  let inheritedRoot = "";
 
   for (let i = 0; i < parts.length; i++) {
     const raw = parts[i].trim();
     let root: string;
     let strike: number;
-    let type: 'C' | 'P';
+    let type: "C" | "P";
 
     const compactMatch = raw.match(COMPACT_LEG_RE);
     if (compactMatch) {
       root = compactMatch[1].toUpperCase();
       strike = parseFloat(compactMatch[2]);
-      type = compactMatch[3].toUpperCase() as 'C' | 'P';
+      type = compactMatch[3].toUpperCase() as "C" | "P";
     } else {
       // Try compact without root (e.g., "465C" in "SPY 470C/465C")
       const noRootMatch = raw.match(COMPACT_NO_ROOT_RE);
       if (noRootMatch && inheritedRoot) {
         root = inheritedRoot;
         strike = parseFloat(noRootMatch[1]);
-        type = noRootMatch[2].toUpperCase() as 'C' | 'P';
+        type = noRootMatch[2].toUpperCase() as "C" | "P";
       } else {
         const verboseMatch = raw.match(VERBOSE_LEG_RE);
         if (verboseMatch) {
           root = verboseMatch[1].toUpperCase();
           strike = parseFloat(verboseMatch[2]);
-          type = verboseMatch[3].toLowerCase() === 'call' ? 'C' : 'P';
+          type = verboseMatch[3].toLowerCase() === "call" ? "C" : "P";
         } else {
           throw new Error(
-            `Cannot parse legs "${legsStr}" — use hypothetical mode with explicit strikes`
+            `Cannot parse legs "${legsStr}" — use hypothetical mode with explicit strikes`,
           );
         }
       }
@@ -245,7 +253,7 @@ export function parseLegsString(legsStr: string): ParsedLegOO[] {
     if (i === 0) inheritedRoot = root;
 
     // First leg is bought (+1), subsequent alternate -1, +1, -1...
-    const quantity = i === 0 ? 1 : (i % 2 === 0 ? 1 : -1);
+    const quantity = i === 0 ? 1 : i % 2 === 0 ? 1 : -1;
 
     legs.push({ root, strike, type, quantity });
   }
@@ -264,7 +272,7 @@ export function parseLegsString(legsStr: string): ParsedLegOO[] {
  * - Open+close fills: same strike, same date, opposite direction (close dropped)
  */
 function parseOOLegs(legsStr: string): ParsedLegOO[] {
-  const segments = legsStr.split('|').map(s => s.trim());
+  const segments = legsStr.split("|").map((s) => s.trim());
   const legs: ParsedLegOO[] = [];
   const seen = new Set<string>();
 
@@ -272,7 +280,7 @@ function parseOOLegs(legsStr: string): ParsedLegOO[] {
     const match = seg.match(OO_LEG_RE);
     if (!match) {
       throw new Error(
-        `Cannot parse OO leg segment "${seg}" — use hypothetical mode with explicit strikes`
+        `Cannot parse OO leg segment "${seg}" — use hypothetical mode with explicit strikes`,
       );
     }
 
@@ -280,7 +288,7 @@ function parseOOLegs(legsStr: string): ParsedLegOO[] {
     const month = match[2];
     const day = match[3];
     const strike = parseFloat(match[4]);
-    const type = match[5].toUpperCase() as 'C' | 'P';
+    const type = match[5].toUpperCase() as "C" | "P";
     const direction = match[6].toUpperCase();
     const price = parseFloat(match[7]);
 
@@ -291,10 +299,10 @@ function parseOOLegs(legsStr: string): ParsedLegOO[] {
     seen.add(key);
 
     legs.push({
-      root: '',  // OO format doesn't include root — caller provides via trade's ticker field
+      root: "", // OO format doesn't include root — caller provides via trade's ticker field
       strike,
       type,
-      quantity: direction === 'BTO' ? 1 : -1,
+      quantity: direction === "BTO" ? 1 : -1,
       entryPrice: price,
       contracts,
       expiryHint: `${month} ${day}`,
@@ -318,16 +326,16 @@ function parseOOLegs(legsStr: string): ParsedLegOO[] {
 export function buildOccTicker(
   root: string,
   expiry: string,
-  type: 'C' | 'P',
+  type: "C" | "P",
   strike: number,
 ): string {
   // Extract YYMMDD from "YYYY-MM-DD"
-  const [yyyy, mm, dd] = expiry.split('-');
+  const [yyyy, mm, dd] = expiry.split("-");
   const yy = yyyy.slice(2);
 
   // Strike * 1000 padded to 8 digits
   const strikeInt = Math.round(strike * 1000);
-  const strikePadded = String(strikeInt).padStart(8, '0');
+  const strikePadded = String(strikeInt).padStart(8, "0");
 
   return `${root}${yy}${mm}${dd}${type}${strikePadded}`;
 }
@@ -361,7 +369,7 @@ export function computeStrategyPnlPath(
   const legMaps: Map<string, BarRow>[] = barsByLeg.map((bars) => {
     const map = new Map<string, BarRow>();
     for (const bar of bars) {
-      const ts = `${bar.date} ${bar.time ?? ''}`.trim();
+      const ts = `${bar.date} ${bar.time ?? ""}`.trim();
       map.set(ts, bar);
     }
     return map;
@@ -371,7 +379,7 @@ export function computeStrategyPnlPath(
   const allTimestamps = new Set<string>();
   for (const bars of barsByLeg) {
     for (const bar of bars) {
-      allTimestamps.add(`${bar.date} ${bar.time ?? ''}`.trim());
+      allTimestamps.add(`${bar.date} ${bar.time ?? ""}`.trim());
     }
   }
   const sortedTimestamps = [...allTimestamps].sort();
@@ -380,7 +388,6 @@ export function computeStrategyPnlPath(
   const path: PnlPoint[] = [];
   const lastBar: (BarRow | undefined)[] = new Array(legs.length).fill(undefined);
 
-
   for (const ts of sortedTimestamps) {
     let complete = true;
     const legPrices: number[] = [];
@@ -413,14 +420,17 @@ export function computeStrategyPnlPath(
           if (nearest) underlyingPrice = greeksConfig.underlyingPrices.get(nearest);
         }
         if (underlyingPrice === undefined) {
-          const dateOnly = ts.split(' ')[0];
+          const dateOnly = ts.split(" ")[0];
           underlyingPrice = greeksConfig.underlyingPrices.get(dateOnly);
         }
 
         if (underlyingPrice !== undefined) {
           point.underlyingPrice = underlyingPrice;
           const legGreeksArr: GreeksResult[] = [];
-          let netDelta = 0, netGamma = 0, netTheta = 0, netVega = 0;
+          let netDelta = 0,
+            netGamma = 0,
+            netTheta = 0,
+            netVega = 0;
           let allNull = true;
 
           for (let j = 0; j < legs.length; j++) {
@@ -431,11 +441,11 @@ export function computeStrategyPnlPath(
             }
 
             // Compute fractional DTE from bar timestamp to leg expiry
-            const dateStr = ts.split(' ')[0];
-            const timePart = ts.split(' ')[1] ?? '09:30';
-            const [eyy, emm, edd] = legCfg.expiryDate.split('-').map(Number);
-            const [byy, bmm, bdd] = dateStr.split('-').map(Number);
-            const [hh, min] = timePart.split(':').map(Number);
+            const dateStr = ts.split(" ")[0];
+            const timePart = ts.split(" ")[1] ?? "09:30";
+            const [eyy, emm, edd] = legCfg.expiryDate.split("-").map(Number);
+            const [byy, bmm, bdd] = dateStr.split("-").map(Number);
+            const [hh, min] = timePart.split(":").map(Number);
 
             const expiryMs = new Date(eyy, emm - 1, edd).getTime() + 16 * 60 * 60 * 1000; // 4:00 PM ET
             const barMs = new Date(byy, bmm - 1, bdd).getTime() + (hh * 60 + min) * 60 * 1000;
@@ -459,7 +469,7 @@ export function computeStrategyPnlPath(
 
             if (g.delta !== null) {
               allNull = false;
-              const weight = legs[j].quantity * legs[j].multiplier / 100;
+              const weight = (legs[j].quantity * legs[j].multiplier) / 100;
               netDelta += g.delta * weight;
               netGamma += g.gamma! * weight;
               netTheta += g.theta! * weight;
@@ -473,9 +483,8 @@ export function computeStrategyPnlPath(
           point.netTheta = allNull ? null : netTheta;
           point.netVega = allNull ? null : netVega;
 
-
           // IVP lookup by date
-          const ivpDate = ts.split(' ')[0];
+          const ivpDate = ts.split(" ")[0];
           point.ivp = greeksConfig.ivpByDate?.get(ivpDate) ?? null;
         }
       }
@@ -505,7 +514,7 @@ export function computeReplayMfeMae(pnlPath: PnlPoint[]): {
   maeTimestamp: string;
 } {
   if (pnlPath.length === 0) {
-    return { mfe: 0, mae: 0, mfeTimestamp: '', maeTimestamp: '' };
+    return { mfe: 0, mae: 0, mfeTimestamp: "", maeTimestamp: "" };
   }
 
   let mfe = pnlPath[0].strategyPnl;