tradeblocks-mcp 3.0.3 → 3.3.1

package/README.md

@@ -14,13 +14,7 @@ Model Context Protocol (MCP) server for options trading analysis. Works with Cla
 
 ## Installation
 
-### Option 1: MCPB Bundle (Claude Desktop - One Click)
-
-Download the latest `.mcpb` file from [Releases](https://github.com/tradeblocks-org/tradeblocks/releases) and double-click to install.
-
-The installer will prompt you to select your Trading Data Directory.
-
-### Option 2: npx (All Platforms)
+### Option 1: npx (All Platforms)
 
 Run directly without installation:
 
@@ -32,9 +26,9 @@ npx tradeblocks-mcp ~/Trading/backtests
 npx tradeblocks-mcp --http ~/Trading/backtests
 ```
 
-See [Configuration by Platform](#configuration-by-platform) below for platform-specific setup.
+For Claude Desktop, add the server to `claude_desktop_config.json` — see [Configuration by Platform](#configuration-by-platform) below for platform-specific setup.
 
-### Option 3: From Source
+### Option 2: From Source
 
 ```bash
 git clone https://github.com/tradeblocks-org/tradeblocks
@@ -399,9 +393,6 @@ npm run build
 
 # Run tests
 npm test
-
-# Pack MCPB bundle
-npm run mcpb:pack
 ```
 
 ## Market Data (Optional)

package/dist/{chunk-C6LL746C.js → chunk-2I3S2ZLT.js}

@@ -21416,6 +21416,262 @@ var DAY_MS = 24 * 60 * 60 * 1e3;
 // ../lib/calculations/walk-forward-degradation.ts
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 
+// ../lib/calculations/paired-block-bootstrap.ts
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return function() {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function deriveSeed(seed, blockDays) {
+  return seed + Math.imul(blockDays, 2654435761) >>> 0;
+}
+function percentileOf(sorted, p) {
+  const n = sorted.length;
+  if (n === 1) return sorted[0];
+  const rank = p * (n - 1);
+  const lo = Math.floor(rank);
+  const hi = Math.ceil(rank);
+  if (lo === hi) return sorted[lo];
+  const weight = rank - lo;
+  return sorted[lo] * (1 - weight) + sorted[hi] * weight;
+}
+function observedValueMap(arm) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (let i = 0; i < arm.index.length; i++) {
+    if (arm.observedMask[i]) {
+      map2.set(arm.index[i], arm.values[i]);
+    }
+  }
+  return map2;
+}
+function isConstantArm(arm) {
+  return arm !== void 0 && "constant" in arm;
+}
+function unionDays(a, b) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of a) seen.add(d);
+  for (const d of b) seen.add(d);
+  return Array.from(seen).sort();
+}
+function buildOverlap(ambient, isObserved, deltaOf) {
+  const days = [];
+  const delta = [];
+  const runs = [];
+  let runStart = -1;
+  for (const day of ambient) {
+    if (isObserved(day)) {
+      if (runStart === -1) runStart = days.length;
+      days.push(day);
+      delta.push(deltaOf(day));
+    } else if (runStart !== -1) {
+      runs.push({ start: runStart, length: days.length - runStart });
+      runStart = -1;
+    }
+  }
+  if (runStart !== -1) {
+    runs.push({ start: runStart, length: days.length - runStart });
+  }
+  return { days, delta, runs };
+}
+function buildComparisonOverlap(armA, armB) {
+  const mapA = observedValueMap(armA);
+  if (armB === void 0 || isConstantArm(armB)) {
+    const c = armB === void 0 ? 0 : armB.constant;
+    return buildOverlap(
+      armA.index,
+      (day) => mapA.has(day),
+      (day) => mapA.get(day) - c
+    );
+  }
+  const mapB = observedValueMap(armB);
+  const ambient = unionDays(armA.index, armB.index);
+  return buildOverlap(
+    ambient,
+    (day) => mapA.has(day) && mapB.has(day),
+    (day) => mapA.get(day) - mapB.get(day)
+  );
+}
+function enumerateBlockStarts(runs, blockDays) {
+  const starts = [];
+  for (const run of runs) {
+    const lastStart = run.length - blockDays;
+    for (let offset = 0; offset <= lastStart; offset++) {
+      starts.push(run.start + offset);
+    }
+  }
+  return starts;
+}
+function drawResampleIndices(rng, blockStarts, blockDays, n) {
+  const indices = [];
+  while (indices.length < n) {
+    const start = blockStarts[Math.floor(rng() * blockStarts.length)];
+    for (let k = 0; k < blockDays && indices.length < n; k++) {
+      indices.push(start + k);
+    }
+  }
+  return indices;
+}
+function computeCore(params) {
+  const {
+    overlapDays,
+    runs,
+    deltaSeries,
+    memberDeltas,
+    extremum,
+    blockDays,
+    resamples,
+    seed,
+    ciLevel,
+    statistic,
+    effectiveNFloorBlocks
+  } = params;
+  const n = overlapDays.length;
+  const effectiveN = n / blockDays;
+  const takeExtremum = (values) => extremum === "min" ? Math.min(...values) : Math.max(...values);
+  let point;
+  if (n === 0) {
+    point = null;
+  } else if (memberDeltas) {
+    point = takeExtremum(memberDeltas.map((d) => statistic(d)));
+  } else {
+    point = statistic(deltaSeries);
+  }
+  const blockStarts = enumerateBlockStarts(runs, blockDays);
+  if (effectiveNFloorBlocks !== void 0 && effectiveN < effectiveNFloorBlocks) {
+    return { point, low: null, high: null, effectiveN, status: "notComparable" };
+  }
+  if (blockStarts.length < 2) {
+    return { point, low: null, high: null, effectiveN, status: "underpowered" };
+  }
+  const rng = mulberry32(deriveSeed(seed, blockDays));
+  const distribution = new Array(resamples);
+  for (let r = 0; r < resamples; r++) {
+    const idx = drawResampleIndices(rng, blockStarts, blockDays, n);
+    if (memberDeltas) {
+      const stats = memberDeltas.map((d) => statistic(idx.map((i) => d[i])));
+      distribution[r] = takeExtremum(stats);
+    } else {
+      distribution[r] = statistic(idx.map((i) => deltaSeries[i]));
+    }
+  }
+  distribution.sort((a, b) => a - b);
+  const alpha = 1 - ciLevel;
+  const low = percentileOf(distribution, alpha / 2);
+  const high = percentileOf(distribution, 1 - alpha / 2);
+  return { point, low, high, effectiveN, status: "resolved" };
+}
+function buildSelectionOverlap(members) {
+  const memberMaps = members.map((m) => {
+    const overlap2 = buildComparisonOverlap(m.armA, m.armB);
+    const map2 = /* @__PURE__ */ new Map();
+    for (let i = 0; i < overlap2.days.length; i++) {
+      map2.set(overlap2.days[i], overlap2.delta[i]);
+    }
+    return map2;
+  });
+  let ambient = [];
+  for (const m of members) {
+    const armBDays = isConstantArm(m.armB) || m.armB === void 0 ? [] : m.armB.index;
+    ambient = unionDays(ambient, unionDays(m.armA.index, armBDays));
+  }
+  const overlap = buildOverlap(
+    ambient,
+    (day) => memberMaps.every((map2) => map2.has(day)),
+    () => 0
+  );
+  const memberDeltas = memberMaps.map((map2) => overlap.days.map((day) => map2.get(day)));
+  return { days: overlap.days, runs: overlap.runs, memberDeltas };
+}
+function holdingPeriodBlockDays(holdingPeriodsTradingDays, percentile = 0.95) {
+  if (holdingPeriodsTradingDays.length === 0) return 1;
+  const sorted = [...holdingPeriodsTradingDays].sort((a, b) => a - b);
+  return Math.max(1, Math.round(percentileOf(sorted, percentile)));
+}
+function pairedBlockBootstrap(input) {
+  const blockDays = Math.max(1, Math.round(input.holdingRule.blockDays));
+  const { ciLevel, resamples, seed, statistic, effectiveNFloorBlocks } = input;
+  let overlapDays;
+  let runs;
+  let deltaSeries;
+  let memberDeltas;
+  let extremum;
+  let selection = null;
+  if (input.selectionSet) {
+    const sel = buildSelectionOverlap(input.selectionSet.members);
+    overlapDays = sel.days;
+    runs = sel.runs;
+    memberDeltas = sel.memberDeltas;
+    extremum = input.selectionSet.extremum;
+    deltaSeries = [];
+    const memberPoints = sel.memberDeltas.map((d) => statistic(d));
+    const kConsidered = memberPoints.length;
+    const centroid = kConsidered > 0 ? memberPoints.reduce((s, v) => s + v, 0) / kConsidered : 0;
+    let maxGap = 0;
+    if (kConsidered >= 2) {
+      const ordered = [...memberPoints].sort((a, b) => a - b);
+      maxGap = extremum === "min" ? ordered[1] - ordered[0] : ordered[kConsidered - 1] - ordered[kConsidered - 2];
+    }
+    selection = { centroid, maxGap, kConsidered };
+  } else {
+    const overlap = buildComparisonOverlap(input.armA, input.armB);
+    overlapDays = overlap.days;
+    runs = overlap.runs;
+    deltaSeries = overlap.delta;
+  }
+  const overlapWindow = overlapDays.length > 0 ? { start: overlapDays[0], end: overlapDays[overlapDays.length - 1] } : null;
+  const primary = computeCore({
+    overlapDays,
+    runs,
+    deltaSeries,
+    memberDeltas,
+    extremum,
+    blockDays,
+    resamples,
+    seed,
+    ciLevel,
+    statistic,
+    effectiveNFloorBlocks
+  });
+  const sensitivity = [];
+  for (const multiplier of input.holdingRule.sensitivity ?? []) {
+    const sensBlockDays = Math.max(1, Math.round(multiplier * blockDays));
+    const sens = computeCore({
+      overlapDays,
+      runs,
+      deltaSeries,
+      memberDeltas,
+      extremum,
+      blockDays: sensBlockDays,
+      resamples,
+      seed,
+      ciLevel,
+      statistic,
+      effectiveNFloorBlocks
+    });
+    sensitivity.push({
+      blockDays: sensBlockDays,
+      ci: { low: sens.low, high: sens.high },
+      status: sens.status
+    });
+  }
+  return {
+    point: primary.point,
+    ci: { level: ciLevel, low: primary.low, high: primary.high, method: "paired-day-block" },
+    effectiveN: primary.effectiveN,
+    overlapWindow,
+    blockDays,
+    sensitivity,
+    selection,
+    status: primary.status,
+    seed
+  };
+}
+
 // ../lib/calculations/index.ts
 function generateDataHash(trades, dailyLogs) {
   const data = {
@@ -21637,6 +21893,8 @@ export {
   PortfolioStatsCalculator,
   calculateCorrelationMatrix,
   performTailRiskAnalysis,
+  holdingPeriodBlockDays,
+  pairedBlockBootstrap,
   REPORTING_TRADE_COLUMN_ALIASES,
   isTatFormat,
   convertTatRowToReportingTrade
@@ -21652,4 +21910,4 @@ decimal.js/decimal.mjs:
    *  MIT Licence
    *)
 */
-//# sourceMappingURL=chunk-C6LL746C.js.map
+//# sourceMappingURL=chunk-2I3S2ZLT.js.map