@tradejs/cli 1.0.0

package/dist/scripts/mlExportSelect.js

@@ -0,0 +1,100 @@
+"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/mlExportSelect.ts
+var import_child_process = require("child_process");
+
+// 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 getStrategyChoices = async () => {
+  try {
+    const loaded = await (0, import_strategies.getAvailableStrategyNames)();
+    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") => {
+  const strategies = await getStrategyChoices();
+  const fallbackStrategy = strategies.includes(defaultStrategy) ? defaultStrategy : 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/mlExportSelect.ts
+var run = async () => {
+  const selected = await selectStrategy();
+  const args = ["ts-node", "./src/scripts/mlExport", "--strategy", selected];
+  const result = (0, import_child_process.spawnSync)("yarn", args, { stdio: "inherit" });
+  process.exit(result.status ?? 1);
+};
+run().catch((err) => {
+  console.error("Failed to select strategy:", err);
+  process.exit(1);
+});

package/dist/scripts/mlInspect.js

@@ -0,0 +1,553 @@
+"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/mlInspect.ts
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_promises = __toESM(require("fs/promises"));
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_readline = __toESM(require("readline"));
+var import_child_process = require("child_process");
+import_args.default.example(
+  "yarn ml-inspect --rows 10000 --mode sample",
+  "Inspect the latest ML dataset chunk and highlight problematic features"
+);
+import_args.default.option(["d", "dir"], "Dataset directory", "data/ml/export");
+import_args.default.option(["r", "rows"], "Rows to inspect", 1e4);
+import_args.default.option(["m", "mode"], "head | tail | sample", "sample");
+import_args.default.option(["S", "strategy"], "Strategy token in dataset filename", "");
+import_args.default.option(
+  ["f", "file"],
+  "Explicit dataset file path (overrides auto-select)"
+);
+import_args.default.option(["L", "limitIssues"], "How many fields to print in report", 25);
+import_args.default.option(["M", "minFieldValues"], "Min valid values per numeric field", 50);
+import_args.default.option(["T", "tool"], "quick | ydata", "");
+var flags = import_args.default.parse(process.argv);
+var toMode = (value) => {
+  const mode = String(value || "sample").toLowerCase();
+  if (mode === "head" || mode === "tail" || mode === "sample") {
+    return mode;
+  }
+  return "sample";
+};
+var toInspectTool = (value) => {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return null;
+  if (raw === "quick" || raw === "ydata") return raw;
+  return null;
+};
+var selectInspectTool = async (defaultTool = "quick") => {
+  if (!process.stdin.isTTY) {
+    return defaultTool;
+  }
+  const options = ["quick", "ydata"];
+  console.log(import_chalk.default.cyan("Available inspect tools:"));
+  options.forEach((name, index) => {
+    const isDefault = name === defaultTool;
+    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(
+    `Select inspect tool [${import_chalk.default.green(defaultTool)}]: `
+  );
+  rl.close();
+  const trimmed = answer.trim().toLowerCase();
+  if (!trimmed) return defaultTool;
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= options.length) {
+    return options[asNumber - 1];
+  }
+  if (options.includes(trimmed)) {
+    return trimmed;
+  }
+  console.warn(
+    `Unknown inspect tool "${answer.trim()}", using ${defaultTool}.`
+  );
+  return defaultTool;
+};
+var asPositiveInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var readRowsHead = async (filePath, maxRows) => {
+  const rows = [];
+  const rl = import_readline.default.createInterface({
+    input: (0, import_fs.createReadStream)(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && typeof row === "object" && !Array.isArray(row)) {
+        rows.push(row);
+      }
+    } catch {
+    }
+    if (rows.length >= maxRows) {
+      rl.close();
+      break;
+    }
+  }
+  return rows;
+};
+var readRowsTail = async (filePath, maxRows) => {
+  const ring = [];
+  let idx = 0;
+  const rl = import_readline.default.createInterface({
+    input: (0, import_fs.createReadStream)(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (!row || typeof row !== "object" || Array.isArray(row)) continue;
+      if (ring.length < maxRows) {
+        ring.push(row);
+      } else {
+        ring[idx] = row;
+        idx = (idx + 1) % maxRows;
+      }
+    } catch {
+    }
+  }
+  if (ring.length < maxRows || idx === 0) {
+    return ring;
+  }
+  return ring.slice(idx).concat(ring.slice(0, idx));
+};
+var readRowsSample = async (filePath, maxRows) => {
+  const sample = [];
+  let seen = 0;
+  const rl = import_readline.default.createInterface({
+    input: (0, import_fs.createReadStream)(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (!row || typeof row !== "object" || Array.isArray(row)) continue;
+      seen += 1;
+      if (sample.length < maxRows) {
+        sample.push(row);
+      } else {
+        const replaceIndex = Math.floor(Math.random() * seen);
+        if (replaceIndex < maxRows) {
+          sample[replaceIndex] = row;
+        }
+      }
+    } catch {
+    }
+  }
+  return sample;
+};
+var quantileSorted = (sorted, q) => {
+  if (!sorted.length) return 0;
+  if (sorted.length === 1) return sorted[0];
+  const pos = (sorted.length - 1) * q;
+  const base = Math.floor(pos);
+  const rest = pos - base;
+  const left = sorted[base];
+  const right = sorted[Math.min(base + 1, sorted.length - 1)];
+  return left + (right - left) * rest;
+};
+var mean = (values) => {
+  if (!values.length) return 0;
+  let total = 0;
+  for (const value of values) total += value;
+  return total / values.length;
+};
+var std = (values, valuesMean) => {
+  if (!values.length) return 0;
+  let total = 0;
+  for (const value of values) {
+    const diff = value - valuesMean;
+    total += diff * diff;
+  }
+  return Math.sqrt(total / values.length);
+};
+var findLatestDataset = async (params) => {
+  const { dir, strategy } = params;
+  const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+  const strategyToken = strategy.trim().toLowerCase();
+  const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).filter(
+    (name) => !name.includes(".train.") && !name.includes(".test.")
+  ).filter(
+    (name) => strategyToken ? name.toLowerCase().includes(`ml-dataset-${strategyToken}-`) : name.toLowerCase().startsWith("ml-dataset-")
+  );
+  if (!files.length) {
+    return null;
+  }
+  const withMtime = await Promise.all(
+    files.map(async (name) => {
+      const stat = await import_promises.default.stat(import_path.default.join(dir, name));
+      return { name, mtime: stat.mtimeMs };
+    })
+  );
+  withMtime.sort(
+    (a, b) => b.mtime - a.mtime
+  );
+  return import_path.default.join(dir, withMtime[0].name);
+};
+var buildNumericStats = (rows, minFieldValues) => {
+  const allFields = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      allFields.add(key);
+    }
+  }
+  const numericStats = [];
+  for (const field of allFields) {
+    const values = [];
+    let missing = 0;
+    let nonFinite = 0;
+    let zeros = 0;
+    let present = 0;
+    for (const row of rows) {
+      const raw = row[field];
+      if (raw === null || raw === void 0 || raw === "") {
+        missing += 1;
+        continue;
+      }
+      present += 1;
+      const value = Number(raw);
+      if (!Number.isFinite(value)) {
+        nonFinite += 1;
+        continue;
+      }
+      values.push(value);
+      if (value === 0) {
+        zeros += 1;
+      }
+    }
+    if (values.length < minFieldValues) {
+      continue;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const q1 = quantileSorted(sorted, 0.25);
+    const median = quantileSorted(sorted, 0.5);
+    const q3 = quantileSorted(sorted, 0.75);
+    const p95 = quantileSorted(sorted, 0.95);
+    const p99 = quantileSorted(sorted, 0.99);
+    const valuesMean = mean(values);
+    const valuesStd = std(values, valuesMean);
+    const iqr = q3 - q1;
+    const low = q1 - 3 * iqr;
+    const high = q3 + 3 * iqr;
+    const outliers = values.filter((v) => v < low || v > high).length;
+    const uniqueCount = new Set(values).size;
+    numericStats.push({
+      field,
+      count: rows.length,
+      validCount: values.length,
+      missingRate: missing / rows.length,
+      nonFiniteRate: nonFinite / Math.max(present, 1),
+      zeroRate: zeros / Math.max(values.length, 1),
+      uniqueCount,
+      min: sorted[0],
+      max: sorted[sorted.length - 1],
+      mean: valuesMean,
+      std: valuesStd,
+      median,
+      q1,
+      q3,
+      p95,
+      p99,
+      outlierRate: outliers / Math.max(values.length, 1),
+      scaleRatio: 0,
+      issues: [],
+      score: 0
+    });
+  }
+  const medianAbsValues = numericStats.map((item) => Math.abs(item.median)).filter((value) => value > 0).sort((a, b) => a - b);
+  const globalMedianAbs = quantileSorted(medianAbsValues, 0.5) || 1;
+  for (const stat of numericStats) {
+    const issues = [];
+    let score = 0;
+    const absMedian = Math.abs(stat.median);
+    const absP99 = Math.abs(stat.p99);
+    const p99ToMedian = absP99 / Math.max(absMedian, 1e-12);
+    const scaleRatio = absMedian / globalMedianAbs;
+    const hasStableMedian = absMedian >= 1e-4;
+    const isBinary = stat.uniqueCount <= 2;
+    stat.scaleRatio = scaleRatio;
+    if (stat.nonFiniteRate > 0) {
+      issues.push("has NaN/Inf values");
+      score += 5;
+    }
+    if (stat.missingRate > 0.2) {
+      issues.push(`high missing rate ${(stat.missingRate * 100).toFixed(1)}%`);
+      score += 4;
+    } else if (stat.missingRate > 0.05) {
+      issues.push(
+        `noticeable missing rate ${(stat.missingRate * 100).toFixed(1)}%`
+      );
+      score += 2;
+    }
+    if (stat.validCount > 0 && stat.uniqueCount <= 1) {
+      issues.push("constant value (no signal for model)");
+      score += 5;
+    }
+    if (stat.zeroRate > 0.98) {
+      issues.push(`almost always zero ${(stat.zeroRate * 100).toFixed(1)}%`);
+      score += 4;
+    } else if (stat.zeroRate > 0.9) {
+      issues.push(`mostly zero ${(stat.zeroRate * 100).toFixed(1)}%`);
+      score += 2;
+    }
+    if (hasStableMedian) {
+      if (p99ToMedian > 1e3) {
+        issues.push(
+          `extreme scale spread p99/median=${p99ToMedian.toFixed(0)}`
+        );
+        score += 5;
+      } else if (p99ToMedian > 100) {
+        issues.push(`large scale spread p99/median=${p99ToMedian.toFixed(0)}`);
+        score += 3;
+      }
+    }
+    if (stat.outlierRate > 0.1) {
+      issues.push(
+        `very high outlier rate ${(stat.outlierRate * 100).toFixed(1)}%`
+      );
+      score += 4;
+    } else if (stat.outlierRate > 0.03) {
+      issues.push(`high outlier rate ${(stat.outlierRate * 100).toFixed(1)}%`);
+      score += 2;
+    }
+    if (!isBinary && (scaleRatio > 1e3 || scaleRatio < 1e-3)) {
+      issues.push(
+        `feature scale differs from dataset median by x${scaleRatio.toExponential(2)}`
+      );
+      score += 3;
+    }
+    stat.issues = issues;
+    stat.score = score;
+  }
+  numericStats.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.outlierRate - a.outlierRate;
+  });
+  return numericStats;
+};
+var formatNumber = (value) => {
+  if (!Number.isFinite(value)) return "n/a";
+  const abs = Math.abs(value);
+  if (abs >= 1e6 || abs > 0 && abs < 1e-4) {
+    return value.toExponential(3);
+  }
+  return value.toFixed(6);
+};
+var runQuickInspect = async (params) => {
+  const { datasetPath, mode, rowsToInspect, limitIssues, minFieldValues } = params;
+  let rows = [];
+  if (mode === "head") {
+    rows = await readRowsHead(datasetPath, rowsToInspect);
+  } else if (mode === "tail") {
+    rows = await readRowsTail(datasetPath, rowsToInspect);
+  } else {
+    rows = await readRowsSample(datasetPath, rowsToInspect);
+  }
+  if (!rows.length) {
+    console.error(import_chalk.default.red("No rows could be read from dataset."));
+    process.exit(1);
+  }
+  const numericStats = buildNumericStats(rows, minFieldValues);
+  if (!numericStats.length) {
+    console.error(
+      import_chalk.default.red(
+        "No numeric fields with enough values were found in sampled rows."
+      )
+    );
+    process.exit(1);
+  }
+  const problematic = numericStats.filter((item) => item.score > 0);
+  console.log(import_chalk.default.gray("ML dataset inspection (quick)"));
+  console.log(import_chalk.default.gray(`file: ${datasetPath}`));
+  console.log(import_chalk.default.gray(`mode: ${mode}`));
+  console.log(import_chalk.default.gray(`rows inspected: ${rows.length}`));
+  console.log(import_chalk.default.gray(`numeric fields analyzed: ${numericStats.length}`));
+  console.log(import_chalk.default.gray(`fields with recommendations: ${problematic.length}`));
+  console.log("");
+  if (!problematic.length) {
+    console.log(
+      import_chalk.default.green("No problematic fields detected by current rules.")
+    );
+    process.exit(0);
+  }
+  const top = problematic.slice(0, limitIssues);
+  for (const item of top) {
+    console.log(import_chalk.default.yellow(item.field));
+    console.log(
+      `  score=${item.score} issues=${item.issues.join("; ") || "none"}`
+    );
+    console.log(
+      `  median=${formatNumber(item.median)} p99=${formatNumber(item.p99)} min=${formatNumber(item.min)} max=${formatNumber(item.max)}`
+    );
+    console.log(
+      `  missing=${(item.missingRate * 100).toFixed(2)}% nonFinite=${(item.nonFiniteRate * 100).toFixed(2)}% outliers=${(item.outlierRate * 100).toFixed(2)}% zeros=${(item.zeroRate * 100).toFixed(2)}%`
+    );
+  }
+  if (problematic.length > limitIssues) {
+    console.log("");
+    console.log(
+      import_chalk.default.gray(
+        `... ${problematic.length - limitIssues} more fields hidden (raise --limitIssues)`
+      )
+    );
+  }
+  console.log("");
+  console.log(import_chalk.default.cyan("How to fix common issues:"));
+  console.log(
+    "  - Large scale spread: normalize feature (log1p / relative to price / robust scaling)."
+  );
+  console.log(
+    "  - High outliers: winsorize/clip or rebuild the source transform."
+  );
+  console.log("  - Missing values: fill consistently or remove the feature.");
+  console.log(
+    "  - Constant/mostly zero: drop the feature or redefine its window."
+  );
+};
+var runYDataInspect = async (params) => {
+  const { datasetPath, mode, rowsToInspect } = params;
+  const cwd = process.cwd();
+  const absDatasetPath = import_path.default.resolve(datasetPath);
+  const dataRoot = import_path.default.resolve(cwd, "data");
+  if (!absDatasetPath.startsWith(dataRoot)) {
+    console.error(
+      import_chalk.default.red(
+        `ydata mode supports only files under ${dataRoot}. Use --file inside data/`
+      )
+    );
+    process.exit(1);
+  }
+  const relToData = import_path.default.relative(dataRoot, absDatasetPath);
+  const inputInContainer = `/app/data/${relToData}`;
+  const reportDir = import_path.default.dirname(absDatasetPath);
+  await import_promises.default.mkdir(reportDir, { recursive: true });
+  const reportPath = import_path.default.join(
+    reportDir,
+    `${import_path.default.basename(datasetPath, import_path.default.extname(datasetPath))}.profile.html`
+  );
+  const reportRelToData = import_path.default.relative(dataRoot, reportPath);
+  const reportInContainer = `/app/data/${reportRelToData}`;
+  console.log(
+    import_chalk.default.gray(
+      "Running ydata-profiling report via docker ml-profile service..."
+    )
+  );
+  const result = (0, import_child_process.spawnSync)(
+    "docker",
+    [
+      "compose",
+      "-f",
+      "docker-compose.ml.yml",
+      "run",
+      "--rm",
+      "ml-profile",
+      "python",
+      "/app/ml/profile.py",
+      "--input",
+      inputInContainer,
+      "--rows",
+      String(rowsToInspect),
+      "--mode",
+      mode,
+      "--output",
+      reportInContainer,
+      "--title",
+      `ML Profile: ${import_path.default.basename(datasetPath)}`
+    ],
+    {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        PYTHONUNBUFFERED: "1"
+      }
+    }
+  );
+  if ((result.status ?? 1) !== 0) {
+    console.error(
+      import_chalk.default.red(
+        "ydata-profiling failed. Build profile image first: docker compose -f docker-compose.ml.yml build ml-profile"
+      )
+    );
+    process.exit(result.status ?? 1);
+  }
+  console.log(import_chalk.default.green(`Profile report saved: ${reportPath}`));
+};
+var main = async () => {
+  const dir = String(flags.dir || "data/ml/export");
+  const rowsToInspect = asPositiveInt(flags.rows, 1e4);
+  const mode = toMode(flags.mode);
+  const strategy = String(flags.strategy || "");
+  const limitIssues = asPositiveInt(flags.limitIssues, 25);
+  const minFieldValues = asPositiveInt(flags.minFieldValues, 50);
+  const toolFromFlags = toInspectTool(flags.tool);
+  const explicitFile = flags.file ? String(flags.file) : "";
+  const datasetPath = explicitFile || await findLatestDataset({
+    dir,
+    strategy
+  });
+  if (!datasetPath) {
+    console.error(
+      import_chalk.default.red(`No dataset found. Expected ml-dataset-*.jsonl in ${dir}`)
+    );
+    process.exit(1);
+  }
+  const tool = toolFromFlags ?? await selectInspectTool("quick");
+  if (tool === "ydata") {
+    await runYDataInspect({
+      datasetPath,
+      mode,
+      rowsToInspect
+    });
+    return;
+  }
+  await runQuickInspect({
+    datasetPath,
+    mode,
+    rowsToInspect,
+    limitIssues,
+    minFieldValues
+  });
+};
+main().catch((err) => {
+  console.error("ml-inspect failed:", err);
+  process.exit(1);
+});