@tradejs/cli 1.0.8 → 1.0.9

package/dist/lib/runtimeSignalsLoader.js

@@ -0,0 +1,153 @@
+"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/runtimeSignalsLoader.ts
+var runtimeSignalsLoader_exports = {};
+__export(runtimeSignalsLoader_exports, {
+  isRuntimeSignalEvaluationRecord: () => isRuntimeSignalEvaluationRecord,
+  isSignalRecord: () => isSignalRecord,
+  loadRuntimeSignalEvaluationStatsBuckets: () => loadRuntimeSignalEvaluationStatsBuckets,
+  loadRuntimeSignalEvaluations: () => loadRuntimeSignalEvaluations,
+  loadRuntimeSignals: () => loadRuntimeSignals
+});
+module.exports = __toCommonJS(runtimeSignalsLoader_exports);
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+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 isRuntimeSignalEvaluationRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
+};
+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 loadRuntimeSignalEvaluations = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(
+    import_redis.redisKeys.runtimeSignalEvaluationBuckets(userName)
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    deduped.set(evaluation.evaluationId, evaluation);
+  }
+  return sortByTimestamp([...deduped.values()]);
+};
+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);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRuntimeSignalEvaluationRecord,
+  isSignalRecord,
+  loadRuntimeSignalEvaluationStatsBuckets,
+  loadRuntimeSignalEvaluations,
+  loadRuntimeSignals
+});

package/dist/lib/runtimeSignalsStorage.js

