@tradejs/cli 3.1.8 → 3.1.9-beta.214

package/dist/lib/runEnvironment.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/runEnvironment.ts
 var runEnvironment_exports = {};
 __export(runEnvironment_exports, {
+  loadDeploymentReplayStrategies: () => loadDeploymentReplayStrategies,
   loadReplayStrategies: () => loadReplayStrategies,
   prepareRunEnvironment: () => prepareRunEnvironment,
   resolveBacktestExecutionPreloadInterval: () => resolveBacktestExecutionPreloadInterval
@@ -40,6 +41,54 @@ var import_connectors3 = require("@tradejs/node/connectors");
 var import_cli3 = require("@tradejs/node/cli");
 var import_constants = require("@tradejs/core/constants");
 var import_time2 = require("@tradejs/core/time");
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+
+// src/lib/runtimeStrategyBacktest.ts
+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 import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
+var isRuntimeStrategyEnabled = (strategyConfig) => {
+  const enabled = strategyConfig.ENABLE;
+  return enabled !== false;
+};
+
+// 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 (0, import_runtimeStrategyConfigs.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)
+  }));
+};
 
 // src/lib/timeWindow.ts
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
@@ -143,53 +192,6 @@ var resolveTimeWindow = ({
   );
 };
 
-// src/lib/runtimeStrategyBacktest.ts
-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 import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
-var isRuntimeStrategyEnabled = (strategyConfig) => {
-  const enabled = strategyConfig.ENABLE;
-  return enabled !== false;
-};
-
-// 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 (0, import_runtimeStrategyConfigs.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)
-  }));
-};
-
 // src/lib/runFormatting.ts
 var import_date_fns = require("date-fns");
 var ListIt = require("list-it");
@@ -490,10 +492,47 @@ var loadReplayStrategies = async (userName) => {
         `No active runtime strategy configs found by users:${userName}:strategies:*:config`
       )
     );
-    return [];
   }
   return runtimeStrategies;
 };
