@tradejs/cli 1.0.5 → 1.0.6

package/dist/scripts/backtest.js

@@ -1637,6 +1637,7 @@ import_args.default.option(["t", "tickers"], "Selected tickers");
 import_args.default.option(["e", "exclude"], "Exclude tickers from tests");
 import_args.default.option(["l", "tickersLimit"], "Tickers limit");
 import_args.default.option(["n", "tests"], "Tests limit", import_constants.TESTS_LIMIT);
+import_args.default.option("skip", "Skip first N tests", 0);
 import_args.default.option(["p", "parallel"], "Parallel tasks", MAX_PARALLEL);
 import_args.default.option(["f", "timeframe"], "Timeframe", 15);
 import_args.default.option(["T", "top"], "Return N best tests", import_constants.TESTS_TOP_LIMIT);
@@ -1656,9 +1657,26 @@ import_args.default.option(
   "Write ML dataset rows to per-worker JSONL chunks",
   false
 );
-var flags = import_args.default.parse(process.argv);
+import_args.default.option(
+  ["A", "ai"],
+  "Write AI prompt rows to per-worker JSONL chunks",
+  false
+);
+var normalizedArgv = process.argv.map((arg) => {
+  if (arg === "--ML") {
+    return "--ml";
+  }
+  if (arg === "--AI") {
+    return "--ai";
+  }
+  return arg;
+});
+var flags = import_args.default.parse(normalizedArgv);
 var interval = flags.timeframe.toString();
