@tradejs/cli 1.0.9 → 1.0.10

package/dist/lib/runtimeRedis.js

@@ -0,0 +1,157 @@
+"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/runtimeRedis.ts
+var runtimeRedis_exports = {};
+__export(runtimeRedis_exports, {
+  getRuntimeStrategyConfigKeys: () => getRuntimeStrategyConfigKeys,
+  isRuntimeStrategyEnabled: () => isRuntimeStrategyEnabled,
+  isRuntimeTradeRecord: () => isRuntimeTradeRecord,
+  loadRuntimeStrategyConfigs: () => loadRuntimeStrategyConfigs,
+  loadRuntimeStrategyNames: () => loadRuntimeStrategyNames,
+  loadRuntimeTrades: () => loadRuntimeTrades,
+  loadStrategyResultSymbols: () => loadStrategyResultSymbols,
+  resolveStrategyConfigIdentityByKey: () => resolveStrategyConfigIdentityByKey,
+  resolveStrategyNameByConfigKey: () => resolveStrategyNameByConfigKey
+});
+module.exports = __toCommonJS(runtimeRedis_exports);
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var resolveStrategyConfigIdentityByKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+var isRuntimeStrategyEnabled = (strategyConfig) => {
+  const enabled = strategyConfig.ENABLE;
+  return enabled !== false;
+};
+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" && (record.direction === "LONG" || record.direction === "SHORT");
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
+};
+var getRuntimeStrategyConfigKeys = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeStrategyNames = async (userName) => [
+  ...new Set(
+    (await getRuntimeStrategyConfigKeys(userName)).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value))
+  )
+].sort((left, right) => left.localeCompare(right));
+var loadRuntimeStrategyConfigs = async (userName, {
+  onInvalidConfig
+} = {}) => {
+  const configKeys = await getRuntimeStrategyConfigKeys(userName);
+  const strategyConfigs = await Promise.all(
+    configKeys.map(async (key) => {
+      const strategyName = resolveStrategyNameByConfigKey(userName, key);
+      const identity = resolveStrategyConfigIdentityByKey(userName, key);
+      if (!strategyName || !identity) {
+        return null;
+      }
+      const strategyConfig = await (0, import_redis.getData)(
+        key,
+        null
+      );
+      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+        onInvalidConfig?.(key);
+        return null;
+      }
+      return {
+        key,
+        strategyName,
+        configId: identity.configId,
+        strategyConfig
+      };
+    })
+  );
+  return strategyConfigs.filter(Boolean);
+};
+var loadRuntimeTrades = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
+  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
+  if (hasWindow) {
+    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+    const bucketTrades = (await Promise.all(
+      dayKeys.map(
+        (dayKey) => (0, import_redis.getHashJsonValues)(
+          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
+        )
+      )
+    )).flat();
+    const dedupedBucketTrades = /* @__PURE__ */ new Map();
+    for (const trade of bucketTrades) {
+      if (!isRuntimeTradeRecord(trade)) {
+        continue;
+      }
+      dedupedBucketTrades.set(trade.orderId, trade);
+    }
+    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+    if (windowedTrades.length > 0 || dayKeys.length === 0) {
+      return windowedTrades;
+    }
+  }
+  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
+  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
+    (key) => !key.startsWith(bucketPrefix)
+  );
+  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 loadStrategyResultSymbols = async ({
+  userName,
+  strategy
+}) => {
+  const results = await (0, import_redis.getData)(
+    import_redis.redisKeys.strategyResults(userName, strategy),
+    {}
+  );
+  return Object.keys(results ?? {}).sort(
+    (left, right) => left.localeCompare(right)
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRuntimeStrategyConfigKeys,
+  isRuntimeStrategyEnabled,
+  isRuntimeTradeRecord,
+  loadRuntimeStrategyConfigs,
+  loadRuntimeStrategyNames,
+  loadRuntimeTrades,
+  loadStrategyResultSymbols,
+  resolveStrategyConfigIdentityByKey,
+  resolveStrategyNameByConfigKey
+});

package/dist/lib/runtimeSignalsLoader.js

