@tradejs/cli 1.0.5 → 1.0.8

package/dist/scripts/resolveExportStrategy.js

@@ -0,0 +1,133 @@
+"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/scripts/resolveExportStrategy.ts
+var resolveExportStrategy_exports = {};
+__export(resolveExportStrategy_exports, {
+  resolveExportStrategy: () => resolveExportStrategy
+});
+module.exports = __toCommonJS(resolveExportStrategy_exports);
+
+// 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]
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveExportStrategy
+});

package/dist/scripts/results.js

@@ -502,19 +502,21 @@ var require_supports_color = __commonJS({
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
-    var forceColor;
+    var flagForceColor;
     if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      forceColor = 0;
+      flagForceColor = 0;
     } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      forceColor = 1;
+      flagForceColor = 1;
     }
-    if ("FORCE_COLOR" in env) {
-      if (env.FORCE_COLOR === "true") {
-        forceColor = 1;
-      } else if (env.FORCE_COLOR === "false") {
-        forceColor = 0;
-      } else {
-        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+    function envForceColor() {
+      if ("FORCE_COLOR" in env) {
+        if (env.FORCE_COLOR === "true") {
+          return 1;
+        }
+        if (env.FORCE_COLOR === "false") {
+          return 0;
+        }
+        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
       }
     }
     function translateLevel(level) {
@@ -528,15 +530,22 @@ var require_supports_color = __commonJS({
         has16m: level >= 3
       };
     }
-    function supportsColor(haveStream, streamIsTTY) {
+    function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+      const noFlagForceColor = envForceColor();
+      if (noFlagForceColor !== void 0) {
+        flagForceColor = noFlagForceColor;
+      }
+      const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
       if (forceColor === 0) {
         return 0;
       }
-      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-        return 3;
-      }
-      if (hasFlag("color=256")) {
-        return 2;
+      if (sniffFlags) {
+        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+          return 3;
+        }
+        if (hasFlag("color=256")) {
+          return 2;
+        }
       }
       if (haveStream && !streamIsTTY && forceColor === void 0) {
         return 0;
@@ -553,7 +562,7 @@ var require_supports_color = __commonJS({
         return 1;
       }
       if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -565,7 +574,7 @@ var require_supports_color = __commonJS({
         return 3;
       }
       if ("TERM_PROGRAM" in env) {
-        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
         switch (env.TERM_PROGRAM) {
           case "iTerm.app":
             return version >= 3 ? 3 : 2;
@@ -584,14 +593,17 @@ var require_supports_color = __commonJS({
       }
       return min;
     }
-    function getSupportLevel(stream) {
-      const level = supportsColor(stream, stream && stream.isTTY);
+    function getSupportLevel(stream, options = {}) {
+      const level = supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options
+      });
       return translateLevel(level);
     }
     module2.exports = {
       supportsColor: getSupportLevel,
-      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
+      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
     };
   }
 });
@@ -1664,6 +1676,18 @@ var toStrategyResults = (rows) => Object.fromEntries(
   [...rows].map((row) => [row.symbol, toStrategyResultEntry(row)])
 );
 var getTestConfigs = async (userName) => {
+  const testSummariesKey = typeof import_redis.redisKeys.testSummaries === "function" ? import_redis.redisKeys.testSummaries(userName) : null;
+  const indexedItems = testSummariesKey ? await (0, import_redis.getData)(testSummariesKey, null) : null;
+  if (Array.isArray(indexedItems) && indexedItems.length) {
+    return indexedItems.map((item) => {
+      const testName = typeof item?.value === "string" ? item.value : null;
+      const strategyName = typeof item?.data?.strategyName === "string" ? item.data.strategyName : null;
+      if (!testName || !strategyName) {
+        return null;
+      }
+      return { strategyName, testName };
+    }).filter(Boolean);
+  }
   const testsPrefix = import_redis.redisKeys.tests(userName);
   const keys = await (0, import_redis.getKeys)(testsPrefix);
   const configKeys = keys.filter((key) => key.endsWith(":config"));