-var progressStep = flags.progressStep;
+var progressStep = Math.max(1, parseInt(String(flags.progressStep), 10));
+var testsLimit = Math.max(0, parseInt(String(flags.tests), 10));
+var testsSkip = Math.max(0, parseInt(String(flags.skip ?? 0), 10));
+var testItemTimeoutMs = 12e4;
 var uuid = (len = 12) => (0, import_uuid.v4)().slice(-len);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var testerWorkerPathCandidates = [
@@ -1701,6 +1719,10 @@ var errorTests = 0;
 var errorMessages = [];
 var results = [];
 var resultsByTickers = /* @__PURE__ */ new Map();
+var resultArtifactsByTestName = /* @__PURE__ */ new Map();
+var artifactRefCountsByTestName = /* @__PURE__ */ new Map();
+var bestTickerTestNameBySymbol = /* @__PURE__ */ new Map();
+var topResultNames = /* @__PURE__ */ new Set();
 var userName = flags.user;
 var runStartedAt = Date.now();
 var createListIt = () => new ListIt({
@@ -1709,10 +1731,108 @@ var createListIt = () => new ListIt({
 });
 var createTable = (headers, rows) => createListIt().setHeaderRow(headers).d(rows).toString();
 var createTimestamp = (date) => (0, import_date_fns.format)(date, "yyyyMMddHHmm");
-var filterGoodTests = (tests) => tests.filter((res) => res.stat?.orders > 5 && res.stat?.profit > 10);
+var isGoodTest = (result) => result.stat?.orders > 5 && result.stat?.profit > 10;
+var getResultAmount = (result) => result.stat.amount ?? 0;
 var recordError = (error) => {
   errorMessages.push(error);
 };
+var stripInlineLogs = (result) => {
+  const { inlineOrderLog, inlinePositionLog, ...resultWithoutLogs } = result;
+  return resultWithoutLogs;
+};
+var getInlineArtifacts = (result) => {
+  if (!result.inlineOrderLog && !result.inlinePositionLog) {
+    return null;
+  }
+  return {
+    orderLog: result.inlineOrderLog,
+    positionLog: result.inlinePositionLog
+  };
+};
+var retainArtifacts = (testName, artifacts) => {
+  if (artifacts) {
+    resultArtifactsByTestName.set(testName, artifacts);
+  }
+  artifactRefCountsByTestName.set(
+    testName,
+    (artifactRefCountsByTestName.get(testName) ?? 0) + 1
+  );
+};
+var releaseArtifacts = (testName) => {
+  const nextCount = (artifactRefCountsByTestName.get(testName) ?? 0) - 1;
+  if (nextCount <= 0) {
+    artifactRefCountsByTestName.delete(testName);
+    resultArtifactsByTestName.delete(testName);
+    return;
+  }
+  artifactRefCountsByTestName.set(testName, nextCount);
+};
+var insertTopResult = (currentResults, nextResult, limit) => {
+  if (limit <= 0) {
+    return {
+      results: [],
+      added: false
+    };
+  }
+  const nextResults = [...currentResults];
+  const nextAmount = getResultAmount(nextResult);
+  let insertIndex = nextResults.length;
+  for (let index = 0; index < nextResults.length; index += 1) {
+    if (nextAmount > getResultAmount(nextResults[index])) {
+      insertIndex = index;
+      break;
+    }
+  }
+  if (insertIndex === nextResults.length && nextResults.length >= limit) {
+    return {
+      results: currentResults,
+      added: false
+    };
+  }
+  nextResults.splice(insertIndex, 0, nextResult);
+  if (nextResults.length > limit) {
+    nextResults.length = limit;
+  }
+  return {
+    results: nextResults,
+    added: nextResults.some(
+      (candidate) => candidate.test.name === nextResult.test.name
+    )
+  };
+};
+var updateTopResults = (nextResults, nextResult, artifacts) => {
+  const previousTopNames = topResultNames;
+  const nextTopNames = new Set(nextResults.map((result) => result.test.name));
+  if (artifacts && !previousTopNames.has(nextResult.test.name) && nextTopNames.has(nextResult.test.name)) {
+    retainArtifacts(nextResult.test.name, artifacts);
+  }
+  for (const testName of previousTopNames) {
+    if (!nextTopNames.has(testName)) {
+      releaseArtifacts(testName);
+    }
+  }
+  results = nextResults;
+  topResultNames = nextTopNames;
+};
+var updateBestTickerResult = (result, artifacts) => {
+  if (!isGoodTest(result)) {
+    return false;
+  }
+  const previousResult = resultsByTickers.get(result.test.symbol);
+  if (previousResult && previousResult.stat.profit >= result.stat.profit) {
+    return false;
+  }
+  const previousTestName = bestTickerTestNameBySymbol.get(result.test.symbol);
+  if (previousTestName) {
+    releaseArtifacts(previousTestName);
+  }
+  resultsByTickers.set(result.test.symbol, result);
+  bestTickerTestNameBySymbol.set(result.test.symbol, result.test.name);
+  if (artifacts) {
+    retainArtifacts(result.test.name, artifacts);
+  }
+  return true;
+};
 var isStrategyConfigGrid = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -1735,13 +1855,39 @@ var resolveBacktestConnectorName = async (value) => {
 };
 var getLogsById = async (orderLogId) => {
   const orderLog = await (0, import_redis.getData)(
-    import_redis.redisKeys.cacheOrders(userName, orderLogId)
+    import_redis.redisKeys.cacheOrders(userName, orderLogId),
+    null
   );
   const positionLog = await (0, import_redis.getData)(
-    import_redis.redisKeys.cachePositions(userName, orderLogId)
+    import_redis.redisKeys.cachePositions(userName, orderLogId),
+    null
   );
   return { orderLog, positionLog };
 };
+var cacheArtifactsById = async (orderLogId, artifacts) => {
+  if (!artifacts || !Array.isArray(artifacts.orderLog) || !Array.isArray(artifacts.positionLog)) {
+    return;
+  }
+  await Promise.all([
+    (0, import_redis.setData)(import_redis.redisKeys.cacheOrders(userName, orderLogId), artifacts.orderLog, {
+      expire: import_constants.TTL_1D
+    }),
+    (0, import_redis.setData)(
+      import_redis.redisKeys.cachePositions(userName, orderLogId),
+      artifacts.positionLog,
+      {
+        expire: import_constants.TTL_1D
+      }
+    )
+  ]);
+};
+var resolveResultArtifacts = async (result) => {
+  const inlineArtifacts = resultArtifactsByTestName.get(result.test.name);
+  if (inlineArtifacts?.orderLog && inlineArtifacts?.positionLog) {
+    return inlineArtifacts;
+  }
+  return getLogsById(result.orderLogId);
+};
 var setTestData = async (test, stat, orderLog) => {
   await (0, import_redis.setData)(
     import_redis.redisKeys.testOrders(test.userName, test.strategyName, test.name),
@@ -1838,15 +1984,38 @@ var backtest = async () => {
     strategyName,
     typedBacktestConfig,
     connectorName
-  ).slice(0, parseInt(flags.tests));
+  );
   const mlEnabled = Boolean(flags.ml);
-  testSuite = testSuite.map((test) => ({ ...test, ml: mlEnabled }));
+  const aiEnabled = Boolean(flags.ai);
+  testSuite = testSuite.map((test) => ({
+    ...test,
+    ml: mlEnabled,
+    ai: aiEnabled,
+    timeoutMs: testItemTimeoutMs
+  })).slice(testsSkip, testsSkip + testsLimit);
+  if (!testSuite.length) {
+    console.log(
+      import_chalk.default.yellow(
+        `No tests selected (skip=${testsSkip}, limit=${testsLimit}).`
+      )
+    );
+    return;
+  }
   const chunkSize = Math.ceil(testSuite.length / parseInt(flags.parallel));
   const chunks = import_lodash.default.chunk(testSuite, chunkSize);
-  let completedWorkers = 0;
   let completedTests = 0;
   let isFinishing = false;
   const workers = /* @__PURE__ */ new Set();
+  const maybeFinish = async () => {
+    if (isFinishing) {
+      return;
+    }
+    if (completedTests !== testSuite.length || workers.size > 0) {
+      return;
+    }
+    isFinishing = true;
+    await finish();
+  };
   const stopWorkers = () => {
     for (const worker of workers) {
       if (!worker.killed) {
@@ -1886,13 +2055,8 @@ var backtest = async () => {
     workers.add(tester);
     tester.on("message", async (msg) => {
       if (msg.done) {
-        completedWorkers++;
         workers.delete(tester);
-        if (completedWorkers === chunks.length && !isFinishing) {
-          isFinishing = true;
-          results = (0, import_backtest.sortBestTests)(results, flags.top);
-          await finish();
-        }
+        await maybeFinish();
         return;
       }
       completedTests++;
@@ -1910,20 +2074,25 @@ var backtest = async () => {
       } else {
         successTests++;
       }
-      results.push(msg);
-      const goodResults = filterGoodTests(results);
-      goodResults.forEach((res) => {
-        const prevValue = resultsByTickers.get(res.test.symbol);
-        if (!prevValue || prevValue.stat.profit < res.stat.profit) {
-          resultsByTickers.set(res.test.symbol, res);
-        }
-      });
+      const fullResult = msg;
+      const result = stripInlineLogs(fullResult);
+      const inlineArtifacts = getInlineArtifacts(fullResult);
+      const nextTopResults = insertTopResult(results, result, flags.top);
+      const shouldCacheTopArtifacts = nextTopResults.added;
+      if (nextTopResults.added || results !== nextTopResults.results) {
+        updateTopResults(nextTopResults.results, result, inlineArtifacts);
+      }
+      const updatedBestTickerResult = updateBestTickerResult(
+        result,
+        inlineArtifacts
+      );
+      if ((shouldCacheTopArtifacts || updatedBestTickerResult) && inlineArtifacts) {
+        await cacheArtifactsById(result.orderLogId, inlineArtifacts);
+      }
       if (completedTests % progressStep === 0 || completedTests === testSuite.length) {
-        results = (0, import_backtest.sortBestTests)(results, flags.top);
-        const {
-          test: { symbol, name },
-          stat: { profit }
-        } = results[0];
+        const bestResult = results[0];
+        const symbol = bestResult?.test.symbol || "-";
+        const profit = bestResult?.stat.profit || 0;
         const profitStr = `${(profit || 0).toFixed(2)}$`;
         bar.tick(
           completedTests === testSuite.length ? completedTests % progressStep : progressStep,
@@ -1944,6 +2113,7 @@ var backtest = async () => {
         recordError({ error: `Worker exited with code ${code}` });
         console.error(import_chalk.default.red(`Worker exited with code ${code}`));
       }
+      void maybeFinish();
     });
     await (0, import_redis.setData)(import_redis.redisKeys.cacheChunk(userName, chunkId), chunkWithId, {
       expire: import_constants.TTL_1D
@@ -1954,10 +2124,18 @@ var backtest = async () => {
 var saveAndPrintResults = async () => {
   const colorizedResults = [];
   for await (const result of results) {
-    const { test, orderLogId } = result;
+    const { test } = result;
     const { symbol, name } = test;
-    const { orderLog, positionLog } = await getLogsById(orderLogId);
+    const { orderLog, positionLog } = await resolveResultArtifacts(result);
+    if (!orderLog || !positionLog) {
+      throw new Error(`Logs not found for test ${name}`);
+    }
     const stat = (0, import_backtest.calculateStatsFull)(positionLog);
+    if (!stat && result.stat.orders > 0) {
+      throw new Error(
+        `Position log is empty for test ${name} despite ${result.stat.orders} closed orders`
+      );
+    }
     await setTestData(test, stat, orderLog);
     const statRow = [
       import_chalk.default.blue(name),
@@ -1980,10 +2158,18 @@ var saveAndPrintResults = async () => {
 var saveAndPrintResultsByTickers = async () => {
   const colorizedResultsByTickers = [];
   for await (const result of resultsByTickers.values()) {
-    const { test, orderLogId } = result;
+    const { test } = result;
     const { symbol, name } = test;
-    const { orderLog, positionLog } = await getLogsById(orderLogId);
+    const { orderLog, positionLog } = await resolveResultArtifacts(result);
+    if (!orderLog || !positionLog) {
+      throw new Error(`Logs not found for ticker result ${name}`);
+    }
     const stat = (0, import_backtest.calculateStatsFull)(positionLog);
+    if (!stat && result.stat.orders > 0) {
+      throw new Error(
+        `Position log is empty for ticker result ${name} despite ${result.stat.orders} closed orders`
+      );
+    }
     await setTestData(test, stat, orderLog);
     const statRow = [
       import_chalk.default.blue(name),
@@ -2038,7 +2224,7 @@ var finish = async () => {
       finishedAt: finishedAt.toISOString(),
       durationSeconds,
       results,
-      resultsByTickers: resultsByTickers.values(),
+      resultsByTickers: Array.from(resultsByTickers.values()),
       bestConfig,
       mergedConfig,
       successTests,

package/dist/scripts/derivativesIngest.js

@@ -28,6 +28,7 @@ var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 var import_indicators = require("@tradejs/core/indicators");
 var import_timescale = require("@tradejs/infra/timescale");
+var import_userSettings = require("@tradejs/infra/userSettings");
 var import_connectors = require("@tradejs/connectors");
 import_args.default.example(
   "yarn ts-node ./src/scripts/derivativesIngest --provider coinalyze --symbols BTCUSDT,ETHUSDT --intervals 15m,1h --days 120",
@@ -41,6 +42,7 @@ import_args.default.option(
   "Provider name: coinalyze | binance_coinbase_spread",
   "coinalyze"
 );
+import_args.default.option(["U", "user"], "User settings profile name from Redis", "root");
 import_args.default.option(["b", "batchDays"], "Request chunk size in days", 7);
 var flags = import_args.default.parse(process.argv);
 var asInt = (value, fallback) => {
@@ -59,6 +61,8 @@ var run = async () => {
   );
   const days = asInt(flags.days, 120);
   const batchDays = asInt(flags.batchDays, 7);
+  const userName = String(flags.user || "root").trim() || "root";
+  const coinalyzeApiKey = providerName === "coinalyze" ? (await (0, import_userSettings.getUserSettings)(userName)).COINALYZE_API_KEY : void 0;
   if (!symbols.length) throw new Error("No symbols provided");
   if (!intervals.length) throw new Error("No intervals provided");
   await (0, import_timescale.waitForDbReady)();
@@ -76,6 +80,7 @@ var run = async () => {
         );
         const window = await provider.fetchWindow({
           symbol,
+          apiKey: coinalyzeApiKey,
           interval,
           fromMs: cursor,
           toMs

package/dist/scripts/derivativesIngestCoinalyzeAll.js

@@ -31,6 +31,7 @@ var import_lodash = __toESM(require("lodash"));
 var import_connectors = require("@tradejs/connectors");
 var import_indicators = require("@tradejs/core/indicators");
 var import_async = require("@tradejs/core/async");
+var import_userSettings = require("@tradejs/infra/userSettings");
 var import_cli = require("@tradejs/node/cli");
 var import_timescale = require("@tradejs/infra/timescale");
 var coinalyzeIntervalMap = {
@@ -41,7 +42,7 @@ import_args.default.example(
   "yarn ts-node ./src/scripts/derivativesIngestCoinalyzeAll --days 120 --intervals 15m,1h",
   "Fetch derivatives for all getTickers symbols matched to Coinalyze markets"
 );
-import_args.default.option(["U", "user"], "Bybit user config name from Redis", "root");
+import_args.default.option(["U", "user"], "User settings profile name from Redis", "root");
 import_args.default.option(["t", "tickers"], "Comma-separated include symbols");
 import_args.default.option(["e", "exclude"], "Comma-separated exclude symbols");
 import_args.default.option(["l", "tickersLimit"], "Tickers limit");
@@ -76,14 +77,10 @@ var asInt = (value, fallback) => {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 };
 var parseList = (value) => String(value ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
-var apiKey = process.env.COINALYZE_API_KEY?.trim();
-if (!apiKey) {
-  throw new Error("Missing COINALYZE_API_KEY");
-}
 var coinalyzeBaseUrl = process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
 var coinalyzeMaxRetries = asInt(process.env.COINALYZE_MAX_RETRIES, 4);
 var lastRequestTs = 0;
-var fetchJsonWithRateLimit = async (url) => {
+var fetchJsonWithRateLimit = async (url, apiKey) => {
   const requestDelayMs = Math.max(100, asInt(flags.requestDelayMs, 200));
   const requestTimeoutMs = Math.max(
     5e3,
@@ -135,9 +132,10 @@ var fetchJsonWithRateLimit = async (url) => {
   }
   throw new Error("Coinalyze request failed after retries");
 };
-var fetchCoinalyzeMarkets = async () => {
+var fetchCoinalyzeMarkets = async (apiKey) => {
   const raw = await fetchJsonWithRateLimit(
-    `${coinalyzeBaseUrl}/future-markets`
+    `${coinalyzeBaseUrl}/future-markets`,
+    apiKey
   );
   return Array.isArray(raw) ? raw : [];
 };
@@ -220,16 +218,17 @@ var toSeriesMap = (raw, metric) => {
   return out;
 };
 var fetchMetricBatch = async (params) => {
-  const { endpoint, metric, marketSymbols, interval, fromMs, toMs } = params;
+  const { endpoint, metric, marketSymbols, apiKey, interval, fromMs, toMs } = params;
   const url = new URL(`${coinalyzeBaseUrl}${endpoint}`);
   url.searchParams.set("symbols", marketSymbols.join(","));
   url.searchParams.set("interval", coinalyzeIntervalMap[interval] || interval);
   url.searchParams.set("from", String(Math.floor(fromMs / 1e3)));
   url.searchParams.set("to", String(Math.floor(toMs / 1e3)));
-  const raw = await fetchJsonWithRateLimit(url.toString());
+  const raw = await fetchJsonWithRateLimit(url.toString(), apiKey);
   return toSeriesMap(raw, metric);
 };
 var run = async () => {
+  const userName = String(flags.user || "root").trim() || "root";
   const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
     flags.intervals
   );
@@ -239,9 +238,16 @@ var run = async () => {
   const tickersLimit = flags.tickersLimit !== void 0 ? asInt(flags.tickersLimit, 0) || void 0 : void 0;
   const exchangePriority = parseList(flags.exchangePriority || "A,6,0");
   if (!intervals.length) throw new Error("No intervals provided");
+  const settings = await (0, import_userSettings.getUserSettings)(userName);
+  const coinalyzeApiKey = settings.COINALYZE_API_KEY.trim();
+  if (!coinalyzeApiKey) {
+    throw new Error(
+      `Missing COINALYZE_API_KEY in user settings for user ${userName}`
+    );
+  }
   const connectorFactory = import_connectors.connectors[import_connectors.ConnectorNames.ByBit];
   const bybit = await connectorFactory({
-    userName: String(flags.user || "root")
+    userName
   });
   const tickers = await (0, import_cli.getTickers)(
     bybit,
@@ -253,7 +259,7 @@ var run = async () => {
   if (!tickers.length) {
     throw new Error("No tickers loaded via getTickers");
   }
-  const markets = await fetchCoinalyzeMarkets();
+  const markets = await fetchCoinalyzeMarkets(coinalyzeApiKey);
   if (!markets.length) {
     throw new Error("No markets returned by Coinalyze /future-markets");
   }
@@ -321,6 +327,7 @@ var run = async () => {
             endpoint: oiPath,
             metric: "oi",
             marketSymbols,
+            apiKey: coinalyzeApiKey,
             interval,
             fromMs: cursor,
             toMs
@@ -329,6 +336,7 @@ var run = async () => {
             endpoint: fundingPath,
             metric: "funding",
             marketSymbols,
+            apiKey: coinalyzeApiKey,
             interval,
             fromMs: cursor,
             toMs
@@ -337,6 +345,7 @@ var run = async () => {
             endpoint: liqPath,
             metric: "liq",
             marketSymbols,
+            apiKey: coinalyzeApiKey,
             interval,
             fromMs: cursor,
             toMs

package/dist/scripts/mlExport.js

@@ -24,10 +24,106 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/scripts/mlExport.ts
 var import_args = __toESM(require("args"));
-var import_chalk = __toESM(require("chalk"));
+var import_chalk2 = __toESM(require("chalk"));
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
 var import_ml = require("@tradejs/infra/ml");
+
+// src/scripts/selectStrategy.ts
+var import_readline = __toESM(require("readline"));
+var import_chalk = __toESM(require("chalk"));
+var import_strategies = require("@tradejs/node/strategies");
+var defaultStrategy = "TrendLine";
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var getStrategyChoices = async () => {
+  try {
+    const loaded = await (0, import_strategies.getAvailableStrategyNames)(projectRoot);
+    if (loaded.length) {
+      return loaded;
+    }
+  } catch (error) {
+    console.warn(`Failed to load strategy list: ${String(error)}`);
+  }
+  return [
+    "Breakout",
+    "MaStrategy",
+    "AdaptiveMomentumRibbon",
+    "TrendLine",
+    "VolumeDivergence"
+  ];
+};
+var selectStrategy = async (promptLabel = "Select strategy", options) => {
+  const strategies = options?.strategies && options.strategies.length ? options.strategies : await getStrategyChoices();
+  const preferredDefault = options?.defaultStrategy || defaultStrategy;
+  const fallbackStrategy = strategies.includes(preferredDefault) ? preferredDefault : strategies[0];
+  if (!process.stdin.isTTY) {
+    return fallbackStrategy;
+  }
+  console.log(import_chalk.default.cyan("Available strategies:"));
+  strategies.forEach((name, index) => {
+    const isDefault = name === defaultStrategy;
+    const label = isDefault ? import_chalk.default.green(name) : name;
+    const suffix = isDefault ? import_chalk.default.gray(" (default)") : "";
+    console.log(`  ${import_chalk.default.yellow(String(index + 1))}) ${label}${suffix}`);
+  });
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const question = (text) => new Promise((resolve) => rl.question(text, resolve));
+  const answer = await question(
+    `${promptLabel} [${import_chalk.default.green(fallbackStrategy)}]: `
+  );
+  rl.close();
+  const trimmed = answer.trim();
+  if (!trimmed) {
+    return fallbackStrategy;
+  }
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= strategies.length) {
+    return strategies[asNumber - 1];
+  }
+  const byName = strategies.find(
+    (name) => name.toLowerCase() === trimmed.toLowerCase()
+  );
+  if (byName) {
+    return byName;
+  }
+  console.warn(`Unknown strategy "${trimmed}", using ${fallbackStrategy}.`);
+  return fallbackStrategy;
+};
+
+// src/scripts/resolveExportStrategy.ts
+var resolveExportStrategy = async ({
+  explicitStrategy,
+  outDir,
+  datasetLabel,
+  promptLabel,
+  listStrategies
+}) => {
+  const raw = String(explicitStrategy || "").trim();
+  if (raw) {
+    return raw;
+  }
+  const availableStrategies = await listStrategies({ outDir });
+  if (!availableStrategies.length) {
+    return null;
+  }
+  if (availableStrategies.length === 1) {
+    return availableStrategies[0];
+  }
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      `Multiple ${datasetLabel} chunk strategies found in ${outDir}: ${availableStrategies.join(", ")}. Pass --strategy.`
+    );
+  }
+  return selectStrategy(promptLabel, {
+    strategies: availableStrategies,
+    defaultStrategy: availableStrategies[0]
+  });
+};
+
+// src/scripts/mlExport.ts
 import_args.default.example(
   "yarn ts-node ./src/scripts/mlExport --strategy trendline",
   "Merge per-worker ML chunks into one dataset JSONL"
@@ -45,21 +141,24 @@ var listChunkFiles = async (outDir, strategyName) => {
   const entries = await import_promises.default.readdir(outDir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => import_path.default.join(outDir, name)).sort();
 };
-var resolveStrategyName = async () => {
-  const raw = String(flags.strategy || "").trim();
-  if (raw) {
-    return raw;
-  }
-  throw new Error("Missing --strategy. Use mlExportSelect or pass --strategy.");
-};
 var main = async () => {
   const outDir = String(flags.outDir || "data/ml/export");
-  const strategyName = await resolveStrategyName();
   await import_promises.default.mkdir(outDir, { recursive: true });
+  const strategyName = await resolveExportStrategy({
+    explicitStrategy: String(flags.strategy || ""),
+    outDir,
+    datasetLabel: "ML",
+    promptLabel: "Select ML export strategy",
+    listStrategies: import_ml.listMlChunkStrategies
+  });
+  if (!strategyName) {
+    console.log(import_chalk2.default.yellow(`No ML chunk files found in ${outDir}`));
+    process.exit(0);
+  }
   const chunkFiles = await listChunkFiles(outDir, strategyName);
   if (!chunkFiles.length) {
     console.log(
-      import_chalk.default.yellow(
+      import_chalk2.default.yellow(
         `No chunk files found for strategy "${strategyName}" in ${outDir}`
       )
     );
@@ -79,9 +178,9 @@ var main = async () => {
       await import_promises.default.rm(filePath, { force: true });
     }
   }
-  console.log(import_chalk.default.green(`Merged dataset saved: ${mergedPath}`));
+  console.log(import_chalk2.default.green(`Merged dataset saved: ${mergedPath}`));
   console.log(
-    import_chalk.default.gray(
+    import_chalk2.default.gray(
       `strategy=${strategyName}, source_chunks=${chunkFiles.length}, deleteChunks=${Boolean(
         shouldDeleteChunks
       )}`
@@ -90,6 +189,6 @@ var main = async () => {
   process.exit(0);
 };
 main().catch((error) => {
-  console.error(import_chalk.default.red(error?.message || String(error)));
+  console.error(import_chalk2.default.red(error?.message || String(error)));
   process.exit(1);
 });