@tradejs/cli 1.0.0

package/dist/scripts/findMlSignalsByTestSuite.js

@@ -0,0 +1,83 @@
+"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 __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
+));
+
+// src/scripts/findMlSignalsByTestSuite.ts
+var import_args = __toESM(require("args"));
+var import_ioredis = __toESM(require("ioredis"));
+import_args.default.example(
+  'yarn ts-node ./src/scripts/findMlSignalsByTestSuite --testSuiteId 861d9d --pattern "ml:*:signals:*"',
+  "Find ML signal keys by context.testSuiteId"
+);
+import_args.default.option(["p", "pattern"], "Redis key pattern", "ml:signals:*");
+import_args.default.option(["t", "testSuiteId"], "context.testSuiteId value", "861d9d");
+import_args.default.option(["c", "count"], "SCAN COUNT", 500);
+var flags = import_args.default.parse(process.argv);
+var redis = new import_ioredis.default({
+  host: process.env.REDIS_HOST ?? "127.0.0.1",
+  port: Number(process.env.REDIS_PORT ?? 6379)
+});
+var findKeys = async () => {
+  const pattern = String(flags.pattern || "ml:signals:*");
+  const testSuiteId = String(flags.testSuiteId || "861d9d");
+  const scanCount = Number(flags.count || 500);
+  let cursor = "0";
+  const matchedKeys = [];
+  let scanned = 0;
+  do {
+    const [nextCursor, keys] = await redis.scan(
+      cursor,
+      "MATCH",
+      pattern,
+      "COUNT",
+      scanCount
+    );
+    cursor = nextCursor;
+    for (const key of keys) {
+      scanned++;
+      const raw = await redis.call("JSON.GET", key, "$.context.testSuiteId");
+      if (raw === `["${testSuiteId}"]`) {
+        matchedKeys.push(key);
+      }
+    }
+  } while (cursor !== "0");
+  console.log(
+    JSON.stringify(
+      {
+        pattern,
+        testSuiteId,
+        scanned,
+        matched: matchedKeys.length,
+        keys: matchedKeys
+      },
+      null,
+      2
+    )
+  );
+};
+findKeys().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+}).finally(() => {
+  redis.disconnect();
+});

package/dist/scripts/infraCommon.js

