@tradejs/cli 1.0.6 → 1.0.9

package/dist/scripts/signalsSummary.js

@@ -0,0 +1,712 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/signalsSummary.ts
+var signalsSummary_exports = {};
+__export(signalsSummary_exports, {
+  signalsSummary: () => signalsSummary
+});
+module.exports = __toCommonJS(signalsSummary_exports);
+var import_config = require("dotenv/config");
+var import_args = __toESM(require("args"));
+var import_constants = require("@tradejs/core/constants");
+var import_logger = require("@tradejs/infra/logger");
+var import_redis2 = require("@tradejs/infra/redis");
+var import_connectors = require("@tradejs/node/connectors");
+
+// src/lib/telegramReports.ts
+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;
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var DAY_MS = 864e5;
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+var toIsoDayKey = (timestamp) => new Date(timestamp).toISOString().slice(0, 10);
+var toRuntimeStorageDayTimestamp = (timestamp) => Math.floor((timestamp + RUNTIME_STORAGE_DAY_OFFSET_MS) / DAY_MS) * DAY_MS;
+var getRuntimeStorageDayKeys = (startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime)) {
+    return [];
+  }
+  const start = Math.min(startTime, endTime);
+  const endExclusive = Math.max(startTime, endTime);
+  const normalizedEnd = Math.max(start, endExclusive - 1);
+  const keys = [];
+  const startDay = toRuntimeStorageDayTimestamp(start);
+  const endDay = toRuntimeStorageDayTimestamp(normalizedEnd);
+  for (let current = startDay; current <= endDay; current += DAY_MS) {
+    keys.push(toIsoDayKey(current));
+  }
+  return keys;
+};
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var isSignalRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
+};
+var sortByTimestamp = (records) => [...records].sort((left, right) => left.timestamp - right.timestamp);
+var loadRuntimeSignals = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalBuckets(userName));
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const seen = /* @__PURE__ */ new Set();
+  const payloads = await Promise.all(
+    refs.map(async (ref) => {
+      const dedupeKey = `${ref.symbol}:${ref.signalId}`;
+      if (seen.has(dedupeKey)) {
+        return null;
+      }
+      seen.add(dedupeKey);
+      const signal = await (0, import_redis.getData)(
+        import_redis.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var parseBucketKey = (prefix, key) => {
+  if (!key.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = key.slice(prefix.length);
+  const firstColon = suffix.indexOf(":");
+  if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+    return null;
+  }
+  return {
+    dayKey: suffix.slice(0, firstColon),
+    strategy: suffix.slice(firstColon + 1)
+  };
+};
+var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
+  const prefix = import_redis.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis.getKeys)(prefix);
+  const entries = await Promise.all(
+    keys.map(async (key) => {
+      const parsedKey = parseBucketKey(prefix, key);
+      if (!parsedKey) {
+        return null;
+      }
+      return {
+        key,
+        ...parsedKey,
+        stats: parseRuntimeSignalStatsBucket(await (0, import_redis.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+
+// src/scripts/signalsSummary.ts
+import_args.default.option(["u", "user"], "Use user config", "root");
+import_args.default.option(
+  "connector",
+  "Connector provider or name for summary (e.g. bybit, binance, coinbase, custom)",
+  "bybit"
+);
+import_args.default.option(["H", "hours"], "Summary window in hours", 24);
+import_args.default.option(["P", "printOnly"], "Print summary instead of Telegram", false);
+var flags = import_args.default.parse(process.argv);
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var SUMMARY_TIMEZONE = "Europe/Moscow";
+var SUMMARY_TIMEZONE_LABEL = "MSK";
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var formatMskDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+  timeZone: SUMMARY_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false
+}).format(new Date(timestamp));
+var formatSigned = (value) => `${value >= 0 ? "+" : ""}${value.toFixed(2)}`;
+var resolveSummaryTitle = (hours) => {
+  if (hours === 24) {
+    return "TradeJS daily summary";
+  }
+  if (hours === 168) {
+    return "TradeJS weekly summary";
+  }
+  return `TradeJS ${hours}h summary`;
+};
+var normalizeStatus = (value) => {
+  if (value === "completed" || value === "failed" || value === "skipped" || value === "canceled") {
+    return value;
+  }
+  return "unknown";
+};
+var isRuntimeTradeRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number";
+};
+var resolveSummaryConnectorName = async (value) => {
+  const connectorName = await (0, import_connectors.resolveConnectorName)(value, projectRoot);
+  if (connectorName) {
+    return connectorName;
+  }
+  import_logger.logger.warn(
+    'Unknown connector "%s". Fallback to %s.',
+    String(value || "").trim() || String(value),
+    import_connectors.DEFAULT_CONNECTOR_NAME
+  );
+  return import_connectors.DEFAULT_CONNECTOR_NAME;
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) {
+    return null;
+  }
+  const [users, keyUserName, strategiesKey, strategyName, configKey] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || configKey !== "config" || !strategyName) {
+    return null;
+  }
+  return strategyName;
+};
+var loadRuntimeStrategyNames = async (userName) => {
+  const keys = await (0, import_redis2.getKeys)(`${import_redis2.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => key.endsWith(":config")).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeTrades = async (userName) => {
+  const keys = await (0, import_redis2.getKeys)(import_redis2.redisKeys.runtimeTrades(userName));
+  const trades = await Promise.all(keys.map((key) => (0, import_redis2.getData)(key, null)));
+  return trades.filter(isRuntimeTradeRecord).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+var createRuntimeSignalStats = () => ({
+  evaluated: 0,
+  signals: 0,
+  reasonGroups: /* @__PURE__ */ new Map()
+});
+var mergeRuntimeSignalStats = (target, source) => {
+  target.evaluated += source.evaluated;
+  target.signals += source.signals;
+  for (const [group, reasons] of source.reasonGroups.entries()) {
+    const targetReasons = target.reasonGroups.get(group) ?? /* @__PURE__ */ new Map();
+    for (const [reason, count] of reasons.entries()) {
+      targetReasons.set(reason, (targetReasons.get(reason) ?? 0) + count);
+    }
+    target.reasonGroups.set(group, targetReasons);
+  }
+};
+var loadClosedPnlRows = async ({
+  connector,
+  startTime,
+  endTime
+}) => {
+  if (typeof connector.getClosedPnl !== "function") {
+    return [];
+  }
+  try {
+    const rows = await connector.getClosedPnl({
+      startTime,
+      endTime,
+      limit: 100
+    });
+    return rows.sort((left, right) => left.closedAt - right.closedAt);
+  } catch (error) {
+    import_logger.logger.warn(
+      "signals summary: getClosedPnl failed: %s",
+      error?.message || String(error)
+    );
+    return [];
+  }
+};
+var consumeClosedPnlMatch = (buckets, trade) => {
+  const rows = buckets.get(trade.symbol);
+  if (!rows?.length) {
+    return null;
+  }
+  const minimumClosedAt = trade.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.findIndex(
+    (row2) => Number.isFinite(row2.closedAt) && row2.closedAt >= minimumClosedAt
+  );
+  if (matchIndex < 0) {
+    return null;
+  }
+  const [row] = rows.splice(matchIndex, 1);
+  return row ?? null;
+};
+var syncRuntimeTrades = async ({
+  userName,
+  connector,
+  trades,
+  startTime,
+  endTime
+}) => {
+  const openPositions = typeof connector.getOpenPositionPnl === "function" ? await connector.getOpenPositionPnl() : [];
+  const openPositionsBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position])
+  );
+  const activeOrderIdBySymbol = /* @__PURE__ */ new Map();
+  const symbols = [...new Set(trades.map((trade) => trade.symbol))];
+  await Promise.all(
+    symbols.map(async (symbol) => {
+      const activeRef = await (0, import_redis2.getData)(
+        import_redis2.redisKeys.runtimeActiveTrade(userName, symbol),
+        null
+      );
+      activeOrderIdBySymbol.set(
+        symbol,
+        typeof activeRef?.orderId === "string" ? activeRef.orderId : null
+      );
+    })
+  );
+  const closedPnlRows = await loadClosedPnlRows({
+    connector,
+    startTime,
+    endTime
+  });
+  const closedPnlBuckets = /* @__PURE__ */ new Map();
+  for (const row of closedPnlRows) {
+    const bucket = closedPnlBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    closedPnlBuckets.set(row.symbol, bucket);
+  }
+  const syncedTrades = [];
+  for (const trade of trades) {
+    if (trade.status !== "active") {
+      syncedTrades.push(trade);
+      continue;
+    }
+    const openPosition = openPositionsBySymbol.get(trade.symbol);
+    const activeOrderId = activeOrderIdBySymbol.get(trade.symbol);
+    const isCurrentActiveTrade = activeOrderId === trade.orderId;
+    if (isCurrentActiveTrade && openPosition && openPosition.direction === trade.direction) {
+      const nextTrade2 = {
+        ...trade,
+        status: "active",
+        currentPrice: openPosition.currentPrice,
+        currentPnl: openPosition.unrealizedPnl,
+        lastSyncedAt: endTime
+      };
+      await (0, import_redis2.setData)(
+        import_redis2.redisKeys.runtimeTrade(userName, trade.orderId),
+        nextTrade2,
+        {
+          expire: 0
+        }
+      );
+      syncedTrades.push(nextTrade2);
+      continue;
+    }
+    const matchedClosedPnl = consumeClosedPnlMatch(closedPnlBuckets, trade);
+    const nextTrade = {
+      ...trade,
+      status: "closed",
+      currentPrice: matchedClosedPnl?.exitPrice ?? trade.currentPrice ?? null,
+      currentPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
+      closedPnl: matchedClosedPnl?.closedPnl ?? trade.closedPnl ?? trade.currentPnl ?? null,
+      exitPrice: matchedClosedPnl?.exitPrice ?? trade.exitPrice ?? null,
+      exitTimestamp: matchedClosedPnl?.closedAt ?? trade.exitTimestamp ?? endTime,
+      lastSyncedAt: endTime
+    };
+    await Promise.all([
+      (0, import_redis2.setData)(import_redis2.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
+        expire: import_constants.TTL_1M
+      }),
+      ...isCurrentActiveTrade ? [(0, import_redis2.delKey)(import_redis2.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
+    ]);
+    syncedTrades.push(nextTrade);
+  }
+  return syncedTrades;
+};
+var buildSummaryMessage = ({
+  hours,
+  startTime,
+  endTime,
+  configuredStrategyNames,
+  signals,
+  evaluationStatsByStrategy,
+  trades
+}) => {
+  const lines = [];
+  const statusOrder = [
+    "completed",
+    "skipped",
+    "failed",
+    "canceled",
+    "unknown"
+  ];
+  const strategyNames = /* @__PURE__ */ new Set();
+  const signalStats = /* @__PURE__ */ new Map();
+  const tradeStats = /* @__PURE__ */ new Map();
+  for (const strategyName of configuredStrategyNames) {
+    if (strategyName) {
+      strategyNames.add(strategyName);
+    }
+  }
+  for (const signal of signals) {
+    strategyNames.add(signal.strategy);
+    const stats = signalStats.get(signal.strategy) ?? /* @__PURE__ */ new Map();
+    const status = normalizeStatus(signal.orderStatus);
+    stats.set(status, (stats.get(status) ?? 0) + 1);
+    signalStats.set(signal.strategy, stats);
+  }
+  for (const trade of trades) {
+    strategyNames.add(trade.strategy);
+    const stats = tradeStats.get(trade.strategy) ?? {
+      total: 0,
+      active: 0,
+      closed: 0,
+      activePnl: 0,
+      activePnlKnown: 0,
+      closedPnl: 0,
+      closedPnlKnown: 0,
+      totalPnl: 0,
+      totalPnlKnown: 0,
+      trades: []
+    };
+    const pnl = trade.status === "active" ? trade.currentPnl : trade.closedPnl ?? trade.currentPnl;
+    const pnlText = typeof pnl === "number" && Number.isFinite(pnl) ? formatSigned(pnl) : "n/a";
+    stats.total += 1;
+    if (trade.status === "active") {
+      stats.active += 1;
+      if (typeof pnl === "number" && Number.isFinite(pnl)) {
+        stats.activePnl += pnl;
+        stats.activePnlKnown += 1;
+        stats.totalPnl += pnl;
+        stats.totalPnlKnown += 1;
+      }
+    } else {
+      stats.closed += 1;
+      if (typeof pnl === "number" && Number.isFinite(pnl)) {
+        stats.closedPnl += pnl;
+        stats.closedPnlKnown += 1;
+        stats.totalPnl += pnl;
+        stats.totalPnlKnown += 1;
+      }
+    }
+    stats.trades.push({
+      symbol: trade.symbol,
+      status: trade.status,
+      pnlText,
+      entryTimestamp: trade.entryTimestamp,
+      orderId: trade.orderId
+    });
+    tradeStats.set(trade.strategy, stats);
+  }
+  const sortedStrategies = [...strategyNames].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const totalWindowPnl = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.totalPnl,
+    0
+  );
+  const totalWindowPnlKnown = [...tradeStats.values()].reduce(
+    (sum, stats) => sum + stats.totalPnlKnown,
+    0
+  );
+  const totalWindowPnlText = totalWindowPnlKnown > 0 ? formatSigned(totalWindowPnl) : "n/a";
+  const windowPnlLabel = hours === 24 ? "24h PnL" : `${hours}h PnL`;
+  lines.push(`\u{1F4CB} <b>${escapeHtml(resolveSummaryTitle(hours))}</b>`);
+  lines.push("");
+  lines.push("\u{1F552} <b>Window</b>");
+  lines.push(
+    `<b>${escapeHtml(formatMskDateTime(startTime))} - ${escapeHtml(formatMskDateTime(endTime))} ${SUMMARY_TIMEZONE_LABEL}</b>`
+  );
+  lines.push("");
+  lines.push(`\u23F1 Range: <b>${hours}h</b>`);
+  lines.push(
+    `\u{1F4B0} <b>${windowPnlLabel}:</b> <b>${escapeHtml(totalWindowPnlText)}</b>`
+  );
+  lines.push("");
+  lines.push("\u{1F4E1} <b>Signals</b>");
+  if (!sortedStrategies.length) {
+    lines.push("\u26A0\uFE0F No runtime data for this window.");
+    return lines.join("\n");
+  }
+  const appendEvaluationDetails = (strategyName) => {
+    const evaluation = evaluationStatsByStrategy.get(strategyName);
+    if (!evaluation) {
+      return;
+    }
+    lines.push(
+      `evaluated=<b>${evaluation.evaluated}</b>, signals=<b>${evaluation.signals}</b>`
+    );
+    const sourceOrder = ["skip from core", "skip from AI", "skip from ML"];
+    const sortedReasonGroups = [...evaluation.reasonGroups.entries()].sort(
+      (left, right) => {
+        const leftOrder = sourceOrder.indexOf(left[0]);
+        const rightOrder = sourceOrder.indexOf(right[0]);
+        const normalizedLeftOrder = leftOrder >= 0 ? leftOrder : sourceOrder.length;
+        const normalizedRightOrder = rightOrder >= 0 ? rightOrder : sourceOrder.length;
+        return normalizedLeftOrder - normalizedRightOrder || left[0].localeCompare(right[0]);
+      }
+    );
+    for (const [source, reasons] of sortedReasonGroups) {
+      lines.push(`<b>${escapeHtml(source)}</b>:`);
+      const sortedReasons = [...reasons.entries()].sort(
+        (left, right) => right[1] - left[1] || left[0].localeCompare(right[0])
+      );
+      for (const [reason, count] of sortedReasons) {
+        lines.push(`${escapeHtml(reason)}: <b>${count}</b>`);
+      }
+    }
+  };
+  for (const strategyName of sortedStrategies) {
+    const stats = signalStats.get(strategyName);
+    if (!stats || stats.size === 0) {
+      const evaluation = evaluationStatsByStrategy.get(strategyName);
+      lines.push("");
+      lines.push(
+        evaluation?.evaluated ? `<b>${escapeHtml(strategyName)}</b>
+signals=<b>0</b>` : `<b>${escapeHtml(strategyName)}</b>
+none`
+      );
+      appendEvaluationDetails(strategyName);
+      continue;
+    }
+    const parts = statusOrder.map((status) => {
+      const count = stats.get(status) ?? 0;
+      return count > 0 ? `${status}=<b>${count}</b>` : null;
+    }).filter(Boolean);
+    lines.push("");
+    lines.push(`<b>${escapeHtml(strategyName)}</b>`);
+    lines.push(parts.join(", "));
+    appendEvaluationDetails(strategyName);
+  }
+  lines.push("");
+  lines.push("\u{1F4BC} <b>Trades</b>");
+  for (const strategyName of sortedStrategies) {
+    const stats = tradeStats.get(strategyName);
+    if (!stats) {
+      lines.push("");
+      lines.push(`<b>${escapeHtml(strategyName)}</b>`);
+      lines.push(`total=<b>0</b>`);
+      continue;
+    }
+    const activePnlText = stats.activePnlKnown > 0 ? formatSigned(stats.activePnl) : "n/a";
+    const closedPnlText = stats.closedPnlKnown > 0 ? formatSigned(stats.closedPnl) : "n/a";
+    const totalPnlText = stats.totalPnlKnown > 0 ? formatSigned(stats.totalPnl) : "n/a";
+    lines.push("");
+    lines.push(`<b>${escapeHtml(strategyName)}</b>`);
+    lines.push(
+      `total=<b>${stats.total}</b>, active=<b>${stats.active}</b> (PnL <b>${escapeHtml(activePnlText)}</b>)`
+    );
+    lines.push(
+      `closed=<b>${stats.closed}</b> (PnL <b>${escapeHtml(closedPnlText)}</b>), totalPnL=<b>${escapeHtml(totalPnlText)}</b>`
+    );
+    const sortedTrades = [...stats.trades].sort(
+      (left, right) => left.entryTimestamp - right.entryTimestamp || left.symbol.localeCompare(right.symbol) || left.orderId.localeCompare(right.orderId)
+    );
+    for (const trade of sortedTrades) {
+      lines.push(
+        `- ${escapeHtml(trade.symbol)}: PnL <b>${escapeHtml(trade.pnlText)}</b>, status=<b>${escapeHtml(trade.status)}</b>`
+      );
+    }
+  }
+  return lines.join("\n");
+};
+var signalsSummary = async () => {
+  const hours = Math.max(
+    1,
+    Number.parseInt(String(flags.hours ?? 24), 10) || 24
+  );
+  const endTime = Date.now();
+  const startTime = endTime - hours * 60 * 60 * 1e3;
+  const connectorName = await resolveSummaryConnectorName(flags.connector);
+  const connectorFactory = await (0, import_connectors.getConnectorCreatorByName)(
+    connectorName,
+    projectRoot
+  );
+  if (!connectorFactory) {
+    throw new Error(`Connector "${connectorName}" is not registered`);
+  }
+  const connector = await connectorFactory({
+    userName: flags.user
+  });
+  const [configuredStrategyNames, signals, evaluationStatsBuckets, trades] = await Promise.all([
+    loadRuntimeStrategyNames(flags.user),
+    loadRuntimeSignals(flags.user),
+    loadRuntimeSignalEvaluationStatsBuckets(flags.user),
+    loadRuntimeTrades(flags.user)
+  ]);
+  const syncedTrades = await syncRuntimeTrades({
+    userName: flags.user,
+    connector,
+    trades,
+    startTime,
+    endTime
+  });
+  const windowSignals = signals.filter(
+    (signal) => signal.timestamp >= startTime && signal.timestamp < endTime
+  );
+  const windowDayKeys = new Set(getRuntimeStorageDayKeys(startTime, endTime));
+  const windowEvaluationStats = /* @__PURE__ */ new Map();
+  for (const entry of evaluationStatsBuckets) {
+    if (!windowDayKeys.has(entry.dayKey)) {
+      continue;
+    }
+    const stats = windowEvaluationStats.get(entry.strategy) ?? createRuntimeSignalStats();
+    mergeRuntimeSignalStats(stats, entry.stats);
+    windowEvaluationStats.set(entry.strategy, stats);
+  }
+  const signalIds = new Set(
+    signals.map((signal) => signal.signalId).filter(Boolean)
+  );
+  const windowTrades = syncedTrades.filter(
+    (trade) => trade.entryTimestamp >= startTime && trade.entryTimestamp < endTime && trade.signalId != null && signalIds.has(trade.signalId)
+  );
+  const message = buildSummaryMessage({
+    hours,
+    startTime,
+    endTime,
+    configuredStrategyNames,
+    signals: windowSignals,
+    evaluationStatsByStrategy: windowEvaluationStats,
+    trades: windowTrades
+  });
+  const windowEvaluationsCount = [...windowEvaluationStats.values()].reduce(
+    (sum, stats) => sum + stats.evaluated,
+    0
+  );
+  import_logger.logger.info(
+    "signals summary window=%sh signals=%s evaluations=%s trades=%s connector=%s user=%s",
+    hours,
+    windowSignals.length,
+    windowEvaluationsCount,
+    windowTrades.length,
+    connectorName,
+    flags.user
+  );
+  if (flags.printOnly) {
+    console.log(message);
+    return;
+  }
+  await sendTelegramReport(message, { userName: flags.user });
+};
+if (process.env.NODE_ENV !== "test") {
+  signalsSummary().then(() => {
+    process.exit(0);
+  }).catch(() => {
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  signalsSummary
+});