@@ -30,7 +30,8 @@ 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 import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
 var isRuntimeSignalBucketRef = (value) => {
   if (!value || typeof value !== "object") {
     return false;
@@ -80,8 +81,34 @@ var isRuntimeSignalEvaluationRecord = (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));
+var filterBucketKeysByWindow = (bucketKeys, prefix, startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime == null || endTime == null) {
+    return bucketKeys;
+  }
+  const allowedDayKeys = new Set((0, import_time.getRuntimeStorageDayKeys)(startTime, endTime));
+  if (!allowedDayKeys.size) {
+    return [];
+  }
+  return bucketKeys.filter((key) => {
+    const suffix = key.slice(prefix.length);
+    const firstColon = suffix.indexOf(":");
+    if (firstColon <= 0) {
+      return false;
+    }
+    return allowedDayKeys.has(suffix.slice(0, firstColon));
+  });
+};
+var loadRuntimeSignals = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis.redisKeys.runtimeSignalBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
   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(
@@ -100,9 +127,16 @@ var loadRuntimeSignals = async (userName) => {
   );
   return sortByTimestamp(payloads.filter(isSignalRecord));
 };
-var loadRuntimeSignalEvaluations = async (userName) => {
-  const bucketKeys = await (0, import_redis.getKeys)(
-    import_redis.redisKeys.runtimeSignalEvaluationBuckets(userName)
+var loadRuntimeSignalEvaluations = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis.redisKeys.runtimeSignalEvaluationBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
   );
   const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
   const deduped = /* @__PURE__ */ new Map();

package/dist/lib/runtimeSignalsStorage.js

@@ -20,42 +20,60 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/runtimeSignalsStorage.ts
 var runtimeSignalsStorage_exports = {};
 __export(runtimeSignalsStorage_exports, {
+  DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS: () => DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS,
+  RUNTIME_SIGNAL_RETENTION_DAYS_ENV: () => RUNTIME_SIGNAL_RETENTION_DAYS_ENV,
   buildRuntimeSignalStatsIncrements: () => buildRuntimeSignalStatsIncrements,
-  getRuntimeStorageDayKey: () => getRuntimeStorageDayKey,
-  getRuntimeStorageDayKeys: () => getRuntimeStorageDayKeys,
+  getRuntimeSignalRetentionTtlSeconds: () => getRuntimeSignalRetentionTtlSeconds,
+  getRuntimeStorageDayKey: () => import_time.getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys: () => import_time.getRuntimeStorageDayKeys,
   isRuntimeSignalBucketRef: () => isRuntimeSignalBucketRef,
   normalizeRuntimeSignalSkipReason: () => normalizeRuntimeSignalSkipReason,
   parseRuntimeSignalStatsBucket: () => parseRuntimeSignalStatsBucket,
   shouldStoreDetailedRuntimeSignalEvaluation: () => shouldStoreDetailedRuntimeSignalEvaluation,
-  toRuntimeSignalBucketRef: () => toRuntimeSignalBucketRef
+  shouldStoreRuntimeSignalDiagnostics: () => shouldStoreRuntimeSignalDiagnostics,
+  toRuntimeSignalBucketRef: () => toRuntimeSignalBucketRef,
+  toStoredRuntimeSignal: () => toStoredRuntimeSignal
 });
 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 [];
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var SECONDS_PER_DAY = 86400;
+var RUNTIME_SIGNAL_RETENTION_DAYS_ENV = "RUNTIME_SIGNAL_RETENTION_DAYS";
+var DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS = import_constants.TTL_3D;
+var parsePositiveNumber = (value) => {
+  if (value == null || value === "") {
+    return null;
   }
-  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));
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+var getRuntimeSignalRetentionTtlSeconds = () => {
+  const explicitDays = parsePositiveNumber(
+    process.env[RUNTIME_SIGNAL_RETENTION_DAYS_ENV]
+  );
+  if (explicitDays != null) {
+    return Math.ceil(explicitDays * SECONDS_PER_DAY);
   }
-  return keys;
+  return DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS;
 };
 var toRuntimeSignalBucketRef = (signal) => ({
   signalId: signal.signalId,
   symbol: signal.symbol,
   strategy: signal.strategy,
-  timestamp: signal.timestamp
+  timestamp: signal.timestamp,
+  ...signal.runtimeConfigId && signal.runtimeConfigId !== "config" ? { runtimeConfigId: signal.runtimeConfigId } : {}
 });