@@ -0,0 +1,135 @@
+"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/infraCommon.ts
+var infraCommon_exports = {};
+__export(infraCommon_exports, {
+  DEV_COMPOSE_FILE: () => DEV_COMPOSE_FILE,
+  initDevComposeFile: () => initDevComposeFile,
+  requireDevComposeFile: () => requireDevComposeFile,
+  runDockerCompose: () => runDockerCompose
+});
+module.exports = __toCommonJS(infraCommon_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var DEV_COMPOSE_FILE = "docker-compose.dev.yml";
+var resolveProjectRoot = () => {
+  const cwd = process.cwd();
+  const composeInCwd = import_node_path.default.resolve(cwd, DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composeInCwd)) {
+    return cwd;
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    const normalized = import_node_path.default.resolve(fromEnv);
+    const composeFromEnv = import_node_path.default.resolve(normalized, DEV_COMPOSE_FILE);
+    if ((0, import_node_fs.existsSync)(composeFromEnv)) {
+      return normalized;
+    }
+  }
+  return cwd;
+};
+var DEV_COMPOSE_TEMPLATE = `services:
+  timescale:
+    image: timescale/timescaledb:latest-pg16
+    container_name: tradejs-timescale
+    environment:
+      POSTGRES_USER: \${PG_USER:-app}
+      POSTGRES_PASSWORD: \${PG_PASSWORD:-app}
+      POSTGRES_DB: \${PG_DB:-app}
+    ports:
+      - "5432:5432"
+    volumes:
+      - tradejs_pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${PG_USER:-app} -d \${PG_DB:-app}"]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+    restart: unless-stopped
+
+  redis:
+    image: redis/redis-stack:latest
+    container_name: tradejs-redis
+    ports:
+      - "6379:6379"
+      - "5540:8001"
+    volumes:
+      - tradejs_redisdata:/data
+    restart: unless-stopped
+
+volumes:
+  tradejs_pgdata:
+  tradejs_redisdata:
+`;
+var getDevComposePath = () => import_node_path.default.resolve(resolveProjectRoot(), DEV_COMPOSE_FILE);
+var initDevComposeFile = () => {
+  const composePath = getDevComposePath();
+  if ((0, import_node_fs.existsSync)(composePath)) {
+    console.log(
+      import_chalk.default.yellow(
+        `${DEV_COMPOSE_FILE} already exists. Keeping user-defined file as is.`
+      )
+    );
+    return composePath;
+  }
+  (0, import_node_fs.writeFileSync)(composePath, DEV_COMPOSE_TEMPLATE, "utf8");
+  console.log(import_chalk.default.green(`Created ${DEV_COMPOSE_FILE} in project root`));
+  return composePath;
+};
+var requireDevComposeFile = () => {
+  const composePath = import_node_path.default.resolve(resolveProjectRoot(), DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composePath)) {
+    console.log(import_chalk.default.gray(`Using existing ${DEV_COMPOSE_FILE}`));
+    return composePath;
+  }
+  throw new Error(
+    `${DEV_COMPOSE_FILE} not found in project root. Run "npx @tradejs/cli infra-init" first.`
+  );
+};
+var runDockerCompose = (composePath, args) => {
+  const result = (0, import_node_child_process.spawnSync)("docker", ["compose", "-f", composePath, ...args], {
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if ((result.status ?? 0) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEV_COMPOSE_FILE,
+  initDevComposeFile,
+  requireDevComposeFile,
+  runDockerCompose
+});

package/dist/scripts/infraDown.js

@@ -0,0 +1,82 @@
+"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 __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
+));
+
+// src/scripts/infraDown.ts
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/scripts/infraCommon.ts
+var import_chalk = __toESM(require("chalk"));
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var DEV_COMPOSE_FILE = "docker-compose.dev.yml";
+var resolveProjectRoot = () => {
+  const cwd = process.cwd();
+  const composeInCwd = import_node_path.default.resolve(cwd, DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composeInCwd)) {
+    return cwd;
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    const normalized = import_node_path.default.resolve(fromEnv);
+    const composeFromEnv = import_node_path.default.resolve(normalized, DEV_COMPOSE_FILE);
+    if ((0, import_node_fs.existsSync)(composeFromEnv)) {
+      return normalized;
+    }
+  }
+  return cwd;
+};
+var requireDevComposeFile = () => {
+  const composePath = import_node_path.default.resolve(resolveProjectRoot(), DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composePath)) {
+    console.log(import_chalk.default.gray(`Using existing ${DEV_COMPOSE_FILE}`));
+    return composePath;
+  }
+  throw new Error(
+    `${DEV_COMPOSE_FILE} not found in project root. Run "npx @tradejs/cli infra-init" first.`
+  );
+};
+var runDockerCompose = (composePath, args) => {
+  const result = (0, import_node_child_process.spawnSync)("docker", ["compose", "-f", composePath, ...args], {
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if ((result.status ?? 0) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+
+// src/scripts/infraDown.ts
+var run = async () => {
+  const composePath = requireDevComposeFile();
+  console.log(import_chalk2.default.cyan("Stopping dev infra (timescale, redis)..."));
+  runDockerCompose(composePath, ["stop", "timescale", "redis"]);
+  console.log(import_chalk2.default.green("Dev infra is stopped."));
+};
+run().catch((error) => {
+  console.error(import_chalk2.default.red(`infra-down failed: ${String(error)}`));
+  process.exit(1);
+});

package/dist/scripts/infraInit.js

@@ -0,0 +1,107 @@
+"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 __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
+));
+
+// src/scripts/infraInit.ts
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/scripts/infraCommon.ts
+var import_chalk = __toESM(require("chalk"));
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var DEV_COMPOSE_FILE = "docker-compose.dev.yml";
+var resolveProjectRoot = () => {
+  const cwd = process.cwd();
+  const composeInCwd = import_node_path.default.resolve(cwd, DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composeInCwd)) {
+    return cwd;
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    const normalized = import_node_path.default.resolve(fromEnv);
+    const composeFromEnv = import_node_path.default.resolve(normalized, DEV_COMPOSE_FILE);
+    if ((0, import_node_fs.existsSync)(composeFromEnv)) {
+      return normalized;
+    }
+  }
+  return cwd;
+};
+var DEV_COMPOSE_TEMPLATE = `services:
+  timescale:
+    image: timescale/timescaledb:latest-pg16
+    container_name: tradejs-timescale
+    environment:
+      POSTGRES_USER: \${PG_USER:-app}
+      POSTGRES_PASSWORD: \${PG_PASSWORD:-app}
+      POSTGRES_DB: \${PG_DB:-app}
+    ports:
+      - "5432:5432"
+    volumes:
+      - tradejs_pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${PG_USER:-app} -d \${PG_DB:-app}"]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+    restart: unless-stopped
+
+  redis:
+    image: redis/redis-stack:latest
+    container_name: tradejs-redis
+    ports:
+      - "6379:6379"
+      - "5540:8001"
+    volumes:
+      - tradejs_redisdata:/data
+    restart: unless-stopped
+
+volumes:
+  tradejs_pgdata:
+  tradejs_redisdata:
+`;
+var getDevComposePath = () => import_node_path.default.resolve(resolveProjectRoot(), DEV_COMPOSE_FILE);
+var initDevComposeFile = () => {
+  const composePath = getDevComposePath();
+  if ((0, import_node_fs.existsSync)(composePath)) {
+    console.log(
+      import_chalk.default.yellow(
+        `${DEV_COMPOSE_FILE} already exists. Keeping user-defined file as is.`
+      )
+    );
+    return composePath;
+  }
+  (0, import_node_fs.writeFileSync)(composePath, DEV_COMPOSE_TEMPLATE, "utf8");
+  console.log(import_chalk.default.green(`Created ${DEV_COMPOSE_FILE} in project root`));
+  return composePath;
+};
+
+// src/scripts/infraInit.ts
+var run = async () => {
+  initDevComposeFile();
+  console.log(import_chalk2.default.green("Dev infra files are initialized."));
+};
+run().catch((error) => {
+  console.error(import_chalk2.default.red(`infra-init failed: ${String(error)}`));
+  process.exit(1);
+});

package/dist/scripts/infraUp.js

@@ -0,0 +1,82 @@
+"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 __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
+));
+
+// src/scripts/infraUp.ts
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/scripts/infraCommon.ts
+var import_chalk = __toESM(require("chalk"));
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var DEV_COMPOSE_FILE = "docker-compose.dev.yml";
+var resolveProjectRoot = () => {
+  const cwd = process.cwd();
+  const composeInCwd = import_node_path.default.resolve(cwd, DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composeInCwd)) {
+    return cwd;
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    const normalized = import_node_path.default.resolve(fromEnv);
+    const composeFromEnv = import_node_path.default.resolve(normalized, DEV_COMPOSE_FILE);
+    if ((0, import_node_fs.existsSync)(composeFromEnv)) {
+      return normalized;
+    }
+  }
+  return cwd;
+};
+var requireDevComposeFile = () => {
+  const composePath = import_node_path.default.resolve(resolveProjectRoot(), DEV_COMPOSE_FILE);
+  if ((0, import_node_fs.existsSync)(composePath)) {
+    console.log(import_chalk.default.gray(`Using existing ${DEV_COMPOSE_FILE}`));
+    return composePath;
+  }
+  throw new Error(
+    `${DEV_COMPOSE_FILE} not found in project root. Run "npx @tradejs/cli infra-init" first.`
+  );
+};
+var runDockerCompose = (composePath, args) => {
+  const result = (0, import_node_child_process.spawnSync)("docker", ["compose", "-f", composePath, ...args], {
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if ((result.status ?? 0) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+};
+
+// src/scripts/infraUp.ts
+var run = async () => {
+  const composePath = requireDevComposeFile();
+  console.log(import_chalk2.default.cyan("Starting dev infra (timescale, redis)..."));
+  runDockerCompose(composePath, ["up", "-d", "timescale", "redis"]);
+  console.log(import_chalk2.default.green("Dev infra is up."));
+};
+run().catch((error) => {
+  console.error(import_chalk2.default.red(`infra-up failed: ${String(error)}`));
+  process.exit(1);
+});

package/dist/scripts/migration.js

@@ -0,0 +1,67 @@
+"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 __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
+));
+
+// src/scripts/migration.ts
+var import_progress = __toESM(require("progress"));
+var import_chalk = __toESM(require("chalk"));
+var import_logger = require("@tradejs/infra/logger");
+var import_files = require("@tradejs/infra/files");
+var import_timescale = require("@tradejs/infra/timescale");
+var DIR = "data/history";
+var re = /^(.+?)_(\d+)\.json$/;
+var BATCH = 2e3;
+var migrateFile = async (file) => {
+  const m = re.exec(file);
+  if (!m) return;
+  const symbol = m[1];
+  const interval = Number(m[2]);
+  const data = await (0, import_files.getFile)(DIR, `${symbol}_${interval}`);
+  const rows = (0, import_timescale.toRows)(symbol, interval, data);
+  for (let i = 0; i < rows.length; i += BATCH) {
+    await (0, import_timescale.upsertCandles)(rows.slice(i, i + BATCH));
+  }
+};
+var migration = async () => {
+  const files = await (0, import_files.getFiles)(DIR);
+  const bar = new import_progress.default(
+    ":current/:total [:bar][:percent] :eta(s) :file",
+    {
+      total: files.length,
+      width: 30
+    }
+  );
+  for await (const file of files) {
+    try {
+      await migrateFile(file);
+    } catch (e) {
+      import_logger.logger.error("Failed: %s %s", file, e);
+    } finally {
+      bar.tick(1, {
+        file: import_chalk.default.gray(file)
+      });
+    }
+  }
+  process.exit();
+};
+migration();

package/dist/scripts/mlExport.js

@@ -0,0 +1,95 @@
+"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 __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
+));
+
+// src/scripts/mlExport.ts
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_ml = require("@tradejs/infra/ml");
+import_args.default.example(
+  "yarn ts-node ./src/scripts/mlExport --strategy trendline",
+  "Merge per-worker ML chunks into one dataset JSONL"
+);
+import_args.default.option(["o", "outDir"], "Dataset directory", "data/ml/export");
+import_args.default.option(["s", "strategy"], "Strategy name", "");
+import_args.default.option(
+  ["k", "keepChunks"],
+  "Keep source chunk files after successful merge",
+  false
+);
+var flags = import_args.default.parse(process.argv);
+var listChunkFiles = async (outDir, strategyName) => {
+  const prefix = `ml-dataset-${(0, import_ml.toFileToken)(strategyName)}-chunk-`;
+  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 chunkFiles = await listChunkFiles(outDir, strategyName);
+  if (!chunkFiles.length) {
+    console.log(
+      import_chalk.default.yellow(
+        `No chunk files found for strategy "${strategyName}" in ${outDir}`
+      )
+    );
+    process.exit(0);
+  }
+  const mergedPath = import_path.default.join(
+    outDir,
+    `ml-dataset-${(0, import_ml.toFileToken)(strategyName)}-merged-${Date.now()}.jsonl`
+  );
+  await (0, import_ml.mergeJsonlFiles)({
+    filePaths: chunkFiles,
+    outPath: mergedPath
+  });
+  const shouldDeleteChunks = !Boolean(flags.keepChunks);
+  if (shouldDeleteChunks) {
+    for (const filePath of chunkFiles) {
+      await import_promises.default.rm(filePath, { force: true });
+    }
+  }
+  console.log(import_chalk.default.green(`Merged dataset saved: ${mergedPath}`));
+  console.log(
+    import_chalk.default.gray(
+      `strategy=${strategyName}, source_chunks=${chunkFiles.length}, deleteChunks=${Boolean(
+        shouldDeleteChunks
+      )}`
+    )
+  );
+  process.exit(0);
+};
+main().catch((error) => {
+  console.error(import_chalk.default.red(error?.message || String(error)));
+  process.exit(1);
+});