@tradejs/cli 2.0.15 → 2.0.16

package/dist/scripts/replayRuntimeEvidence.js

@@ -135,6 +135,29 @@ var loadRuntimeTrades = async (userName, {
   const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
   return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
+var loadRuntimeClosedTrades = async (userName, {
+  startTime,
+  endTime
+}) => {
+  const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+  const trades = (await Promise.all(
+    dayKeys.map(
+      (dayKey) => (0, import_redis.getHashJsonValues)(
+        import_redis.redisKeys.runtimeClosedTradeBucket(userName, dayKey)
+      )
+    )
+  )).flat();
+  const deduped = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    if (!isRuntimeTradeRecord(trade) || trade.status !== "closed" || !Number.isFinite(trade.exitTimestamp) || trade.exitTimestamp < startTime || trade.exitTimestamp >= endTime) {
+      continue;
+    }
+    deduped.set(trade.orderId, trade);
+  }
+  return [...deduped.values()].sort(
+    (left, right) => left.exitTimestamp - right.exitTimestamp
+  );
+};
 
 // src/lib/runtimeSignalsLoader.ts
 var import_redis2 = require("@tradejs/infra/redis");
@@ -299,11 +322,6 @@ var formatRuntimeDebugDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU",
   minute: "2-digit",
   hour12: false
 }).format(new Date(timestamp));
