@tradejs/cli 1.0.6 → 1.0.8

package/dist/lib/runtimeParity.js

@@ -0,0 +1,234 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeParity.ts
+var runtimeParity_exports = {};
+__export(runtimeParity_exports, {
+  compareTradeParityEntries: () => compareTradeParityEntries,
+  dedupeRuntimeParityEntries: () => dedupeRuntimeParityEntries,
+  extractBacktestEntryParityEntries: () => extractBacktestEntryParityEntries,
+  extractRuntimeParityEntries: () => extractRuntimeParityEntries,
+  findRuntimeDuplicateGroups: () => findRuntimeDuplicateGroups,
+  summarizeMatchedParity: () => summarizeMatchedParity
+});
+module.exports = __toCommonJS(runtimeParity_exports);
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
+var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
+var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
+var buildPriceDeltaPct = (leftPrice, rightPrice) => {
+  if (leftPrice == null || rightPrice == null || !Number.isFinite(leftPrice) || !Number.isFinite(rightPrice) || leftPrice === 0) {
+    return null;
+  }
+  return Math.abs((rightPrice - leftPrice) / leftPrice * 100);
+};
+var extractBacktestEntryParityEntries = (orderLog) => {
+  if (!Array.isArray(orderLog)) {
+    return [];
+  }
+  return orderLog.filter(
+    (item) => (item.type === "OPEN_LONG" || item.type === "OPEN_SHORT") && item.signal && typeof item.signal.strategy === "string" && typeof item.signal.symbol === "string" && (item.signal.direction === "LONG" || item.signal.direction === "SHORT")
+  ).map((item, index) => {
+    const signal = item.signal;
+    const timestamp = typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : item.timestamp;
+    return {
+      id: typeof signal.signalId === "string" && signal.signalId.trim() ? signal.signalId : `backtest-${index}-${timestamp}`,
+      source: "backtest",
+      strategy: signal.strategy,
+      symbol: signal.symbol,
+      direction: signal.direction,
+      timestamp,
+      price: toFiniteNumberOrNull(item.price),
+      signalId: typeof signal.signalId === "string" ? signal.signalId : void 0
+    };
+  }).sort((left, right) => left.timestamp - right.timestamp);
+};
+var extractRuntimeParityEntries = (trades) => trades.filter(
+  (trade) => typeof trade.strategy === "string" && typeof trade.symbol === "string" && (trade.direction === "LONG" || trade.direction === "SHORT") && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp)
+).map((trade) => ({
+  id: trade.orderId,
+  source: "runtime",
+  strategy: trade.strategy,
+  symbol: trade.symbol,
+  direction: trade.direction,
+  timestamp: trade.entryTimestamp,
+  price: toFiniteNumberOrNull(trade.entryPrice),
+  orderId: trade.orderId,
+  signalId: typeof trade.signalId === "string" ? trade.signalId : void 0
+})).sort((left, right) => left.timestamp - right.timestamp);
+var findRuntimeDuplicateGroups = (entries) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.source !== "runtime") {
+      continue;
+    }
+    const key = toRuntimeDuplicateKey(entry);
+    const bucket = groups.get(key) ?? [];
+    bucket.push(entry);
+    groups.set(key, bucket);
+  }
+  return [...groups.entries()].filter(([, group]) => group.length > 1).map(([key, group]) => {
+    const sortedGroup = [...group].sort(sortTradeParityEntries);
+    const first = sortedGroup[0];
+    return {
+      key,
+      strategy: first.strategy,
+      symbol: first.symbol,
+      direction: first.direction,
+      timestamp: first.timestamp,
+      entries: sortedGroup
+    };
+  }).sort(
+    (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction)
+  );
+};
+var dedupeRuntimeParityEntries = (entries) => {
+  const duplicateGroups = findRuntimeDuplicateGroups(entries);
+  const duplicateEntriesSet = /* @__PURE__ */ new Set();
+  for (const group of duplicateGroups) {
+    for (const duplicate of group.entries.slice(1)) {
+      duplicateEntriesSet.add(duplicate);
+    }
+  }
+  const dedupedEntries = entries.filter((entry) => !duplicateEntriesSet.has(entry)).sort(sortTradeParityEntries);
+  const duplicateEntries = duplicateGroups.flatMap((group) => group.entries.slice(1)).sort(sortTradeParityEntries);
+  return {
+    entries: dedupedEntries,
+    duplicateGroups,
+    duplicateEntries
+  };
+};
+var compareTradeParityEntries = ({
+  runtimeEntries,
+  backtestEntries,
+  toleranceMs
+}) => {
+  const matched = [];
+  const runtimeOnly = [];
+  const backtestOnly = [];
+  const groupedRuntime = /* @__PURE__ */ new Map();
+  const groupedBacktest = /* @__PURE__ */ new Map();
+  for (const entry of runtimeEntries) {
+    const key = toGroupKey(entry);
+    const bucket = groupedRuntime.get(key) ?? [];
+    bucket.push(entry);
+    groupedRuntime.set(key, bucket);
+  }
+  for (const entry of backtestEntries) {
+    const key = toGroupKey(entry);
+    const bucket = groupedBacktest.get(key) ?? [];
+    bucket.push(entry);
+    groupedBacktest.set(key, bucket);
+  }
+  const groupKeys = /* @__PURE__ */ new Set([
+    ...groupedRuntime.keys(),
+    ...groupedBacktest.keys()
+  ]);
+  for (const key of groupKeys) {
+    const runtimeGroup = [...groupedRuntime.get(key) ?? []].sort(
+      (left, right) => left.timestamp - right.timestamp
+    );
+    const backtestGroup = [...groupedBacktest.get(key) ?? []].sort(
+      (left, right) => left.timestamp - right.timestamp
+    );
+    const unmatchedBacktest = backtestGroup.map((entry) => ({
+      entry,
+      used: false
+    }));
+    for (const runtimeEntry of runtimeGroup) {
+      let bestIndex = -1;
+      let bestDiff = Number.POSITIVE_INFINITY;
+      for (let index = 0; index < unmatchedBacktest.length; index += 1) {
+        const candidate = unmatchedBacktest[index];
+        if (candidate.used) {
+          continue;
+        }
+        const diff = Math.abs(
+          candidate.entry.timestamp - runtimeEntry.timestamp
+        );
+        if (diff > toleranceMs || diff >= bestDiff) {
+          continue;
+        }
+        bestIndex = index;
+        bestDiff = diff;
+      }
+      if (bestIndex < 0) {
+        runtimeOnly.push(runtimeEntry);
+        continue;
+      }
+      unmatchedBacktest[bestIndex].used = true;
+      const backtestEntry = unmatchedBacktest[bestIndex].entry;
+      matched.push({
+        runtime: runtimeEntry,
+        backtest: backtestEntry,
+        timestampDiffMs: bestDiff,
+        priceDeltaPct: buildPriceDeltaPct(
+          runtimeEntry.price,
+          backtestEntry.price
+        )
+      });
+    }
+    for (const candidate of unmatchedBacktest) {
+      if (!candidate.used) {
+        backtestOnly.push(candidate.entry);
+      }
+    }
+  }
+  matched.sort(
+    (left, right) => left.runtime.timestamp - right.runtime.timestamp
+  );
+  runtimeOnly.sort((left, right) => left.timestamp - right.timestamp);
+  backtestOnly.sort((left, right) => left.timestamp - right.timestamp);
+  return {
+    matched,
+    runtimeOnly,
+    backtestOnly
+  };
+};
+var summarizeMatchedParity = (matched) => {
+  if (!matched.length) {
+    return {
+      avgPriceDeltaPct: null,
+      maxPriceDeltaPct: null,
+      avgTimestampDiffMs: null,
+      maxTimestampDiffMs: null
+    };
+  }
+  const priceDeltas = matched.map((item) => item.priceDeltaPct).filter(
+    (value) => value != null && Number.isFinite(value)
+  );
+  const timestampDiffs = matched.map((item) => item.timestampDiffMs).filter((value) => Number.isFinite(value));
+  const average = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
+  const maximum = (values) => values.length ? Math.max(...values) : null;
+  return {
+    avgPriceDeltaPct: average(priceDeltas),
+    maxPriceDeltaPct: maximum(priceDeltas),
+    avgTimestampDiffMs: average(timestampDiffs),
+    maxTimestampDiffMs: maximum(timestampDiffs)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compareTradeParityEntries,
+  dedupeRuntimeParityEntries,
+  extractBacktestEntryParityEntries,
+  extractRuntimeParityEntries,
+  findRuntimeDuplicateGroups,
+  summarizeMatchedParity
+});