@@ -0,0 +1,162 @@
+"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/runtimeSignalsStorage.ts
+var runtimeSignalsStorage_exports = {};
+__export(runtimeSignalsStorage_exports, {
+  buildRuntimeSignalStatsIncrements: () => buildRuntimeSignalStatsIncrements,
+  getRuntimeStorageDayKey: () => getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys: () => getRuntimeStorageDayKeys,
+  isRuntimeSignalBucketRef: () => isRuntimeSignalBucketRef,
+  normalizeRuntimeSignalSkipReason: () => normalizeRuntimeSignalSkipReason,
+  parseRuntimeSignalStatsBucket: () => parseRuntimeSignalStatsBucket,
+  shouldStoreDetailedRuntimeSignalEvaluation: () => shouldStoreDetailedRuntimeSignalEvaluation,
+  toRuntimeSignalBucketRef: () => toRuntimeSignalBucketRef
+});
+module.exports = __toCommonJS(runtimeSignalsStorage_exports);
+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 getRuntimeStorageDayKey = (timestamp) => toIsoDayKey(toRuntimeStorageDayTimestamp(timestamp));
+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 toRuntimeSignalBucketRef = (signal) => ({
+  signalId: signal.signalId,
+  symbol: signal.symbol,
+  strategy: signal.strategy,
+  timestamp: signal.timestamp
+});
+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 normalizeRuntimeSignalSkipReason = (reason, fallbackSource) => {
+  let source = fallbackSource;
+  let normalizedReason = reason;
+  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
+    source = "AI";
+    normalizedReason = "MIN_AI_QUALITY";
+  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
+    source = "AI";
+    normalizedReason = "QUALITY_UNAVAILABLE";
+  } else if (reason === "ML_RESULT_UNAVAILABLE") {
+    source = "ML";
+    normalizedReason = "RESULT_UNAVAILABLE";
+  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
+    source = "ML";
+    normalizedReason = "ML_THRESHOLD";
+  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
+    source = "hook";
+    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
+      "HOOK_BEFORE_ENTRY_GATE:".length
+    )}`;
+  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
+    source = "hook";
+    normalizedReason = "BEFORE_ENTRY_GATE";
+  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
+    source = "policy";
+  }
+  return {
+    source: `skip from ${source}`,
+    reason: normalizedReason
+  };
+};
+var buildStatsReasonField = (source, reason) => `reason:${source}:${reason}`;
+var buildRuntimeSignalStatsIncrements = (evaluation) => {
+  const increments = {
+    evaluated: 1
+  };
+  if (evaluation.status === "signal") {
+    increments.signals = 1;
+  }
+  let skipReason = null;
+  let fallbackSource = "core";
+  if (evaluation.status === "skip") {
+    skipReason = evaluation.reason || "NO_SIGNAL";
+    fallbackSource = "core";
+  } else if (evaluation.status === "signal" && (evaluation.orderStatus === "skipped" || evaluation.orderStatus === "canceled")) {
+    skipReason = evaluation.orderSkipReason || evaluation.reason || `orderStatus=${evaluation.orderStatus}`;
+    fallbackSource = "runtime";
+  } else if (evaluation.status === "error") {
+    skipReason = evaluation.reason || "EVALUATION_ERROR";
+    fallbackSource = "runtime";
+  }
+  if (skipReason) {
+    const normalized = normalizeRuntimeSignalSkipReason(
+      skipReason,
+      fallbackSource
+    );
+    increments[buildStatsReasonField(normalized.source, normalized.reason)] = 1;
+  }
+  return increments;
+};
+var shouldStoreDetailedRuntimeSignalEvaluation = (evaluation) => evaluation.status !== "skip";
+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
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRuntimeSignalStatsIncrements,
+  getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys,
+  isRuntimeSignalBucketRef,
+  normalizeRuntimeSignalSkipReason,
+  parseRuntimeSignalStatsBucket,
+  shouldStoreDetailedRuntimeSignalEvaluation,
+  toRuntimeSignalBucketRef
+});

package/dist/scripts/agentRun.js

@@ -5,6 +5,10 @@ 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))
@@ -21,8 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/scripts/agentRun.ts
+var agentRun_exports = {};
+__export(agentRun_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(agentRun_exports);
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 var import_promises = __toESM(require("fs/promises"));
@@ -893,3 +903,7 @@ if (require.main === module) {
     process.exit(1);
   });
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/dist/scripts/researchAuto.js

@@ -37,6 +37,7 @@ __export(researchAuto_exports, {
   getBacktestResultsPrefix: () => getBacktestResultsPrefix,
   listMergedFiles: () => listMergedFiles,
   listRuntimeStrategyNames: () => listRuntimeStrategyNames,
+  main: () => main,
   parseJsonOutput: () => parseJsonOutput,
   resolveStrategyNameByConfigKey: () => resolveStrategyNameByConfigKey,
   resolveTarget: () => resolveTarget,
@@ -330,7 +331,7 @@ var runCliCommand = async (params) => {
   return new Promise((resolve, reject) => {
     const child = (0, import_node_child_process.spawn)(
       "bash",
-      ["./bin/run-cli-dist.sh", params.command, ...params.args],
+      ["./bin/run-cli-runtime.sh", params.command, ...params.args],
       {
         cwd: projectRoot,
         env,
@@ -836,6 +837,7 @@ if (require.main === module) {
   getBacktestResultsPrefix,
   listMergedFiles,
   listRuntimeStrategyNames,
+  main,
   parseJsonOutput,
   resolveStrategyNameByConfigKey,
   resolveTarget,

package/dist/scripts/runtimeParity.js

@@ -42,7 +42,7 @@ var import_connectors = require("@tradejs/connectors");
 var import_constants = require("@tradejs/core/constants");
 var import_time = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
-var import_redis = require("@tradejs/infra/redis");
+var import_redis2 = require("@tradejs/infra/redis");
 var import_cli2 = require("@tradejs/node/cli");
 var import_backtest = require("@tradejs/node/backtest");
 var import_connectors2 = require("@tradejs/node/connectors");
@@ -257,6 +257,67 @@ var normalizeCliArgv = (argv, legacyFlagMap) => argv.map((arg) => {
   return `${normalizedFlag}=${rest.join("=")}`;
 });
 
+// src/lib/runtimeSignalsLoader.ts
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+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";
+};
+
+// 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 isRuntimeSignalEvaluationRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
+};
+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 loadRuntimeSignalEvaluations = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(
+    import_redis.redisKeys.runtimeSignalEvaluationBuckets(userName)
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    deduped.set(evaluation.evaluationId, evaluation);
+  }
+  return sortByTimestamp([...deduped.values()]);
+};
+
 // src/lib/telegramReports.ts
 var import_cli = require("@tradejs/node/cli");
 var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
@@ -497,20 +558,6 @@ var isRuntimeTradeRecord = (value) => {
   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" && (record.direction === "LONG" || record.direction === "SHORT");
 };
-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" && (record.direction === "LONG" || record.direction === "SHORT");
-};
-var isRuntimeSignalEvaluationRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
-};
 var resolveParityConnectorName = async (value) => {
   const connectorName = await (0, import_connectors2.resolveConnectorName)(value, projectRoot);
   if (connectorName) {
@@ -524,20 +571,10 @@ var resolveParityConnectorName = async (value) => {
   return import_connectors2.DEFAULT_CONNECTOR_NAME;
 };
 var loadRuntimeTrades = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeTrades(userName));
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  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 loadRuntimeSignals = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignals(userName));
-  const signals = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return signals.filter(isSignalRecord).sort((left, right) => left.timestamp - right.timestamp);
-};
-var loadRuntimeSignalEvaluations = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalEvaluations(userName));
-  const evaluations = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return evaluations.filter(isRuntimeSignalEvaluationRecord).sort((left, right) => left.timestamp - right.timestamp);
-};
 var resolveStrategyNameByConfigKey = (userName, key) => {
   const parts = key.split(":");
   if (parts.length !== 5) {
@@ -550,15 +587,15 @@ var resolveStrategyNameByConfigKey = (userName, key) => {
   return strategyName;
 };
 var loadConfiguredStrategyNames = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(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 loadStrategyResultSymbols = async ({
   userName,
   strategy
 }) => {
-  const results = await (0, import_redis.getData)(
-    import_redis.redisKeys.strategyResults(userName, strategy),
+  const results = await (0, import_redis2.getData)(
+    import_redis2.redisKeys.strategyResults(userName, strategy),
     {}
   );
   return Object.keys(results ?? {}).sort(
@@ -709,8 +746,8 @@ var buildReplayConfig = async ({
   toleranceMs
 }) => {
   const [userConfig, strategyResults] = await Promise.all([
-    (0, import_redis.getData)(import_redis.redisKeys.strategyConfig(userName, strategy), {}),
-    (0, import_redis.getData)(import_redis.redisKeys.strategyResults(userName, strategy), {})
+    (0, import_redis2.getData)(import_redis2.redisKeys.strategyConfig(userName, strategy), {}),
+    (0, import_redis2.getData)(import_redis2.redisKeys.strategyResults(userName, strategy), {})
   ]);
   const typedResults = strategyResults ?? {};
   const symbolResult = typedResults?.[symbol];