+var shouldStoreRuntimeSignalDiagnostics = (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed";
+var toStoredRuntimeSignal = (signal) => {
+  if (shouldStoreRuntimeSignalDiagnostics(signal)) {
+    return signal;
+  }
+  const stored = { ...signal };
+  delete stored.figures;
+  delete stored.indicators;
+  delete stored.additionalIndicators;
+  return stored;
+};
 var isRuntimeSignalBucketRef = (value) => {
   if (!value || typeof value !== "object") {
     return false;
@@ -151,12 +169,17 @@ var parseRuntimeSignalStatsBucket = (value) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS,
+  RUNTIME_SIGNAL_RETENTION_DAYS_ENV,
   buildRuntimeSignalStatsIncrements,
+  getRuntimeSignalRetentionTtlSeconds,
   getRuntimeStorageDayKey,
   getRuntimeStorageDayKeys,
   isRuntimeSignalBucketRef,
   normalizeRuntimeSignalSkipReason,
   parseRuntimeSignalStatsBucket,
   shouldStoreDetailedRuntimeSignalEvaluation,
-  toRuntimeSignalBucketRef
+  shouldStoreRuntimeSignalDiagnostics,
+  toRuntimeSignalBucketRef,
+  toStoredRuntimeSignal
 });

package/dist/lib/runtimeStrategyBacktest.js

@@ -0,0 +1,134 @@
+"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/lib/runtimeStrategyBacktest.ts
+var runtimeStrategyBacktest_exports = {};
+__export(runtimeStrategyBacktest_exports, {
+  BACKTEST_CLI_RUNTIME_CONFIG_KEYS: () => BACKTEST_CLI_RUNTIME_CONFIG_KEYS,
+  loadRuntimeStrategyBacktestConfigs: () => loadRuntimeStrategyBacktestConfigs,
+  toStrategyConfigGrid: () => toStrategyConfigGrid
+});
+module.exports = __toCommonJS(runtimeStrategyBacktest_exports);
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/runtimeRedis.ts
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var resolveStrategyConfigIdentityByKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+var isRuntimeStrategyEnabled = (strategyConfig) => {
+  const enabled = strategyConfig.ENABLE;
+  return enabled !== false;
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
+};
+var getRuntimeStrategyConfigKeys = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeStrategyConfigs = async (userName, {
+  onInvalidConfig
+} = {}) => {
+  const configKeys = await getRuntimeStrategyConfigKeys(userName);
+  const strategyConfigs = await Promise.all(
+    configKeys.map(async (key) => {
+      const strategyName = resolveStrategyNameByConfigKey(userName, key);
+      const identity = resolveStrategyConfigIdentityByKey(userName, key);
+      if (!strategyName || !identity) {
+        return null;
+      }
+      const strategyConfig = await (0, import_redis.getData)(
+        key,
+        null
+      );
+      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+        onInvalidConfig?.(key);
+        return null;
+      }
+      return {
+        key,
+        strategyName,
+        configId: identity.configId,
+        strategyConfig
+      };
+    })
+  );
+  return strategyConfigs.filter(Boolean);
+};
+
+// src/lib/runtimeStrategyBacktest.ts
+var BACKTEST_CLI_RUNTIME_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "ENV",
+  "INTERVAL",
+  "MAKE_ORDERS",
+  "CLOSE_OPPOSITE_POSITIONS",
+  "BACKTEST_PRICE_MODE",
+  "BACKTEST_ENTRY_DELAY_BARS"
+]);
+var toStrategyConfigGrid = (strategyConfig) => Object.fromEntries(
+  Object.entries(strategyConfig).filter(([key]) => !BACKTEST_CLI_RUNTIME_CONFIG_KEYS.has(key)).map(([key, value]) => [key, [value]])
+);
+var loadRuntimeStrategyBacktestConfigs = async (userName) => {
+  const configs = await loadRuntimeStrategyConfigs(userName, {
+    onInvalidConfig: (key) => {
+      console.log(import_chalk.default.yellow(`Skip invalid runtime strategy config: ${key}`));
+    }
+  });
+  return configs.filter(({ configId }) => configId === "config").filter(({ strategyName, strategyConfig }) => {
+    const enabled = isRuntimeStrategyEnabled(strategyConfig);
+    if (!enabled) {
+      console.log(
+        import_chalk.default.yellow(
+          `Skip inactive runtime strategy config by ENABLE=false: ${strategyName}`
+        )
+      );
+    }
+    return enabled;
+  }).map(({ strategyName, strategyConfig }) => ({
+    strategyName,
+    strategyConfig,
+    backtestConfig: toStrategyConfigGrid(strategyConfig)
+  }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACKTEST_CLI_RUNTIME_CONFIG_KEYS,
+  loadRuntimeStrategyBacktestConfigs,
+  toStrategyConfigGrid
+});