-var buildRuntimeDebugEvaluationId = ({
-  strategy,
-  symbol,
-  timestamp
-}) => `${strategy}:${symbol}:${timestamp}`;
 var filterByStrategies = (values, strategies) => {
   if (!strategies?.length) {
     return values;
@@ -319,13 +337,30 @@ var collectRuntimeDebugEvidence = async ({
 }) => {
   const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
   const dayKeySet = new Set(dayKeys);
-  const [trades, signals, evaluations, evaluationStatsBuckets, configs] = await Promise.all([
+  const [
+    entryTrades,
+    closedTrades,
+    signals,
+    evaluations,
+    evaluationStatsBuckets,
+    configs
+  ] = await Promise.all([
     loadRuntimeTrades(userName, { startTime, endTime }),
+    loadRuntimeClosedTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
     loadRuntimeStrategyConfigs(userName)
   ]);
+  const tradesByOrderId = new Map(
+    entryTrades.map((trade) => [trade.orderId, trade])
+  );
+  for (const trade of closedTrades) {
+    tradesByOrderId.set(trade.orderId, trade);
+  }
+  const trades = [...tradesByOrderId.values()].sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
   const filteredStats = evaluationStatsBuckets.filter(
     (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
   );
@@ -340,7 +375,7 @@ var collectRuntimeDebugEvidence = async ({
     )
   };
 };
-var buildRuntimeDebugReportPayload = async ({
+var buildRuntimeEvidenceReportPayload = ({
   userName,
   startTime,
   endTime,
@@ -349,159 +384,30 @@ var buildRuntimeDebugReportPayload = async ({
   trades,
   strategyConfigs,
   evaluationStatsBuckets
-}) => {
-  const signalById = new Map(
-    signals.map((signal) => [signal.signalId, signal])
-  );
-  const evaluationById = new Map(
-    evaluations.map((evaluation) => [evaluation.evaluationId, evaluation])
-  );
-  const evaluationBySignalShape = new Map(
-    evaluations.map((evaluation) => [
-      buildRuntimeDebugEvaluationId(evaluation),
-      evaluation
-    ])
-  );
-  const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
-  const debugTrades = await Promise.all(
-    trades.map(async (trade) => {
-      const signal = trade.signalId != null ? signalById.get(trade.signalId) : void 0;
-      const evaluationId = buildRuntimeDebugEvaluationId({
-        strategy: trade.strategy,
-        symbol: trade.symbol,
-        timestamp: signal?.timestamp ?? trade.entryTimestamp
-      });
-      const knownEvaluation = evaluationById.get(evaluationId) ?? evaluationBySignalShape.get(evaluationId);
-      const tradeDayKey = (0, import_time2.getRuntimeStorageDayKey)(trade.entryTimestamp);
-      const signalDayKey = signal != null ? (0, import_time2.getRuntimeStorageDayKey)(signal.timestamp) : tradeDayKey;
-      const evaluationDayKey = knownEvaluation != null ? (0, import_time2.getRuntimeStorageDayKey)(knownEvaluation.timestamp) : signalDayKey;
-      const tradeKey = import_redis3.redisKeys.runtimeTrade(userName, trade.orderId);
-      const tradeBucketKey = import_redis3.redisKeys.runtimeTradeBucket(
-        userName,
-        tradeDayKey
-      );
-      const activeTradeKey = import_redis3.redisKeys.runtimeActiveTrade(
-        userName,
-        trade.symbol,
-        trade.deploymentId ?? trade.accountId
-      );
-      const signalKey = trade.signalId != null ? import_redis3.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
-      const evaluationBucketKey = import_redis3.redisKeys.runtimeSignalEvaluationBucket(
-        userName,
-        evaluationDayKey,
-        knownEvaluation?.strategy ?? trade.strategy
-      );
-      const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
-      const evaluationKey = import_redis3.redisKeys.runtimeSignalEvaluation(
-        userName,
-        evaluationField
-      );
-      const [
-        tradeValue,
-        activeTradeValue,
-        signalValue,
-        directEvaluationValue,
-        bucketEvaluationValue
-      ] = await Promise.all([
-        (0, import_redis3.getData)(tradeKey, null),
-        (0, import_redis3.getData)(activeTradeKey, null),
-        signalKey ? (0, import_redis3.getData)(signalKey, null) : Promise.resolve(null),
-        (0, import_redis3.getData)(evaluationKey, null),
-        knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis3.getHashJsonField)(
-          evaluationBucketKey,
-          evaluationField,
-          null
-        )
-      ]);
-      const evaluationValue = directEvaluationValue ?? bucketEvaluationValue ?? knownEvaluation ?? null;
-      return {
-        redisDebug: {
-          trade: tradeKey,
-          tradeBucket: {
-            key: tradeBucketKey,
-            field: trade.orderId
-          },
-          activeTrade: activeTradeKey,
-          signal: signalKey,
-          evaluation: {
-            key: evaluationBucketKey,
-            field: evaluationField,
-            directKey: evaluationKey
-          }
-        },
-        trade,
-        redisValues: {
-          trade: tradeValue,
-          tradeBucket: trade,
-          activeTrade: activeTradeValue,
-          signal: signalValue ?? signal ?? null,
-          evaluation: evaluationValue ?? knownEvaluation ?? null
-        }
-      };
-    })
-  );
-  const linkedEvaluations = /* @__PURE__ */ new Map();
-  for (const trade of debugTrades) {
-    const evaluation = trade.redisValues.evaluation;
-    if (evaluation && typeof evaluation === "object" && "evaluationId" in evaluation && typeof evaluation.evaluationId === "string") {
-      linkedEvaluations.set(
-        evaluation.evaluationId,
-        evaluation
-      );
-    }
-  }
-  const reportEvaluations = evaluations.length > 0 ? evaluations : [...linkedEvaluations.values()];
-  return {
-    reportType: "runtime-daily-debug",
-    generatedAt: Date.now(),
-    generatedAtMsk: formatRuntimeDebugDateTime(Date.now()),
-    userName,
-    window: {
-      startTime,
-      endTime,
-      startMsk: formatRuntimeDebugDateTime(startTime),
-      endMsk: formatRuntimeDebugDateTime(endTime),
-      dayKeys
-    },
-    redisPrefixes: {
-      runtimeTrades: import_redis3.redisKeys.runtimeTrades(userName),
-      runtimeTradeBuckets: import_redis3.redisKeys.runtimeTradeBuckets(userName),
-      runtimeActiveTrades: import_redis3.redisKeys.runtimeActiveTrades(userName),
-      runtimeSignals: import_redis3.redisKeys.runtimeSignalBuckets(userName),
-      runtimeSignalEvaluations: import_redis3.redisKeys.runtimeSignalEvaluationBuckets(userName),
-      runtimeSignalEvaluationStats: import_redis3.redisKeys.runtimeSignalEvaluationStatsBuckets(userName)
-    },
-    counts: {
-      trades: trades.length,
-      signals: signals.length,
-      evaluations: reportEvaluations.length,
-      evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
-      strategyConfigs: strategyConfigs?.length ?? 0
-    },
-    trades: debugTrades,
-    signals: signals.map((signal) => ({
-      redisKey: import_redis3.redisKeys.storeSignal(signal.symbol, signal.signalId),
-      signal
-    })),
-    evaluations: reportEvaluations.map((evaluation) => ({
-      redisDebug: {
-        key: import_redis3.redisKeys.runtimeSignalEvaluationBucket(
-          userName,
-          (0, import_time2.getRuntimeStorageDayKey)(evaluation.timestamp),
-          evaluation.strategy
-        ),
-        field: evaluation.evaluationId,
-        directKey: import_redis3.redisKeys.runtimeSignalEvaluation(
-          userName,
-          evaluation.evaluationId
-        )
-      },
-      evaluation
-    })),
-    evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-    strategyConfigs: strategyConfigs ?? []
-  };
-};
+}) => ({
+  reportType: "runtime-daily-evidence",
+  generatedAt: Date.now(),
+  userName,
+  window: {
+    startTime,
+    endTime,
+    startMsk: formatRuntimeDebugDateTime(startTime),
+    endMsk: formatRuntimeDebugDateTime(endTime),
+    dayKeys: (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime)
+  },
+  counts: {
+    trades: trades.length,
+    signals: signals.length,
+    evaluations: evaluations.length,
+    evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+    strategyConfigs: strategyConfigs?.length ?? 0
+  },
+  trades: trades.map((trade) => ({ trade })),
+  signals: signals.map((signal) => ({ signal })),
+  evaluations: evaluations.map((evaluation) => ({ evaluation })),
+  evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+  strategyConfigs: strategyConfigs ?? []
+});
 
 // src/lib/replay/support.ts
 var import_chalk = __toESM(require("chalk"));
@@ -659,6 +565,7 @@ var summarizeReplayComparison = (runtimeComparison, strategies) => {
   ].sort((left, right) => left.localeCompare(right));
   return {
     mode: comparison.mode ?? null,
+    lineage: comparison.lineage ?? null,
     rows: asArray(comparison.rows).filter(
       (row) => !useFilter || strategySet.has(String(row.strategyName ?? ""))
     ),
@@ -786,7 +693,7 @@ var loadRuntimePayload = async ({
   return {
     source: "local-redis",
     path: null,
-    payload: await buildRuntimeDebugReportPayload({
+    payload: buildRuntimeEvidenceReportPayload({
       userName: flags.user,
       startTime,
       endTime,