+var loadDeploymentReplayStrategies = async ({
+  userName,
+  projectRoot,
+  deploymentId
+}) => {
+  const [deployment, runtimeStrategies] = await Promise.all([
+    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot, deploymentId }),
+    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot, deploymentId })
+  ]);
+  if (!deployment) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  const strategies = deployment.enabled ? runtimeStrategies.filter((strategy) => strategy.enabled).map(
+    ({
+      strategyName,
+      version,
+      strategyPackage,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      sourceStrategyConfig
+    }) => ({
+      strategyName,
+      version,
+      strategyPackage,
+      strategyPackageVersion,
+      runtimePackageVersion,
+      strategyConfig: sourceStrategyConfig
+    })
+  ) : [];
+  if (!strategies.length) {
+    console.log(
+      import_chalk3.default.yellow(
+        `No enabled strategies found in runtime deployment ${deploymentId}`
+      )
+    );
+  }
+  return { deployment, strategies };
+};
 var prepareRunEnvironment = async ({
   connector,
   userName,
@@ -638,6 +677,7 @@ var prepareRunEnvironment = async ({
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  loadDeploymentReplayStrategies,
   loadReplayStrategies,
   prepareRunEnvironment,
   resolveBacktestExecutionPreloadInterval

package/dist/lib/runtimeDebugEvidence.js

@@ -220,18 +220,39 @@ var loadRuntimeSignalEvaluations = async (userName, {
   }
   return sortByTimestamp([...deduped.values()]);
 };
+var loadRuntimeLineageScopes = async (userName, {
+  startTime,
+  endTime
+}) => {
+  const records = (await Promise.all(
+    (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime).map(
+      (dayKey) => (0, import_redis2.getHashJsonValues)(
+        import_redis2.redisKeys.runtimeLineageScopeBucket(userName, dayKey)
+      )
+    )
+  )).flat().filter(
+    (record) => record != null && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.firstTimestamp === "number" && typeof record.lastTimestamp === "number" && record.lineage != null
+  );
+  return records.sort(
+    (left, right) => left.firstTimestamp - right.firstTimestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol)
+  );
+};
 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) {
+  const parts = suffix.split(":");
+  if (parts.length < 2 || parts.some((part) => !part)) {
     return null;
   }
+  const [dayKey, ...scopeParts] = parts;
+  const strategy = scopeParts.at(-1);
+  if (!dayKey || !strategy) return null;
   return {
-    dayKey: suffix.slice(0, firstColon),
-    strategy: suffix.slice(firstColon + 1)
+    dayKey,
+    ...scopeParts.length > 1 ? { deploymentId: scopeParts.slice(0, -1).join(":") } : {},
+    strategy
   };
 };
 var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
@@ -293,7 +314,8 @@ var collectRuntimeDebugEvidence = async ({
   userName,
   startTime,
   endTime,
-  strategies
+  strategies,
+  deploymentId
 }) => {
   const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
   const dayKeySet = new Set(dayKeys);
@@ -303,6 +325,7 @@ var collectRuntimeDebugEvidence = async ({
     signals,
     evaluations,
     evaluationStatsBuckets,
+    lineageScopes,
     configs
   ] = await Promise.all([
     loadRuntimeTrades(userName, { startTime, endTime }),
@@ -310,6 +333,7 @@ var collectRuntimeDebugEvidence = async ({
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
+    loadRuntimeLineageScopes(userName, { startTime, endTime }),
     (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName)
   ]);
   const tradesByOrderId = new Map(
@@ -322,15 +346,21 @@ var collectRuntimeDebugEvidence = async ({
     (left, right) => left.entryTimestamp - right.entryTimestamp
   );
   const filteredStats = evaluationStatsBuckets.filter(
-    (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
+    (entry) => dayKeySet.has(entry.dayKey) && (!deploymentId || entry.deploymentId === deploymentId) && (!strategies?.length || strategies.includes(entry.strategy))
   );
+  const matchesDeployment = (value) => !deploymentId || value.deploymentId === deploymentId;
   return {
     dayKeys,
-    trades: filterByStrategies(trades, strategies),
-    signals: filterByStrategies(signals, strategies),
-    evaluations: filterByStrategies(evaluations, strategies),
+    trades: filterByStrategies(trades, strategies).filter(matchesDeployment),
+    signals: filterByStrategies(signals, strategies).filter(matchesDeployment),
+    evaluations: filterByStrategies(evaluations, strategies).filter(
+      matchesDeployment
+    ),
     evaluationStatsBuckets: filteredStats,
-    strategyConfigs: configs.filter(
+    lineageScopes: lineageScopes.filter(matchesDeployment).filter(
+      (scope) => !strategies?.length || strategies.includes(scope.strategy)
+    ),
+    strategyConfigs: deploymentId ? [] : configs.filter(
       (config) => !strategies?.length || strategies.includes(config.strategyName)
     )
   };
@@ -343,7 +373,8 @@ var buildRuntimeDebugReportPayload = async ({
   evaluations,
   trades,
   strategyConfigs,
-  evaluationStatsBuckets
+  evaluationStatsBuckets,
+  lineageScopes
 }) => {
   const signalById = new Map(
     signals.map((signal) => [signal.signalId, signal])
@@ -471,6 +502,7 @@ var buildRuntimeDebugReportPayload = async ({
       signals: signals.length,
       evaluations: reportEvaluations.length,
       evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+      lineageScopes: lineageScopes?.length ?? 0,
       strategyConfigs: strategyConfigs?.length ?? 0
     },
     trades: debugTrades,
@@ -494,6 +526,7 @@ var buildRuntimeDebugReportPayload = async ({
       evaluation
     })),
     evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+    lineageScopes: lineageScopes ?? [],
     strategyConfigs: strategyConfigs ?? []
   };
 };
@@ -505,7 +538,8 @@ var buildRuntimeEvidenceReportPayload = ({
   evaluations,
   trades,
   strategyConfigs,
-  evaluationStatsBuckets
+  evaluationStatsBuckets,
+  lineageScopes
 }) => ({
   reportType: "runtime-daily-evidence",
   generatedAt: Date.now(),
@@ -522,12 +556,14 @@ var buildRuntimeEvidenceReportPayload = ({
     signals: signals.length,
     evaluations: evaluations.length,
     evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+    lineageScopes: lineageScopes?.length ?? 0,
     strategyConfigs: strategyConfigs?.length ?? 0
   },
   trades: trades.map((trade) => ({ trade })),
   signals: signals.map((signal) => ({ signal })),
   evaluations: evaluations.map((evaluation) => ({ evaluation })),
   evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+  lineageScopes: lineageScopes ?? [],
   strategyConfigs: strategyConfigs ?? []
 });
 var buildRuntimeDebugReportAttachment = async (params) => {

package/dist/lib/runtimeEvidenceDeployment.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/runtimeEvidenceDeployment.ts
+var runtimeEvidenceDeployment_exports = {};
+__export(runtimeEvidenceDeployment_exports, {
+  activeRuntimeEvidenceStrategies: () => activeRuntimeEvidenceStrategies,
+  parseRuntimeEvidenceDeploymentSnapshot: () => parseRuntimeEvidenceDeploymentSnapshot,
+  resolveRuntimeEvidenceDeploymentSnapshot: () => resolveRuntimeEvidenceDeploymentSnapshot,
+  runtimeDeploymentFromEvidence: () => runtimeDeploymentFromEvidence
+});
+module.exports = __toCommonJS(runtimeEvidenceDeployment_exports);
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var INTERVALS = /* @__PURE__ */ new Set([
+  "1",
+  "3",
+  "5",
+  "15",
+  "30",
+  "60",
+  "120",
+  "240",
+  "360",
+  "720",
+  "D",
+  "W",
+  "M"
+]);
+var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
+var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
+  if (!isRecord(value) || value.schemaVersion !== 1 || !isNonEmptyString(value.id) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
+    throw new Error(
+      "Runtime evidence deployment snapshot is missing or invalid"
+    );
+  }
+  const strategies = value.strategies.map((candidate) => {
+    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !Number.isSafeInteger(candidate.version) || Number(candidate.version) <= 0 || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig)) {
+      throw new Error(
+        "Runtime evidence deployment strategy snapshot is invalid"
+      );
+    }
+    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
+      throw new Error(
+        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
+      );
+    }
+    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
+      throw new Error(
+        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
+      );
+    }
+    return candidate;
+  });
+  const identities = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (identities.has(strategy.strategyName)) {
+      throw new Error(
+        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
+      );
+    }
+    identities.add(strategy.strategyName);
+  }
+  return {
+    ...value,
+    strategies
+  };
+};
+var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
+var runtimeDeploymentFromEvidence = (deployment) => ({
+  id: deployment.id,
+  label: deployment.label,
+  connectorName: deployment.connectorName,
+  provider: deployment.provider,
+  accountId: deployment.accountId,
+  enabled: deployment.enabled,
+  strategies: deployment.strategies.map(
+    ({ strategyName, version, enabled, controlState }) => ({
+      strategyName,
+      version,
+      enabled,
+      controlState
+    })
+  ),
+  ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+  ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+});
+var resolveRuntimeEvidenceDeploymentSnapshot = async ({
+  userName,
+  projectRoot,
+  deploymentId
+}) => {
+  const [deployment, strategies] = await Promise.all([
+    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot, deploymentId }),
+    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot, deploymentId })
+  ]);
+  if (!deployment) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  return {
+    schemaVersion: 1,
+    id: deployment.id,
+    label: deployment.label,
+    connectorName: deployment.connectorName,
+    provider: deployment.provider,
+    accountId: deployment.accountId,
+    enabled: deployment.enabled,
+    strategies: strategies.map(
+      ({
+        strategyName,
+        version,
+        enabled,
+        controlState,
+        interval,
+        universe,
+        accountId,
+        strategyPackage,
+        strategyPackageVersion,
+        runtimePackageVersion,
+        sourceStrategyConfig
+      }) => ({
+        strategyName,
+        version,
+        enabled,
+        controlState,
+        interval,
+        universe,
+        ...accountId ? { accountId } : {},
+        strategyPackage,
+        strategyPackageVersion,
+        runtimePackageVersion,
+        strategyConfig: sourceStrategyConfig
+      })
+    ),
+    ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
+    ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activeRuntimeEvidenceStrategies,
+  parseRuntimeEvidenceDeploymentSnapshot,
+  resolveRuntimeEvidenceDeploymentSnapshot,
+  runtimeDeploymentFromEvidence
+});

package/dist/lib/runtimeLineage.js

@@ -34,6 +34,7 @@ __export(runtimeLineage_exports, {
   fingerprintRuntimeValue: () => fingerprintRuntimeValue,
   resetRuntimeLineageCachesForTests: () => resetRuntimeLineageCachesForTests,
   runtimeLineageKey: () => runtimeLineageKey,
+  runtimeLineagesComparable: () => runtimeLineagesComparable,
   runtimeLineagesMatch: () => runtimeLineagesMatch
 });
 module.exports = __toCommonJS(runtimeLineage_exports);
@@ -330,7 +331,12 @@ async function buildRuntimeLineage({
     maxLossValue: resolveRuntimeMaxLossValue(config)
   };
 }
-var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.version].join(":") : [
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? [
+  "v2",
+  lineage.version,
+  lineage.strategyPackageVersion ?? "strategy:unknown",
+  lineage.runtimePackageVersion ?? "runtime:unknown"
+].join(":") : [
   lineage.schemaVersion,
   lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",
@@ -340,6 +346,7 @@ var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineag
   lineage.contextFingerprint
 ].join(":");
 var runtimeLineagesMatch = (left, right) => left != null && right != null && runtimeLineageKey(left) === runtimeLineageKey(right);
+var runtimeLineagesComparable = (left, right) => runtimeLineagesMatch(left, right) && typeof left?.maxLossValue === "number" && Number.isFinite(left.maxLossValue) && typeof right?.maxLossValue === "number" && Number.isFinite(right.maxLossValue) && left.maxLossValue === right.maxLossValue;
 var resetRuntimeLineageCachesForTests = () => {
   gitLineageCache.clear();
   gateFingerprintCache.clear();
@@ -352,5 +359,6 @@ var resetRuntimeLineageCachesForTests = () => {
   fingerprintRuntimeValue,
   resetRuntimeLineageCachesForTests,
   runtimeLineageKey,
+  runtimeLineagesComparable,
   runtimeLineagesMatch
 });