@yabasha/gex 1.0.1 → 1.3.0

package/dist/cli-node.cjs

@@ -0,0 +1,766 @@
+#!/usr/bin/env node
+"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/runtimes/node/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+
+// src/runtimes/node/commands.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var import_commander = require("commander");
+
+// src/shared/cli/install.ts
+var INSTALL_COMMANDS = {
+  npm: {
+    global: ["i", "-g"],
+    local: ["i"],
+    dev: ["i", "-D"]
+  },
+  bun: {
+    global: ["add", "-g"],
+    local: ["add"],
+    dev: ["add", "-d"]
+  }
+};
+var MAX_BUFFER = 10 * 1024 * 1024;
+function formatSpec(pkg) {
+  return pkg.version ? `${pkg.name}@${pkg.version}` : pkg.name;
+}
+async function getExecFileAsync() {
+  const { execFile } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  return promisify2(execFile);
+}
+async function installFromReport(report, options) {
+  const opts = typeof options === "string" ? { cwd: options } : options;
+  const { cwd, packageManager = "npm" } = opts;
+  const globalPkgs = report.global_packages.map(formatSpec).filter(Boolean);
+  const localPkgs = report.local_dependencies.map(formatSpec).filter(Boolean);
+  const devPkgs = report.local_dev_dependencies.map(formatSpec).filter(Boolean);
+  if (globalPkgs.length === 0 && localPkgs.length === 0 && devPkgs.length === 0) {
+    console.log("No packages to install from report.");
+    return;
+  }
+  const execFileAsync = await getExecFileAsync();
+  const cmd = INSTALL_COMMANDS[packageManager];
+  const binary = packageManager === "bun" ? "bun" : "npm";
+  if (globalPkgs.length > 0) {
+    console.log(`Installing global: ${globalPkgs.join(" ")}`);
+    await execFileAsync(binary, [...cmd.global, ...globalPkgs], { cwd, maxBuffer: MAX_BUFFER });
+  }
+  if (localPkgs.length > 0) {
+    console.log(`Installing local deps: ${localPkgs.join(" ")}`);
+    await execFileAsync(binary, [...cmd.local, ...localPkgs], { cwd, maxBuffer: MAX_BUFFER });
+  }
+  if (devPkgs.length > 0) {
+    console.log(`Installing local devDeps: ${devPkgs.join(" ")}`);
+    await execFileAsync(binary, [...cmd.dev, ...devPkgs], { cwd, maxBuffer: MAX_BUFFER });
+  }
+}
+function printFromReport(report) {
+  const lines = [];
+  if (report.global_packages.length > 0) {
+    lines.push("Global Packages:");
+    for (const p of report.global_packages) {
+      lines.push(`- ${p.name}@${p.version}`);
+    }
+  }
+  if (report.local_dependencies.length > 0) {
+    if (lines.length) lines.push("");
+    lines.push("Local Dependencies:");
+    for (const p of report.local_dependencies) {
+      lines.push(`- ${p.name}@${p.version}`);
+    }
+  }
+  if (report.local_dev_dependencies.length > 0) {
+    if (lines.length) lines.push("");
+    lines.push("Local Dev Dependencies:");
+    for (const p of report.local_dev_dependencies) {
+      lines.push(`- ${p.name}@${p.version}`);
+    }
+  }
+  if (lines.length === 0) {
+    lines.push("(no packages found in report)");
+  }
+  console.log(lines.join("\n"));
+}
+
+// src/shared/cli/output.ts
+var import_node_path = __toESM(require("path"), 1);
+
+// src/shared/report/json.ts
+function renderJson(report) {
+  const r = {
+    ...report,
+    global_packages: [...report.global_packages].sort((a, b) => a.name.localeCompare(b.name)),
+    local_dependencies: [...report.local_dependencies].sort((a, b) => a.name.localeCompare(b.name)),
+    local_dev_dependencies: [...report.local_dev_dependencies].sort(
+      (a, b) => a.name.localeCompare(b.name)
+    )
+  };
+  return JSON.stringify(r, null, 2);
+}
+
+// src/shared/report/md.ts
+function table(headers, rows) {
+  const header = `| ${headers.join(" | ")} |`;
+  const sep = `| ${headers.map(() => "---").join(" | ")} |`;
+  const body = rows.map((r) => `| ${r.join(" | ")} |`).join("\n");
+  return [header, sep, body].filter(Boolean).join("\n");
+}
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push("# GEX Report");
+  lines.push("");
+  if (report.project_name || report.project_version || report.project_description || report.project_homepage || report.project_bugs) {
+    lines.push("## Project Metadata");
+    if (report.project_name) lines.push(`- Name: ${report.project_name}`);
+    if (report.project_version) lines.push(`- Version: ${report.project_version}`);
+    if (report.project_description)
+      lines.push(`- Description: ${report.project_description}`);
+    if (report.project_homepage)
+      lines.push(`- Homepage: ${report.project_homepage}`);
+    if (report.project_bugs) lines.push(`- Bugs: ${report.project_bugs}`);
+    lines.push("");
+  }
+  if (report.global_packages.length > 0) {
+    lines.push("## Global Packages");
+    const rows = report.global_packages.map((p) => [p.name, p.version || "", p.resolved_path || ""]);
+    lines.push(table(["Name", "Version", "Path"], rows));
+    lines.push("");
+  }
+  if (report.local_dependencies.length > 0) {
+    lines.push("## Local Dependencies");
+    const rows = report.local_dependencies.map((p) => [
+      p.name,
+      p.version || "",
+      p.resolved_path || ""
+    ]);
+    lines.push(table(["Name", "Version", "Path"], rows));
+    lines.push("");
+  }
+  if (report.local_dev_dependencies.length > 0) {
+    lines.push("## Local Dev Dependencies");
+    const rows = report.local_dev_dependencies.map((p) => [
+      p.name,
+      p.version || "",
+      p.resolved_path || ""
+    ]);
+    lines.push(table(["Name", "Version", "Path"], rows));
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("_Generated by GEX_");
+  return lines.join("\n");
+}
+
+// src/shared/cli/output.ts
+async function outputReport(report, format, outFile, markdownExtras) {
+  const content = format === "json" ? renderJson(report) : renderMarkdown({ ...report, ...markdownExtras || {} });
+  if (outFile) {
+    const outDir = import_node_path.default.dirname(outFile);
+    const { mkdir, writeFile } = await import("fs/promises");
+    await mkdir(outDir, { recursive: true });
+    await writeFile(outFile, content, "utf8");
+    console.log(`Wrote report to ${outFile}`);
+  } else {
+    console.log(content);
+  }
+}
+
+// src/shared/cli/parser.ts
+var import_promises = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+function isMarkdownReportFile(filePath) {
+  const ext = import_node_path2.default.extname(filePath).toLowerCase();
+  return ext === ".md" || ext === ".markdown";
+}
+function parseMarkdownPackagesTable(lines, startIndex) {
+  const rows = [];
+  if (!lines[startIndex] || !lines[startIndex].trim().startsWith("|")) return rows;
+  let i = startIndex + 2;
+  while (i < lines.length && lines[i].trim().startsWith("|")) {
+    const cols = lines[i].split("|").map((c) => c.trim()).filter((_, idx, arr) => !(idx === 0 || idx === arr.length - 1));
+    const [name = "", version = "", resolved_path = ""] = cols;
+    if (name) rows.push({ name, version, resolved_path });
+    i++;
+  }
+  return rows;
+}
+function parseMarkdownReport(md) {
+  const lines = md.split(/\r?\n/);
+  const findSection = (title) => lines.findIndex((l) => l.trim().toLowerCase() === `## ${title}`.toLowerCase());
+  const parseSection = (idx) => {
+    if (idx < 0) return [];
+    let i = idx + 1;
+    while (i < lines.length && !lines[i].trim().startsWith("|")) i++;
+    return parseMarkdownPackagesTable(lines, i);
+  };
+  const global_packages = parseSection(findSection("Global Packages"));
+  const local_dependencies = parseSection(findSection("Local Dependencies"));
+  const local_dev_dependencies = parseSection(findSection("Local Dev Dependencies"));
+  const report = {
+    report_version: "1.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool_version: "unknown",
+    global_packages,
+    local_dependencies,
+    local_dev_dependencies
+  };
+  return report;
+}
+async function loadReportFromFile(reportPath) {
+  const raw = await (0, import_promises.readFile)(reportPath, "utf8");
+  if (isMarkdownReportFile(reportPath) || raw.startsWith("# GEX Report")) {
+    return parseMarkdownReport(raw);
+  }
+  return JSON.parse(raw);
+}
+
+// src/shared/npm-cli.ts
+var import_node_util = require("util");
+async function getExecFileAsync2() {
+  const { execFile } = await import("child_process");
+  return (0, import_node_util.promisify)(execFile);
+}
+async function npmOutdated(options = {}) {
+  const args = ["outdated", "--json"];
+  if (options.global) args.push("--global");
+  try {
+    const execFileAsync = await getExecFileAsync2();
+    const { stdout } = await execFileAsync("npm", args, {
+      cwd: options.cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return normalizeOutdated(stdout);
+  } catch (error) {
+    const stdout = typeof error?.stdout === "string" ? error.stdout : "";
+    if (stdout.trim()) {
+      return normalizeOutdated(stdout);
+    }
+    throw formatNpmError(error, "npm outdated");
+  }
+}
+async function npmUpdate(options) {
+  const args = ["update"];
+  if (options.global) args.push("-g");
+  if (options.packages && options.packages.length > 0) args.push(...options.packages);
+  try {
+    const execFileAsync = await getExecFileAsync2();
+    await execFileAsync("npm", args, {
+      cwd: options.cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch (error) {
+    throw formatNpmError(error, "npm update");
+  }
+}
+function normalizeOutdated(stdout) {
+  if (!stdout.trim()) return [];
+  let data;
+  try {
+    data = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  if (!data) return [];
+  return Object.entries(data).map(([name, info]) => ({
+    name,
+    current: info?.current ? String(info.current) : "",
+    wanted: info?.wanted ? String(info.wanted) : "",
+    latest: info?.latest ? String(info.latest) : "",
+    type: info?.type ? String(info.type) : void 0
+  }));
+}
+function formatNpmError(error, commandLabel) {
+  const stderr = typeof error?.stderr === "string" ? error.stderr.trim() : "";
+  const message = stderr || error?.message || `${commandLabel} failed`;
+  return new Error(`${commandLabel} failed: ${message}`);
+}
+
+// src/shared/cli/loader.ts
+var frames = ["-", "\\", "|", "/"];
+function createLoader(message) {
+  if (!process.stdout.isTTY) {
+    console.log(`${message}...`);
+    return {
+      stop(finalMessage) {
+        if (finalMessage) console.log(finalMessage);
+      }
+    };
+  }
+  let index = 0;
+  const interval = setInterval(() => {
+    const frame = frames[index % frames.length];
+    index += 1;
+    process.stdout.write(`\r${message} ${frame}`);
+  }, 80);
+  return {
+    stop(finalMessage) {
+      clearInterval(interval);
+      process.stdout.write("\r");
+      if (finalMessage) {
+        console.log(finalMessage);
+      } else {
+        process.stdout.write("\x1B[2K");
+      }
+    }
+  };
+}
+
+// src/shared/cli/outdated.ts
+function normalizeUpdateSelection(value) {
+  if (value === void 0) {
+    return { shouldUpdate: false, updateAll: false, packages: [] };
+  }
+  if (value === true) {
+    return { shouldUpdate: true, updateAll: true, packages: [] };
+  }
+  const packages = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  const normalized = packages.flatMap((entry) => String(entry).split(",").map((part) => part.trim())).filter(Boolean);
+  return {
+    shouldUpdate: true,
+    updateAll: false,
+    packages: normalized
+  };
+}
+function formatOutdatedTable(entries) {
+  const headers = ["Name", "Current", "Wanted", "Latest", "Type"];
+  const rows = entries.map((entry) => [
+    entry.name,
+    entry.current || "-",
+    entry.wanted || "-",
+    entry.latest || "-",
+    entry.type || "-"
+  ]);
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => row[index].length))
+  );
+  const formatRow = (columns) => columns.map((col, idx) => col.padEnd(widths[idx], " ")).join("  ");
+  const lines = [formatRow(headers), formatRow(widths.map((w) => "-".repeat(w)))];
+  for (const row of rows) {
+    lines.push(formatRow(row));
+  }
+  return lines.join("\n");
+}
+async function handleOutdatedWorkflow(opts) {
+  if (!opts.checkOutdated && !opts.selection.shouldUpdate) {
+    return true;
+  }
+  let fetchLoader;
+  if (opts.checkOutdated || opts.selection.shouldUpdate) {
+    fetchLoader = createLoader("Checking for outdated packages");
+  }
+  const outdated = await opts.fetchOutdated();
+  fetchLoader?.stop("Finished checking outdated packages.");
+  if (opts.checkOutdated) {
+    if (outdated.length === 0) {
+      console.log(`All ${opts.contextLabel} packages are up to date.`);
+    } else {
+      console.log(formatOutdatedTable(outdated));
+    }
+  }
+  if (opts.selection.shouldUpdate && opts.updateRunner) {
+    const packagesToUpdate = opts.selection.updateAll ? outdated.map((entry) => entry.name) : opts.selection.packages;
+    if (!packagesToUpdate || packagesToUpdate.length === 0) {
+      if (opts.selection.updateAll) {
+        console.log("No outdated packages to update.");
+      } else {
+        console.log("No packages were specified for updating.");
+      }
+    } else {
+      const updateLoader = createLoader("Updating packages");
+      await opts.updateRunner(packagesToUpdate);
+      updateLoader.stop("Finished updating packages.");
+    }
+  }
+  if (opts.checkOutdated || opts.selection.shouldUpdate) {
+    if (!opts.outFile) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/shared/cli/utils.ts
+var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_meta = {};
+function getPkgJsonPath() {
+  let startDir;
+  try {
+    const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
+    startDir = import_node_path3.default.dirname(__filename);
+  } catch {
+    startDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  }
+  return findPackageJson(startDir);
+}
+function findPackageJson(startDir) {
+  let current = startDir;
+  const maxDepth = 6;
+  for (let i = 0; i < maxDepth; i++) {
+    const candidate = import_node_path3.default.resolve(current, "package.json");
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return candidate;
+    }
+    const parent = import_node_path3.default.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return import_node_path3.default.resolve(process.cwd(), "package.json");
+}
+async function getToolVersion() {
+  try {
+    const pkgPath = getPkgJsonPath();
+    const raw = await (0, import_promises2.readFile)(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var ASCII_BANNER = String.raw`
+  ________                __
+ /  _____/  ____   _____/  |_  ____   ____
+/   \  ___ /  _ \ /  _ \   __\/ __ \ /    \
+\    \_\  (  <_> |  <_> )  | \  ___/|   |  \
+ \______  /\____/ \____/|__|  \___  >___|  /
+        \/                         \/     \/
+                      GEX
+`;
+
+// src/runtimes/node/report.ts
+var import_promises4 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// src/shared/transform.ts
+var import_node_path4 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+function toPkgArray(obj) {
+  if (!obj) return [];
+  return Object.keys(obj).map((name) => ({ name, node: obj[name] })).filter((p) => p && p.node);
+}
+async function buildReportFromNpmTree(tree, opts) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const report = {
+    report_version: "1.0",
+    timestamp,
+    tool_version: opts.toolVersion,
+    global_packages: [],
+    local_dependencies: [],
+    local_dev_dependencies: []
+  };
+  if (opts.context === "local") {
+    let pkgMeta = null;
+    try {
+      const pkgJsonPath = import_node_path4.default.join(opts.cwd || process.cwd(), "package.json");
+      const raw = await (0, import_promises3.readFile)(pkgJsonPath, "utf8");
+      pkgMeta = JSON.parse(raw);
+    } catch {
+    }
+    if (pkgMeta?.name) report.project_name = pkgMeta.name;
+    if (pkgMeta?.version) report.project_version = pkgMeta.version;
+    const depsObj = tree?.dependencies;
+    const devDepsObj = tree?.devDependencies;
+    const prodItems = toPkgArray(depsObj);
+    const treeDevItems = toPkgArray(devDepsObj);
+    if (treeDevItems.length > 0) {
+      for (const { name, node } of treeDevItems) {
+        const version = node && node.version || "";
+        const resolvedPath = node && node.path || import_node_path4.default.join(opts.cwd || process.cwd(), "node_modules", name);
+        report.local_dev_dependencies.push({ name, version, resolved_path: resolvedPath });
+      }
+    }
+    const devKeys = treeDevItems.length > 0 ? new Set(treeDevItems.map((entry) => entry.name)) : new Set(Object.keys(pkgMeta?.devDependencies || {}));
+    for (const { name, node } of prodItems) {
+      const version = node && node.version || "";
+      const resolvedPath = node && node.path || import_node_path4.default.join(opts.cwd || process.cwd(), "node_modules", name);
+      const pkg = { name, version, resolved_path: resolvedPath };
+      if (!treeDevItems.length && devKeys.has(name)) {
+        report.local_dev_dependencies.push(pkg);
+      } else {
+        report.local_dependencies.push(pkg);
+      }
+    }
+    report.local_dependencies.sort((a, b) => a.name.localeCompare(b.name));
+    report.local_dev_dependencies.sort((a, b) => a.name.localeCompare(b.name));
+  } else if (opts.context === "global") {
+    const depsObj = tree?.dependencies;
+    const items = toPkgArray(depsObj);
+    for (const { name, node } of items) {
+      const version = node && node.version || "";
+      const resolvedPath = node && node.path || import_node_path4.default.join(opts.globalRoot || "", name);
+      const pkg = { name, version, resolved_path: resolvedPath };
+      report.global_packages.push(pkg);
+    }
+    report.global_packages.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  if (opts.includeTree) {
+    report.tree = tree;
+  }
+  return report;
+}
+
+// src/runtimes/node/package-manager.ts
+async function getExecFileAsync3() {
+  const { execFile } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  return promisify2(execFile);
+}
+async function npmLs(options = {}) {
+  const args = ["ls", "--json"];
+  if (options.global) args.push("--global");
+  if (options.omitDev) args.push("--omit=dev");
+  if (options.depth0) args.push("--depth=0");
+  try {
+    const execFileAsync = await getExecFileAsync3();
+    const { stdout } = await execFileAsync("npm", args, {
+      cwd: options.cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    if (stdout && stdout.trim()) return JSON.parse(stdout);
+    return {};
+  } catch (err) {
+    const stdout = err?.stdout;
+    if (typeof stdout === "string" && stdout.trim()) {
+      try {
+        return JSON.parse(stdout);
+      } catch (parseErr) {
+        if (process.env.DEBUG?.includes("gex")) {
+          console.warn("npm ls stdout parse failed:", parseErr);
+        }
+      }
+    }
+    const stderr = err?.stderr;
+    const msg = typeof stderr === "string" && stderr.trim() || err?.message || "npm ls failed";
+    throw new Error(`npm ls failed: ${msg}`);
+  }
+}
+async function npmRootGlobal() {
+  try {
+    const execFileAsync = await getExecFileAsync3();
+    const { stdout } = await execFileAsync("npm", ["root", "-g"]);
+    return stdout.trim();
+  } catch (err) {
+    const stderr = err?.stderr;
+    const msg = typeof stderr === "string" && stderr.trim() || err?.message || "npm root -g failed";
+    throw new Error(`npm root -g failed: ${msg}`);
+  }
+}
+
+// src/runtimes/node/report.ts
+async function produceReport(ctx, options) {
+  const toolVersion = await getToolVersion();
+  const depth0 = !options.fullTree;
+  const cwd = options.cwd || process.cwd();
+  const tree = await npmLs({
+    global: ctx === "global",
+    omitDev: ctx === "local" ? Boolean(options.omitDev) : false,
+    depth0,
+    cwd
+  });
+  let project_description;
+  let project_homepage;
+  let project_bugs;
+  if (ctx === "local") {
+    try {
+      const pkgRaw = await (0, import_promises4.readFile)(import_node_path5.default.join(cwd, "package.json"), "utf8");
+      const pkg = JSON.parse(pkgRaw);
+      project_description = pkg.description;
+      project_homepage = pkg.homepage;
+      if (typeof pkg.bugs === "string") project_bugs = pkg.bugs;
+      else if (pkg.bugs && typeof pkg.bugs.url === "string") project_bugs = pkg.bugs.url;
+    } catch {
+    }
+  }
+  const globalRoot = ctx === "global" ? await npmRootGlobal().catch(() => void 0) : void 0;
+  const report = await buildReportFromNpmTree(tree, {
+    context: ctx,
+    includeTree: Boolean(options.fullTree),
+    omitDev: Boolean(options.omitDev),
+    cwd,
+    toolVersion,
+    globalRoot
+  });
+  const markdownExtras = { project_description, project_homepage, project_bugs };
+  return { report, markdownExtras };
+}
+
+// src/runtimes/node/commands.ts
+function addCommonOptions(cmd, { allowOmitDev }) {
+  cmd.option(
+    "-f, --output-format <format>",
+    "Output format: md or json",
+    (val) => val === "md" ? "md" : "json",
+    "json"
+  ).option("-o, --out-file <path>", "Write report to file").option("--full-tree", "Include full npm ls tree (omit depth=0 default)", false).option("-c, --check-outdated", "List outdated packages instead of printing the report", false).option(
+    "-u, --update-outdated [packages...]",
+    "Update outdated packages (omit package names to update every package)"
+  );
+  if (allowOmitDev) {
+    cmd.option("--omit-dev", "Exclude devDependencies (local only)", false);
+  }
+  return cmd;
+}
+function createLocalCommand(program) {
+  const localCmd = program.command("local", { isDefault: true }).description("Generate a report for the current project's dependencies");
+  addCommonOptions(localCmd, { allowOmitDev: true });
+  localCmd.action(async (opts) => {
+    const outputFormat = opts.outputFormat ?? "json";
+    const outFile = opts.outFile;
+    const fullTree = Boolean(opts.fullTree);
+    const omitDev = Boolean(opts.omitDev);
+    const cwd = process.cwd();
+    const selection = normalizeUpdateSelection(opts.updateOutdated);
+    const proceed = await handleOutdatedWorkflow({
+      checkOutdated: Boolean(opts.checkOutdated),
+      selection,
+      contextLabel: "local",
+      outFile,
+      fetchOutdated: () => npmOutdated({ cwd }),
+      updateRunner: selection.shouldUpdate ? async (packages) => {
+        await npmUpdate({ cwd, packages });
+      } : void 0
+    });
+    if (!proceed) return;
+    const finalOutFile = outFile;
+    const { report, markdownExtras } = await produceReport("local", {
+      outputFormat,
+      outFile: finalOutFile,
+      fullTree,
+      omitDev
+    });
+    await outputReport(report, outputFormat, finalOutFile, markdownExtras);
+  });
+  return localCmd;
+}
+function createGlobalCommand(program) {
+  const globalCmd = program.command("global").description("Generate a report of globally installed packages");
+  addCommonOptions(globalCmd, { allowOmitDev: false });
+  globalCmd.action(async (opts) => {
+    const outputFormat = opts.outputFormat ?? "json";
+    const outFile = opts.outFile;
+    const fullTree = Boolean(opts.fullTree);
+    const cwd = process.cwd();
+    const selection = normalizeUpdateSelection(opts.updateOutdated);
+    const proceed = await handleOutdatedWorkflow({
+      checkOutdated: Boolean(opts.checkOutdated),
+      selection,
+      contextLabel: "global",
+      outFile,
+      fetchOutdated: () => npmOutdated({ cwd, global: true }),
+      updateRunner: selection.shouldUpdate ? async (packages) => {
+        await npmUpdate({ cwd, global: true, packages });
+      } : void 0
+    });
+    if (!proceed) return;
+    const finalOutFile = outFile;
+    const { report, markdownExtras } = await produceReport("global", {
+      outputFormat,
+      outFile: finalOutFile,
+      fullTree
+    });
+    await outputReport(report, outputFormat, finalOutFile, markdownExtras);
+  });
+  return globalCmd;
+}
+function createReadCommand(program) {
+  const readCmd = program.command("read").description(
+    "Read a previously generated report (JSON or Markdown) and either print package names or install them"
+  ).argument("[report]", "Path to report file (JSON or Markdown)", "gex-report.json").option("-r, --report <path>", "Path to report file (JSON or Markdown)").option("-p, --print", "Print package names/versions from the report (default)", false).option("-i, --install", "Install packages from the report", false);
+  readCmd.action(async (reportArg, opts) => {
+    const chosen = opts.report || reportArg || "gex-report.json";
+    const reportPath = import_node_path6.default.resolve(process.cwd(), chosen);
+    try {
+      const parsed = await loadReportFromFile(reportPath);
+      const doInstall = Boolean(opts.install);
+      const doPrint = Boolean(opts.print) || !doInstall;
+      if (doPrint) {
+        printFromReport(parsed);
+      }
+      if (doInstall) {
+        await installFromReport(parsed, { cwd: process.cwd(), packageManager: "npm" });
+      }
+    } catch (err) {
+      const isMd = isMarkdownReportFile(reportPath);
+      const hint = isMd ? "Try generating a JSON report with: gex global -f json -o global.json, then: gex read global.json" : "Specify a report path with: gex read <path-to-report.json>";
+      console.error(`Failed to read report at ${reportPath}: ${err?.message || err}`);
+      console.error(hint);
+      process.exitCode = 1;
+    }
+  });
+  return readCmd;
+}
+async function createProgram() {
+  const program = new import_commander.Command().name("gex").description("GEX: Dependency auditing and documentation for Node.js (local and global).").version(await getToolVersion());
+  program.addHelpText("beforeAll", `
+${ASCII_BANNER}`);
+  createLocalCommand(program);
+  createGlobalCommand(program);
+  createReadCommand(program);
+  return program;
+}
+
+// src/runtimes/node/cli.ts
+var import_meta2 = {};
+async function run(argv = process.argv) {
+  const program = await createProgram();
+  await program.parseAsync(argv);
+}
+var isMainModule = (() => {
+  try {
+    if (typeof require !== "undefined" && typeof module !== "undefined") {
+      return require.main === module;
+    }
+    if (typeof import_meta2 !== "undefined") {
+      return import_meta2.url === `file://${process.argv[1]}`;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule) {
+  run().catch((error) => {
+    console.error("CLI error:", error);
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});
+//# sourceMappingURL=cli-node.cjs.map