@tradejs/cli 3.1.29-beta.291 → 3.1.29-beta.296

package/dist/scripts/backtest.js

@@ -30,7 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/scripts/backtest.ts
 var backtest_exports = {};
 __export(backtest_exports, {
-  BACKTEST_PRELOAD_DAYS: () => import_constants6.BACKTEST_PRELOAD_DAYS,
+  BACKTEST_PRELOAD_DAYS: () => import_constants7.BACKTEST_PRELOAD_DAYS,
   backtest: () => backtest,
   chunkTestSuiteBySymbol: () => chunkTestSuiteBySymbol,
   interval: () => interval,
@@ -62,8 +62,8 @@ var import_chalk10 = __toESM(require("chalk"));
 var import_backtest3 = require("@tradejs/core/backtest");
 var import_grid = require("@tradejs/core/grid");
 var import_data = require("@tradejs/core/data");
-var import_redis5 = require("@tradejs/infra/redis");
-var import_constants6 = require("@tradejs/core/constants");
+var import_redis6 = require("@tradejs/infra/redis");
+var import_constants7 = require("@tradejs/core/constants");
 
 // src/lib/backtest/jevOptions.ts
 var import_promises = __toESM(require("fs/promises"));
@@ -491,13 +491,12 @@ var getReferenceSymbols = () => {
 };
 var intervalToMarketFeatureInterval = (interval2) => {
   const normalized = String(interval2).trim().toLowerCase();
-  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "1" || normalized === "1m") return null;
   if (normalized === "5" || normalized === "5m") return "5m";
   if (normalized === "60" || normalized === "1h") return "1h";
   return "15m";
 };
 var marketIntervalToConnectorInterval = (interval2) => {
-  if (interval2 === "1m") return "1";
   if (interval2 === "5m") return "5";
   if (interval2 === "1h") return "60";
   return "15";
@@ -662,6 +661,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     return skippedBackfillResult();
   }
   const interval2 = intervalToMarketFeatureInterval(params.interval);
+  if (interval2 === null) return skippedBackfillResult();
   const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval2];
   const { breadthStartMs, tradeFlowStartMs, endMs } = resolveBinanceMarketContextBackfillWindow(params);
   if (endMs <= Math.min(breadthStartMs, tradeFlowStartMs)) {
@@ -2242,7 +2242,7 @@ var coinMarketCapFetch = async (params) => {
 };
 var fetchCoinMarketCapIndexRows = async (params) => {
   const rows = [];
-  const maxChunkDays = 9;
+  const maxChunkDays = 4;
   const totalChunks = Math.max(
     1,
     Math.ceil(
@@ -4777,7 +4777,9 @@ var executeBacktestWorkerPool = async ({
   chunkTestSuite,
   getProgressSnapshot,
   initialCompletedTests = 0,
-  totalTests
+  totalTests,
+  onProgress,
+  onIncomplete
 }) => {
   const chunks = chunkTestSuite(testSuite);
   const fastAiWorkerPgPoolMax = resolveFastAiWorkerPgPoolMax(
@@ -4793,7 +4795,9 @@ var executeBacktestWorkerPool = async ({
   );
   let completedTests = initialCompletedTests;
   let renderedTests = 0;
+  let pendingResults = 0;
   let isFinishing = false;
+  let isInterrupted = false;
   let signalHandlersRemoved = false;
   const workers = /* @__PURE__ */ new Set();
   const stopWorkers = () => {
@@ -4804,6 +4808,7 @@ var executeBacktestWorkerPool = async ({
     }
   };
   const handleInterrupt = (signal, exitCode) => {
+    isInterrupted = true;
     stopWorkers();
     void Promise.resolve(onInterrupt?.(signal)).catch((error) => {
       console.error(
@@ -4824,15 +4829,16 @@ var executeBacktestWorkerPool = async ({
     process.removeListener("SIGTERM", handleSigterm);
   };
   const maybeFinish = async () => {
-    if (isFinishing) {
-      return;
-    }
-    if (completedTests !== totalExpectedTests || workers.size > 0) {
+    if (isFinishing || isInterrupted || workers.size > 0 || pendingResults > 0) {
       return;
     }
     isFinishing = true;
     try {
-      await onFinish();
+      if (completedTests === totalExpectedTests) {
+        await onFinish();
+      } else {
+        await onIncomplete?.();
+      }
     } finally {
       cleanupSignalHandlers();
     }
@@ -4891,14 +4897,22 @@ var executeBacktestWorkerPool = async ({
         return;
       }
       completedTests++;
-      await onMessage(msg);
-      if (completedTests % progressStep2 === 0 || completedTests === totalExpectedTests) {
-        tickProgress();
+      onProgress?.(completedTests);
+      pendingResults++;
+      try {
+        await onMessage(msg);
+        if (completedTests % progressStep2 === 0 || completedTests === totalExpectedTests) {
+          tickProgress();
+        }
+      } finally {
+        pendingResults--;
       }
+      await maybeFinish();
     });
     tester.on("error", (err) => {
       workers.delete(tester);
       onWorkerError(err?.message ?? String(err));
+      void maybeFinish();
     });
     tester.on("exit", (code) => {
       workers.delete(tester);
@@ -5285,7 +5299,9 @@ var executeTestSuite = async ({
   onFinish,
   initialCompletedTests = 0,
   totalTests,
-  backtestRunId
+  backtestRunId,
+  onProgress,
+  onIncomplete
 }) => {
   markTestsStarted();
   const { testerWorkerPath, testerNeedsTsRuntime } = resolveTesterWorker();
@@ -5309,6 +5325,8 @@ var executeTestSuite = async ({
     chunkTestSuite: (suite) => chunkTestSuiteBySymbol(suite, effectiveParallel),
     initialCompletedTests,
     totalTests,
+    onProgress,
+    onIncomplete,
     onInterrupt,
     onMessage: async (msg) => {
       if (msg.error) {
@@ -5362,6 +5380,106 @@ var printRunOutro = () => {
   console.log("");
 };
 
+// src/lib/backtest/observeRun.ts
+var import_constants6 = require("@tradejs/core/constants");
+var import_redis5 = require("@tradejs/infra/redis");
+var import_logger = require("@tradejs/infra/logger");
+var HEARTBEAT_MS = 2e3;
+var ACTIVE_TTL_SECONDS = 30;
+var LINKED_RUN_TTL_SECONDS = 30 * 24 * import_constants6.TTL_1H;
+var RESEARCH_STUDY = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\/\d{4}-\d{2}-\d{2}-[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/;
+var MAX_VALUES_PER_PARAMETER = 12;
+var MAX_VALUE_LENGTH = 500;
+var summarizeBacktestParameters = (tests) => {
+  const parameters = /* @__PURE__ */ new Map();
+  for (const test of tests) {
+    for (const [name, value] of Object.entries(test.strategyConfig)) {
+      const serialized = JSON.stringify(value);
+      if (serialized === void 0) continue;
+      const parameter = parameters.get(name) ?? {
+        values: /* @__PURE__ */ new Set(),
+        truncated: false
+      };
+      parameters.set(name, parameter);
+      if (parameter.values.has(serialized)) continue;
+      if (parameter.values.size === MAX_VALUES_PER_PARAMETER || serialized.length > MAX_VALUE_LENGTH) {
+        parameter.truncated = true;
+      } else {
+        parameter.values.add(serialized);
+      }
+    }
+  }
+  return [...parameters].map(([name, { values, truncated }]) => ({
+    name,
+    values: [...values],
+    truncated
+  }));
+};
+var observeBacktestRun = async (manifest, initialCompleted, parallel) => {
+  if (process.env.TRADEJS_BACKTEST_WEB_JOB === "1") return;
+  const researchStudy = process.env.TRADEJS_RESEARCH_STUDY?.trim();
+  const linkedStudy = researchStudy && RESEARCH_STUDY.test(researchStudy) ? researchStudy : void 0;
+  if (researchStudy && !linkedStudy) {
+    import_logger.logger.warn(
+      "invalid TRADEJS_RESEARCH_STUDY; expected Strategy/YYYY-MM-DD-slug"
+    );
+  }
+  const { testSuite } = manifest;
+  const firstTest = testSuite[0];
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const run = {
+    id: manifest.runId,
+    ...linkedStudy && { researchStudy: linkedStudy },
+    userName: manifest.userName,
+    strategyName: firstTest.strategyName,
+    configId: manifest.config,
+    connector: manifest.connectorName,
+    interval: manifest.interval,
+    startTime: manifest.window.start,
+    endTime: manifest.window.end,
+    symbols: [...new Set(testSuite.map((test) => test.symbol))],
+    settings: {
+      ...manifest.flags,
+      parallel,
+      ...firstTest.executionCosts && {
+        executionCosts: JSON.stringify(firstTest.executionCosts)
+      }
+    },
+    parameters: summarizeBacktestParameters(testSuite),
+    status: "running",
+    completed: initialCompleted,
+    total: testSuite.length,
+    startedAt,
+    updatedAt: startedAt
+  };
+  const save = async (expire) => {
+    run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      await import_redis5.cliBacktestRunStorage.put(run, expire);
+    } catch (error) {
+      import_logger.logger.warn("failed to publish CLI backtest progress: %s", String(error));
+    }
+  };
+  await save(ACTIVE_TTL_SECONDS);
+  let pending;
+  const timer = setInterval(() => {
+    pending ??= save(ACTIVE_TTL_SECONDS).finally(() => {
+      pending = void 0;
+    });
+  }, HEARTBEAT_MS).unref();
+  return {
+    progress: (completed) => {
+      run.completed = completed;
+    },
+    finish: async (status) => {
+      clearInterval(timer);
+      await pending;
+      run.status = status;
+      await save(linkedStudy ? LINKED_RUN_TTL_SECONDS : import_constants6.TTL_1H);
+    }
+  };
+};
+
 // src/scripts/backtest.ts
 if (process.argv.some(
   (arg) => arg === "--live" || String(arg).startsWith("--live=")
@@ -5497,8 +5615,8 @@ var loadBacktestConfig = async () => {
   if (!strategyName) {
     throw new Error("Strategy name not found");
   }
-  const backtestConfig = await (0, import_redis5.getData)(
-    import_redis5.redisKeys.backtestConfig(userName, flags.config),
+  const backtestConfig = await (0, import_redis6.getData)(
+    import_redis6.redisKeys.backtestConfig(userName, flags.config),
     null
   );
   if (!backtestConfig) {
@@ -5645,8 +5763,8 @@ var finishBacktest = async (testSuite) => {
   console.log(import_chalk10.default.gray(`full report: ${markdownReportPath}`));
   console.log("");
   if (!isFastMode || flags.persistResults) {
-    await (0, import_redis5.setData)(
-      import_redis5.redisKeys.backtestResults(userName, flags.config, timestamp),
+    await (0, import_redis6.setData)(
+      import_redis6.redisKeys.backtestResults(userName, flags.config, timestamp),
       {
         config: flags.config,
         mode: "config",
@@ -5666,11 +5784,10 @@ var finishBacktest = async (testSuite) => {
         errorTests: errorTests2
       },
       {
-        expire: import_constants6.TTL_1M
+        expire: import_constants7.TTL_1M
       }
     );
   }
-  process.exit();
 };
 var restoreCompletedBacktestResults = (completed) => {
   for (const { result } of completed) {
@@ -5751,6 +5868,56 @@ var prepareContinuedBacktestMarketContext = async ({
     log: (message) => console.log(import_chalk10.default.gray(message))
   });
 };
+var runBacktestSuite = async (manifest, testSuite, initialCompletedTests = 0) => {
+  const observation = await observeBacktestRun(
+    manifest,
+    initialCompletedTests,
+    effectiveParallel
+  );
+  try {
+    await executeTestSuite({
+      testSuite,
+      window: manifest.window,
+      preloadStart: manifest.preloadStart,
+      backtestRunId: manifest.runId,
+      initialCompletedTests,
+      totalTests: manifest.testSuite.length,
+      onProgress: observation?.progress,
+      onIncomplete: async () => {
+        await observation?.finish("failed");
+        await markBacktestRunStatus({ run: manifest, status: "interrupted" });
+        process.exit(1);
+      },
+      onResult: async (result) => {
+        await saveBacktestCheckpointResult({
+          result,
+          runId: manifest.runId,
+          userName
+        });
+        trackTopResult(result);
+        updateBestTickerResult(result);
+      },
+      onInterrupt: async () => {
+        await observation?.finish("cancelled");
+        await markBacktestRunStatus({ run: manifest, status: "interrupted" });
+      },
+      onFinish: async () => {
+        try {
+          await markBacktestRunStatus({ run: manifest, status: "completed" });
+          await finishBacktest(manifest.testSuite);
+          await observation?.finish("completed");
+          process.exit();
+        } catch (error) {
+          await observation?.finish("failed");
+          throw error;
+        }
+      }
+    });
+  } catch (error) {
+    await observation?.finish("failed");
+    throw error;
+  }
+};
 var backtest = async () => {
   resetRunState();
   const config = await loadBacktestConfig();
@@ -5765,33 +5932,10 @@ var backtest = async () => {
     if (!remainingSuite.length) {
       await markBacktestRunStatus({ run: manifest2, status: "completed" });
       await finishBacktest(manifest2.testSuite);
-      return;
+      process.exit();
     }
     await prepareContinuedBacktestMarketContext({ manifest: manifest2, remainingSuite });
-    await executeTestSuite({
-      testSuite: remainingSuite,
-      window: manifest2.window,
-      preloadStart: manifest2.preloadStart,
-      backtestRunId: manifest2.runId,
-      initialCompletedTests: completed.length,
-      totalTests: manifest2.testSuite.length,
-      onResult: async (result) => {
-        await saveBacktestCheckpointResult({
-          result,
-          runId: manifest2.runId,
-          userName
-        });
-        trackTopResult(result);
-        updateBestTickerResult(result);
-      },
-      onInterrupt: async () => {
-        await markBacktestRunStatus({ run: manifest2, status: "interrupted" });
-      },
-      onFinish: async () => {
-        await markBacktestRunStatus({ run: manifest2, status: "completed" });
-        await finishBacktest(manifest2.testSuite);
-      }
-    });
+    await runBacktestSuite(manifest2, remainingSuite, completed.length);
     return;
   }
   const preparedRun = await prepareRunEnvironment2(config.strategyName);
@@ -5852,28 +5996,7 @@ var backtest = async () => {
     testSuite
   });
   console.log(import_chalk10.default.gray(`backtest run id: ${manifest.runId}`));
-  await executeTestSuite({
-    testSuite,
-    window: preparedRun.window,
-    preloadStart: preparedRun.preloadStart,
-    backtestRunId: manifest.runId,
-    onResult: async (result) => {
-      await saveBacktestCheckpointResult({
-        result,
-        runId: manifest.runId,
-        userName
-      });
-      trackTopResult(result);
-      updateBestTickerResult(result);
-    },
-    onInterrupt: async () => {
-      await markBacktestRunStatus({ run: manifest, status: "interrupted" });
-    },
-    onFinish: async () => {
-      await markBacktestRunStatus({ run: manifest, status: "completed" });
-      await finishBacktest(testSuite);
-    }
-  });
+  await runBacktestSuite(manifest, testSuite);
 };
 var main = backtest;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/scripts/binanceMarketIngest.js

@@ -352,7 +352,7 @@ var buildMarketBreadthRows = ({
 
 // src/scripts/binanceMarketIngest.ts
 import_args.default.example(
-  "yarn cli:node8g binance:market-ingest --all --symbols BTCUSDT,ETHUSDT --days 0.05 --interval 1m --write",
+  "yarn cli:node8g binance:market-ingest --all --symbols BTCUSDT,ETHUSDT --days 0.05 --interval 15m --write",
   "Ingest Binance public market breadth and historical aggTrades buckets"
 );
 import_args.default.option(
@@ -360,7 +360,7 @@ import_args.default.option(
   "Comma-separated target symbols",
   "BTCUSDT,ETHUSDT"
 );
-import_args.default.option(["i", "interval"], "Aggregation interval: 1m,5m,15m,1h", "1m");
+import_args.default.option(["i", "interval"], "Aggregation interval: 5m,15m,1h", "15m");
 import_args.default.option(["d", "days"], "Lookback window in days", "1");
 import_args.default.option(["h", "hours"], "Lookback window in hours; overrides --days");
 import_args.default.option(["a", "aggTrades"], "Fetch and bucket Binance aggTrades");
@@ -394,7 +394,6 @@ var asInt = (value, fallback) => {
 };
 var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
 var intervalToConnectorInterval = (interval) => {
-  if (interval === "1m") return "1";
   if (interval === "5m") return "5";
   if (interval === "15m") return "15";
   return "60";
@@ -450,6 +449,7 @@ var printEstimate = (estimate) => {
 var main = async () => {
   const symbols = normalizeBinanceSymbols(flags.symbols);
   const interval = normalizeMarketFeatureInterval(flags.interval);
+  if (interval === "1m") throw new Error("Use interval 5m, 15m, or 1h");
   const hours = flags.hours == null ? null : asFloat(flags.hours, 0);
   const days = hours != null && hours > 0 ? hours / 24 : asFloat(flags.days, 1);
   const breadthUniverses = (0, import_strategies.getBinanceBreadthUniverses)();