package/dist/lib/telegramReports.js

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/telegramReports.ts
+var telegramReports_exports = {};
+__export(telegramReports_exports, {
+  TELEGRAM_REPORT_CHUNK_LIMIT: () => TELEGRAM_REPORT_CHUNK_LIMIT,
+  sendTelegramReport: () => sendTelegramReport,
+  splitTelegramReport: () => splitTelegramReport
+});
+module.exports = __toCommonJS(telegramReports_exports);
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  return chunks.length;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TELEGRAM_REPORT_CHUNK_LIMIT,
+  sendTelegramReport,
+  splitTelegramReport
+});

package/dist/lib/timeWindow.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/timeWindow.ts
+var timeWindow_exports = {};
+__export(timeWindow_exports, {
+  resolveTimeWindow: () => resolveTimeWindow
+});
+module.exports = __toCommonJS(timeWindow_exports);
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var toEpochMs = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed < 1e12 ? Math.trunc(parsed * 1e3) : Math.trunc(parsed);
+};
+var toPositiveNumber = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+};
+var resolveTimeWindow = ({
+  days,
+  startTime,
+  endTime,
+  nowMs = Date.now(),
+  defaultStartMs,
+  defaultEndMs
+}) => {
+  const explicitStart = toEpochMs(startTime);
+  const explicitEnd = toEpochMs(endTime);
+  if (explicitStart != null || explicitEnd != null) {
+    const resolvedEnd2 = explicitEnd ?? defaultEndMs ?? nowMs;
+    const resolvedStart = explicitStart ?? defaultStartMs;
+    if (resolvedStart >= resolvedEnd2) {
+      throw new Error(
+        `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
+      );
+    }
+    return {
+      start: resolvedStart,
+      end: resolvedEnd2,
+      source: "explicit"
+    };
+  }
+  const resolvedDays = toPositiveNumber(days);
+  if (resolvedDays != null) {
+    const resolvedEnd2 = defaultEndMs ?? nowMs;
+    const resolvedStart = resolvedEnd2 - resolvedDays * ONE_DAY_MS;
+    if (resolvedStart >= resolvedEnd2) {
+      throw new Error(
+        `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
+      );
+    }
+    return {
+      start: Math.trunc(resolvedStart),
+      end: Math.trunc(resolvedEnd2),
+      source: "days"
+    };
+  }
+  const resolvedEnd = defaultEndMs ?? nowMs;
+  if (defaultStartMs >= resolvedEnd) {
+    throw new Error(
+      `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
+    );
+  }
+  return {
+    start: Math.trunc(defaultStartMs),
+    end: Math.trunc(resolvedEnd),
+    source: "default"
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveTimeWindow
+});