tradeblocks-mcp 3.0.0 → 3.0.2

package/server/iv-solver-worker.js

@@ -0,0 +1,295 @@
+// src/utils/iv-solver-worker.ts
+import { parentPort } from "node:worker_threads";
+
+// src/utils/black-scholes.ts
+var BACHELIER_DTE_THRESHOLD = 0.1;
+function pdf(x) {
+  return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+}
+function cdf(x) {
+  if (x < -10) return 0;
+  if (x > 10) return 1;
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const p = 0.2316419;
+  const b1 = 0.31938153;
+  const b2 = -0.356563782;
+  const b3 = 1.781477937;
+  const b4 = -1.821255978;
+  const b5 = 1.330274429;
+  const t = 1 / (1 + p * absX);
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const t4 = t3 * t;
+  const t5 = t4 * t;
+  const poly = b1 * t + b2 * t2 + b3 * t3 + b4 * t4 + b5 * t5;
+  const result = 1 - pdf(absX) * poly;
+  return sign === 1 ? result : 1 - result;
+}
+function d1d2(S, K, T, r, q, sigma) {
+  const sqrtT = Math.sqrt(T);
+  const d1 = (Math.log(S / K) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
+  const d2 = d1 - sigma * sqrtT;
+  return { d1, d2 };
+}
+function bsPrice(type, S, K, T, r, q, sigma) {
+  if (T <= 0) {
+    return type === "call" ? Math.max(S - K, 0) : Math.max(K - S, 0);
+  }
+  if (sigma <= 0) {
+    const forward = S * Math.exp((r - q) * T);
+    if (type === "call") {
+      return Math.max(forward - K, 0) * Math.exp(-r * T);
+    } else {
+      return Math.max(K - forward, 0) * Math.exp(-r * T);
+    }
+  }
+  const { d1, d2 } = d1d2(S, K, T, r, q, sigma);
+  if (type === "call") {
+    return S * Math.exp(-q * T) * cdf(d1) - K * Math.exp(-r * T) * cdf(d2);
+  } else {
+    return K * Math.exp(-r * T) * cdf(-d2) - S * Math.exp(-q * T) * cdf(-d1);
+  }
+}
+function bsDelta(type, S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) {
+    if (type === "call") return S > K ? 1 : 0;
+    return S < K ? -1 : 0;
+  }
+  const { d1 } = d1d2(S, K, T, r, q, sigma);
+  const eqT = Math.exp(-q * T);
+  if (type === "call") {
+    return cdf(d1) * eqT;
+  } else {
+    return (cdf(d1) - 1) * eqT;
+  }
+}
+function bsGamma(S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) return 0;
+  const { d1 } = d1d2(S, K, T, r, q, sigma);
+  return pdf(d1) * Math.exp(-q * T) / (S * sigma * Math.sqrt(T));
+}
+function bsTheta(type, S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) return 0;
+  const { d1, d2 } = d1d2(S, K, T, r, q, sigma);
+  const sqrtT = Math.sqrt(T);
+  const eqT = Math.exp(-q * T);
+  const erT = Math.exp(-r * T);
+  const term1 = -(S * eqT * pdf(d1) * sigma) / (2 * sqrtT);
+  if (type === "call") {
+    const term2 = q * S * eqT * cdf(d1);
+    const term3 = -r * K * erT * cdf(d2);
+    return (term1 - term2 - term3) / 365;
+  } else {
+    const term2 = q * S * eqT * cdf(-d1);
+    const term3 = -r * K * erT * cdf(-d2);
+    return (term1 + term2 + term3) / 365;
+  }
+}
+function bsVega(S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) return 0;
+  const { d1 } = d1d2(S, K, T, r, q, sigma);
+  return S * Math.exp(-q * T) * pdf(d1) * Math.sqrt(T) / 100;
+}
+function solveIV(type, marketPrice, S, K, T, r, q, maxIter = 100, tolerance = 1e-6) {
+  if (marketPrice <= 0 || T <= 0) return null;
+  let sigma = 0.3;
+  let lo = 1e-3;
+  let hi = 5;
+  for (let i = 0; i < maxIter; i++) {
+    const price = bsPrice(type, S, K, T, r, q, sigma);
+    const diff = price - marketPrice;
+    if (Math.abs(diff) < tolerance) {
+      return sigma;
+    }
+    const { d1 } = d1d2(S, K, T, r, q, sigma);
+    const rawVega = S * Math.exp(-q * T) * pdf(d1) * Math.sqrt(T);
+    if (rawVega < 1e-10) {
+      const mid = (lo + hi) / 2;
+      if (diff > 0) {
+        hi = sigma;
+      } else {
+        lo = sigma;
+      }
+      sigma = mid;
+    } else {
+      const newSigma = sigma - diff / rawVega;
+      if (newSigma <= 0 || newSigma > 10) {
+        if (diff > 0) {
+          hi = sigma;
+        } else {
+          lo = sigma;
+        }
+        sigma = (lo + hi) / 2;
+      } else {
+        sigma = newSigma;
+      }
+    }
+  }
+  return null;
+}
+function bachelierPrice(type, S, K, T, r, q, sigma_n) {
+  if (T <= 0) return type === "call" ? Math.max(S - K, 0) : Math.max(K - S, 0);
+  if (sigma_n <= 0) {
+    const forward2 = S * Math.exp((r - q) * T);
+    return Math.exp(-r * T) * (type === "call" ? Math.max(forward2 - K, 0) : Math.max(K - forward2, 0));
+  }
+  const forward = S * Math.exp((r - q) * T);
+  const sqrtT = Math.sqrt(T);
+  const d = (forward - K) / (sigma_n * sqrtT);
+  const discount = Math.exp(-r * T);
+  if (type === "call") {
+    return discount * ((forward - K) * cdf(d) + sigma_n * sqrtT * pdf(d));
+  } else {
+    return discount * ((K - forward) * cdf(-d) + sigma_n * sqrtT * pdf(d));
+  }
+}
+function bachelierDelta(type, S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) {
+    if (type === "call") return S > K ? 1 : 0;
+    return S < K ? -1 : 0;
+  }
+  const forward = S * Math.exp((r - q) * T);
+  const d = (forward - K) / (sigma_n * Math.sqrt(T));
+  const discount = Math.exp(-r * T);
+  return type === "call" ? discount * cdf(d) : -discount * cdf(-d);
+}
+function bachelierGamma(S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) return 0;
+  const forward = S * Math.exp((r - q) * T);
+  const sqrtT = Math.sqrt(T);
+  const d = (forward - K) / (sigma_n * sqrtT);
+  return Math.exp(-r * T) * pdf(d) / (sigma_n * sqrtT);
+}
+function bachelierTheta(type, S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) return 0;
+  const forward = S * Math.exp((r - q) * T);
+  const sqrtT = Math.sqrt(T);
+  const d = (forward - K) / (sigma_n * sqrtT);
+  const discount = Math.exp(-r * T);
+  const price = bachelierPrice(type, S, K, T, r, q, sigma_n);
+  const annualTheta = -discount * sigma_n * pdf(d) / (2 * sqrtT) + r * price;
+  return annualTheta / 365;
+}
+function bachelierVega(S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) return 0;
+  const forward = S * Math.exp((r - q) * T);
+  const d = (forward - K) / (sigma_n * Math.sqrt(T));
+  return Math.exp(-r * T) * Math.sqrt(T) * pdf(d) / 100;
+}
+function solveNormalIV(type, marketPrice, S, K, T, r, q, maxIter = 100, tolerance = 1e-6) {
+  if (marketPrice <= 0 || T <= 0) return null;
+  let sigma_n = marketPrice / Math.sqrt(T / (2 * Math.PI));
+  sigma_n = Math.max(sigma_n, 1);
+  let lo = 0.01;
+  let hi = 5e4;
+  for (let i = 0; i < maxIter; i++) {
+    const price = bachelierPrice(type, S, K, T, r, q, sigma_n);
+    const diff = price - marketPrice;
+    if (Math.abs(diff) < tolerance) return sigma_n;
+    const forward = S * Math.exp((r - q) * T);
+    const d = (forward - K) / (sigma_n * Math.sqrt(T));
+    const rawVega = Math.exp(-r * T) * Math.sqrt(T) * pdf(d);
+    if (rawVega < 1e-10) {
+      if (diff > 0) {
+        hi = sigma_n;
+      } else {
+        lo = sigma_n;
+      }
+      sigma_n = (lo + hi) / 2;
+    } else {
+      const newSigma = sigma_n - diff / rawVega;
+      if (newSigma <= 0 || newSigma > 1e5) {
+        if (diff > 0) {
+          hi = sigma_n;
+        } else {
+          lo = sigma_n;
+        }
+        sigma_n = (lo + hi) / 2;
+      } else {
+        sigma_n = newSigma;
+      }
+    }
+  }
+  return null;
+}
+function computeLegGreeks(optionPrice, underlyingPrice, strike, dte, type, riskFreeRate, dividendYield) {
+  const T = dte / 365;
+  const bsType = type === "C" ? "call" : "put";
+  const nullResult = { delta: null, gamma: null, theta: null, vega: null, iv: null };
+  if (dte < BACHELIER_DTE_THRESHOLD) {
+    const iv2 = solveNormalIV(bsType, optionPrice, underlyingPrice, strike, T, riskFreeRate, dividendYield);
+    if (iv2 === null) return nullResult;
+    return {
+      delta: bachelierDelta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      gamma: bachelierGamma(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      theta: bachelierTheta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      vega: bachelierVega(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      iv: iv2,
+      model: "bachelier"
+    };
+  }
+  const iv = solveIV(bsType, optionPrice, underlyingPrice, strike, T, riskFreeRate, dividendYield);
+  if (iv === null) return nullResult;
+  return {
+    delta: bsDelta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    gamma: bsGamma(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    theta: bsTheta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    vega: bsVega(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    iv,
+    model: "bs"
+  };
+}
+
+// src/utils/iv-solver-worker.ts
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function solveIvBatch(req) {
+  const { id, count } = req;
+  const delta = new Float64Array(count);
+  const gamma = new Float64Array(count);
+  const theta = new Float64Array(count);
+  const vega = new Float64Array(count);
+  const iv = new Float64Array(count);
+  const ok = new Uint8Array(count);
+  for (let i = 0; i < count; i++) {
+    const result = computeLegGreeks(
+      req.optionPrice[i],
+      req.underlyingPrice[i],
+      req.strike[i],
+      req.dte[i],
+      req.type[i] === 0 ? "C" : "P",
+      req.riskFreeRate[i],
+      req.dividendYield[i]
+    );
+    if (isFiniteNumber(result.delta) && isFiniteNumber(result.gamma) && isFiniteNumber(result.theta) && isFiniteNumber(result.vega) && isFiniteNumber(result.iv)) {
+      delta[i] = result.delta;
+      gamma[i] = result.gamma;
+      theta[i] = result.theta;
+      vega[i] = result.vega;
+      iv[i] = result.iv;
+      ok[i] = 1;
+    } else {
+      ok[i] = 0;
+    }
+  }
+  return { id, count, delta, gamma, theta, vega, iv, ok };
+}
+if (parentPort) {
+  const port = parentPort;
+  port.on("message", (req) => {
+    const reply = solveIvBatch(req);
+    port.postMessage(reply, [
+      reply.delta.buffer,
+      reply.gamma.buffer,
+      reply.theta.buffer,
+      reply.vega.buffer,
+      reply.iv.buffer,
+      reply.ok.buffer
+    ]);
+  });
+}
+export {
+  solveIvBatch
+};

package/server/{market-provider-D5SI47K7.js → market-provider-VOYYVYWT.js}

@@ -2,7 +2,7 @@
 import {
   _resetProvider,
   getProvider
-} from "./chunk-JAAQMESY.js";
+} from "./chunk-PNKG7RY7.js";
 import "./chunk-72GKJE2U.js";
 import "./chunk-CSDVJPBB.js";
 import "./chunk-WA5AAPCH.js";
@@ -14,4 +14,4 @@ export {
   _resetProvider,
   getProvider
 };
-//# sourceMappingURL=market-provider-D5SI47K7.js.map
+//# sourceMappingURL=market-provider-VOYYVYWT.js.map

package/src/index.ts

@@ -384,10 +384,27 @@ export async function startTradeBlocksMcp(
   process.on("SIGTERM", shutdown);
 }
 
-const entrypoint = process.argv[1] ? path.resolve(process.argv[1]) : "";
-const currentFile = fileURLToPath(import.meta.url);
+// Resolve the entrypoint path to the actual file that was executed
+// Needed in case command is executed via symlink, often used by node version managers.
+async function resolveEntrypointPath(filePath: string): Promise<string> {
+  const resolved = path.resolve(filePath);
+  try {
+    return await fs.realpath(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+async function isDirectEntrypoint(): Promise<boolean> {
+  if (!process.argv[1]) return false;
+
+  const entrypoint = await resolveEntrypointPath(process.argv[1]);
+  const currentFile = await resolveEntrypointPath(fileURLToPath(import.meta.url));
+
+  return entrypoint === currentFile;
+}
 
-if (entrypoint === currentFile) {
+if (await isDirectEntrypoint()) {
   startTradeBlocksMcp().catch((error) => {
     console.error("Error:", error.message || error);
     process.exit(1);

package/src/market/ingestor/market-ingestor.ts

@@ -20,7 +20,7 @@ import type {
   BulkProgressReporter,
 } from "./types.ts";
 import type { OiDailyRow, QuoteRow } from "../stores/types.ts";
-import { applyQuoteGreeks, type QuoteGreeksStats } from "../../utils/option-quote-greeks.ts";
+import { applyQuoteGreeksParallel, type QuoteGreeksStats } from "../../utils/option-quote-greeks.ts";
 
 export interface MarketIngestorDeps {
   stores: MarketStores;
@@ -441,7 +441,7 @@ export class MarketIngestor {
       }
     }
 
-    const stats = applyQuoteGreeks({
+    const stats = await applyQuoteGreeksParallel({
       rows,
       getDate: (row) => row.timestamp.slice(0, 10),
       getTime: (row) => row.timestamp.slice(11, 16),

package/src/test-exports.ts

@@ -278,11 +278,19 @@ export {
 export { computeFractionalDte } from './utils/option-time.ts';
 export {
   applyQuoteGreeks,
+  applyQuoteGreeksParallel,
   hasQuoteGreeks,
   OPTION_QUOTE_GREEKS_REVISION,
   type QuoteGreeksMode,
   type QuoteGreeksSource,
 } from './utils/option-quote-greeks.ts';
+export {
+  IvSolverPool,
+  getSharedIvSolverPool,
+  destroySharedIvSolverPool,
+  type IvSolveJob,
+  type IvSolveJobResult,
+} from './utils/iv-solver-pool.ts';
 export {
   describeReadParquetColumns,
   quoteParquetCanonicalProjection,