@yabasha/gex 1.3.5 → 1.3.6

package/dist/cli.cjs

@@ -31,1210 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
-  run: () => run3
+  run: () => run
 });
 module.exports = __toCommonJS(cli_exports);
 var import_node_readline = __toESM(require("readline"), 1);
-
-// 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: promisify3 } = await import("util");
-  return promisify3(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}`);
-}
-async function npmViewVersion(packageName) {
-  try {
-    const execFileAsync = await getExecFileAsync2();
-    const { stdout } = await execFileAsync("npm", ["view", packageName, "version", "--json"], {
-      maxBuffer: 5 * 1024 * 1024
-    });
-    const parsed = JSON.parse(stdout);
-    if (typeof parsed === "string") return parsed;
-    if (Array.isArray(parsed)) return parsed[parsed.length - 1] ?? "";
-    return "";
-  } catch (error) {
-    throw formatNpmError(error, `npm view ${packageName}`);
-  }
-}
-
-// 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 = globalThis.setInterval(() => {
-    const frame = frames[index % frames.length];
-    index += 1;
-    process.stdout.write(`\r${message} ${frame}`);
-  }, 80);
-  return {
-    stop(finalMessage) {
-      globalThis.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 { proceed: true, outdated: [] };
-  }
-  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.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.");
-    }
-  }
-  const proceed = !((opts.checkOutdated || opts.selection.shouldUpdate) && !opts.outFile);
-  return { proceed, outdated };
-}
-async function resolveOutdatedWithNpmView(packages) {
-  const results = [];
-  for (const pkg of packages) {
-    try {
-      const latest = await npmViewVersion(pkg.name);
-      if (latest && pkg.current && latest !== pkg.current) {
-        results.push({
-          name: pkg.name,
-          current: pkg.current,
-          wanted: pkg.declared || latest,
-          latest,
-          type: pkg.type
-        });
-      }
-    } catch {
-      continue;
-    }
-  }
-  return results;
-}
-
-// 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: promisify3 } = await import("util");
-  return promisify3(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 result = 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 (opts.checkOutdated) {
-      if (result.outdated.length === 0) console.log("All local packages are up to date.");
-      else console.log(formatOutdatedTable(result.outdated));
-    }
-    if (!result.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 result = 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 (opts.checkOutdated) {
-      if (result.outdated.length === 0) console.log("All global packages are up to date.");
-      else console.log(formatOutdatedTable(result.outdated));
-    }
-    if (!result.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;
-  });
-}
-
-// src/runtimes/bun/commands.ts
-var import_node_path9 = __toESM(require("path"), 1);
-var import_promises7 = require("fs/promises");
-var import_commander2 = require("commander");
-
-// src/runtimes/bun/report.ts
-var import_promises6 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
-
-// src/runtimes/bun/package-manager.ts
-var import_node_path7 = __toESM(require("path"), 1);
-var import_node_fs2 = require("fs");
-var import_promises5 = require("fs/promises");
-var import_node_util2 = require("util");
-var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".bin"]);
-async function bunPmLs(options = {}) {
-  if (options.global) {
-    const root = await bunPmRootGlobal();
-    const manifest2 = await readJson(import_node_path7.default.join(import_node_path7.default.dirname(root), "package.json"));
-    const selections2 = buildSelections(manifest2, { includeDev: false });
-    const dependencies2 = selections2.prod.size > 0 ? await collectPackagesForNames(root, mapSelections(selections2.prod)) : await collectPackagesFromNodeModules(root);
-    return { dependencies: dependencies2, node_modules_path: root };
-  }
-  const cwd = options.cwd || process.cwd();
-  const nodeModulesPath = await bunPmRootLocal(cwd);
-  const manifest = await readJson(import_node_path7.default.join(cwd, "package.json"));
-  const includeDev = !options.omitDev;
-  const selections = buildSelections(manifest, { includeDev });
-  const dependencies = selections.prod.size > 0 ? await collectPackagesForNames(nodeModulesPath, mapSelections(selections.prod)) : await collectPackagesFromNodeModules(nodeModulesPath);
-  let devDependencies;
-  if (includeDev) {
-    if (selections.dev.size > 0) {
-      devDependencies = await collectPackagesForNames(
-        nodeModulesPath,
-        mapSelections(selections.dev)
-      );
-    } else {
-      devDependencies = {};
-    }
-  }
-  return { dependencies, devDependencies, node_modules_path: nodeModulesPath };
-}
-async function bunPmRootGlobal() {
-  if (process.env.GEX_BUN_GLOBAL_ROOT) {
-    return process.env.GEX_BUN_GLOBAL_ROOT;
-  }
-  const candidates = getGlobalRootCandidates();
-  for (const candidate of candidates) {
-    if (candidate && await pathExists(candidate)) {
-      return candidate;
-    }
-  }
-  return candidates.find((c) => Boolean(c)) || import_node_path7.default.join(process.env.HOME || process.cwd(), ".bun", "install", "global", "node_modules");
-}
-async function bunPmRootLocal(cwd = process.cwd()) {
-  if (process.env.GEX_BUN_LOCAL_ROOT) {
-    return process.env.GEX_BUN_LOCAL_ROOT;
-  }
-  return import_node_path7.default.join(cwd, "node_modules");
-}
-async function bunUpdate(options) {
-  const execFileAsync = await getExecFileAsync4();
-  const packages = options.packages && options.packages.length > 0 ? options.packages : [];
-  if (options.global) {
-    const targets = packages.length > 0 ? packages : [];
-    const list = targets.length > 0 ? targets : [];
-    const cmdPackages = list.map((name) => `${name}@latest`);
-    try {
-      await execFileAsync("bun", ["add", "-g", ...cmdPackages], {
-        cwd: options.cwd,
-        maxBuffer: 10 * 1024 * 1024
-      });
-    } catch (error) {
-      const stderr = typeof error?.stderr === "string" ? error.stderr.trim() : "";
-      throw new Error(`bun add -g failed: ${stderr || error?.message || "unknown error"}`);
-    }
-    return;
-  }
-  const args = ["update"];
-  if (packages.length > 0) args.push(...packages);
-  try {
-    await execFileAsync("bun", args, {
-      cwd: options.cwd,
-      maxBuffer: 10 * 1024 * 1024
-    });
-  } catch (error) {
-    const stderr = typeof error?.stderr === "string" ? error.stderr.trim() : "";
-    throw new Error(`bun update failed: ${stderr || error?.message || "unknown error"}`);
-  }
-}
-async function collectPackagesForNames(nodeModulesPath, packages) {
-  const result = {};
-  await Promise.all(
-    packages.map(async ({ name, declared }) => {
-      const pkgDir = packageDir(nodeModulesPath, name);
-      const manifest = await readJson(import_node_path7.default.join(pkgDir, "package.json"));
-      const pkgName = typeof manifest?.name === "string" ? manifest.name : name;
-      const version = typeof manifest?.version === "string" ? manifest.version : declared || "";
-      result[pkgName] = { version, path: pkgDir };
-    })
-  );
-  return result;
-}
-async function collectPackagesFromNodeModules(root) {
-  const result = {};
-  const entries = await safeReadDir(root);
-  for (const entry of entries) {
-    if (!entry || !entry.name || entry.name.startsWith(".") || IGNORED_ENTRIES.has(entry.name)) {
-      continue;
-    }
-    const entryPath = import_node_path7.default.join(root, entry.name);
-    if (!await isDir(entry, entryPath)) continue;
-    if (entry.name.startsWith("@")) {
-      const scopedEntries = await safeReadDir(entryPath);
-      for (const scopedEntry of scopedEntries) {
-        if (!scopedEntry || !scopedEntry.name || scopedEntry.name.startsWith(".")) continue;
-        const scopedPath = import_node_path7.default.join(entryPath, scopedEntry.name);
-        if (!await isDir(scopedEntry, scopedPath)) continue;
-        const manifest = await readJson(import_node_path7.default.join(scopedPath, "package.json"));
-        const pkgName = typeof manifest?.name === "string" ? manifest.name : `${entry.name}/${scopedEntry.name}`;
-        const version = typeof manifest?.version === "string" ? manifest.version : "";
-        result[pkgName] = { version, path: scopedPath };
-      }
-    } else {
-      const manifest = await readJson(import_node_path7.default.join(entryPath, "package.json"));
-      const pkgName = typeof manifest?.name === "string" ? manifest.name : entry.name;
-      const version = typeof manifest?.version === "string" ? manifest.version : "";
-      result[pkgName] = { version, path: entryPath };
-    }
-  }
-  return result;
-}
-async function readJson(file) {
-  try {
-    const raw = await (0, import_promises5.readFile)(file, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function packageDir(root, packageName) {
-  const segments = packageName.startsWith("@") ? packageName.split("/") : [packageName];
-  return import_node_path7.default.join(root, ...segments);
-}
-function buildSelections(manifest, { includeDev }) {
-  const prod = /* @__PURE__ */ new Map();
-  const dev = /* @__PURE__ */ new Map();
-  const addAll = (target, record) => {
-    if (!record) return;
-    for (const [name, range] of Object.entries(record)) {
-      if (!target.has(name)) {
-        target.set(name, range);
-      }
-    }
-  };
-  addAll(prod, manifest?.dependencies);
-  addAll(prod, manifest?.optionalDependencies);
-  if (includeDev) addAll(dev, manifest?.devDependencies);
-  return { prod, dev };
-}
-function mapSelections(map) {
-  return Array.from(map.entries()).map(([name, declared]) => ({ name, declared }));
-}
-async function safeReadDir(dir) {
-  try {
-    return await (0, import_promises5.readdir)(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-async function isDir(entry, fullPath) {
-  if (entry.isDirectory()) return true;
-  if (entry.isSymbolicLink()) {
-    try {
-      const stats = await (0, import_promises5.stat)(fullPath);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-  return false;
-}
-async function pathExists(target) {
-  try {
-    await (0, import_promises5.access)(target, import_node_fs2.constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getGlobalRootCandidates() {
-  const candidates = /* @__PURE__ */ new Set();
-  const bunInstall = process.env.BUN_INSTALL || (process.env.HOME ? import_node_path7.default.join(process.env.HOME, ".bun") : void 0);
-  const maybeAdd = (value) => {
-    if (value) candidates.add(value);
-  };
-  if (bunInstall) {
-    maybeAdd(import_node_path7.default.join(bunInstall, "install", "global", "node_modules"));
-    maybeAdd(import_node_path7.default.join(bunInstall, "global", "node_modules"));
-  }
-  if (process.env.XDG_DATA_HOME) {
-    maybeAdd(import_node_path7.default.join(process.env.XDG_DATA_HOME, "bun", "install", "global", "node_modules"));
-  }
-  maybeAdd("/usr/local/share/bun/global/node_modules");
-  maybeAdd("/opt/homebrew/var/bun/install/global/node_modules");
-  return Array.from(candidates);
-}
-async function getExecFileAsync4() {
-  const { execFile } = await import("child_process");
-  return (0, import_node_util2.promisify)(execFile);
-}
-
-// src/runtimes/bun/report.ts
-async function produceReport2(ctx, options) {
-  const toolVersion = await getToolVersion();
-  const cwd = options.cwd || process.cwd();
-  const tree = await bunPmLs({
-    global: ctx === "global",
-    omitDev: ctx === "local" ? Boolean(options.omitDev) : false,
-    cwd
-  });
-  const nodeModulesPath = tree?.node_modules_path;
-  let project_description;
-  let project_homepage;
-  let project_bugs;
-  if (ctx === "local") {
-    try {
-      const pkgRaw = await (0, import_promises6.readFile)(import_node_path8.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 resolvedRoot = nodeModulesPath ? nodeModulesPath : ctx === "global" ? await bunPmRootGlobal().catch(() => void 0) : await bunPmRootLocal(cwd).catch(() => `${cwd}/node_modules`);
-  const report = await buildReportFromNpmTree(tree, {
-    context: ctx,
-    includeTree: Boolean(options.fullTree),
-    omitDev: Boolean(options.omitDev),
-    cwd,
-    toolVersion,
-    globalRoot: resolvedRoot
-  });
-  const markdownExtras = { project_description, project_homepage, project_bugs };
-  return { report, markdownExtras };
-}
-
-// src/runtimes/bun/commands.ts
-function addCommonOptions2(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 bun pm ls tree (when available)", 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 createLocalCommand2(program) {
-  const localCmd = program.command("local", { isDefault: true }).description("Generate a report for the current Bun project's dependencies");
-  addCommonOptions2(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 result = await handleOutdatedWorkflow({
-      checkOutdated: Boolean(opts.checkOutdated),
-      selection,
-      contextLabel: "local",
-      outFile,
-      fetchOutdated: async () => {
-        const tree = await bunPmLs({ cwd, omitDev });
-        const manifest = await readPackageManifest(cwd);
-        const declared = {
-          ...manifest?.dependencies || {},
-          ...manifest?.optionalDependencies || {},
-          ...manifest?.devDependencies || {}
-        };
-        const packages = Object.entries(tree.dependencies).map(([name, node]) => ({
-          name,
-          current: node.version,
-          declared: declared[name],
-          type: "prod"
-        }));
-        if (tree.devDependencies) {
-          for (const [name, node] of Object.entries(tree.devDependencies)) {
-            packages.push({
-              name,
-              current: node.version,
-              declared: declared[name],
-              type: "dev"
-            });
-          }
-        }
-        return resolveOutdatedWithNpmView(packages);
-      },
-      updateRunner: selection.shouldUpdate ? async (packages) => {
-        await bunUpdate({ cwd, packages });
-      } : void 0
-    });
-    if (opts.checkOutdated) {
-      if (result.outdated.length === 0) console.log("All local packages are up to date.");
-      else console.log(formatOutdatedTable(result.outdated));
-    }
-    if (!result.proceed) return;
-    const finalOutFile = outFile;
-    const { report, markdownExtras } = await produceReport2("local", {
-      outputFormat,
-      outFile: finalOutFile,
-      fullTree,
-      omitDev
-    });
-    await outputReport(report, outputFormat, finalOutFile, markdownExtras);
-  });
-  return localCmd;
-}
-function createGlobalCommand2(program) {
-  const globalCmd = program.command("global").description("Generate a report of globally installed Bun packages");
-  addCommonOptions2(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 result = await handleOutdatedWorkflow({
-      checkOutdated: Boolean(opts.checkOutdated),
-      selection,
-      contextLabel: "global",
-      outFile,
-      fetchOutdated: async () => {
-        const tree = await bunPmLs({ global: true });
-        const packages = Object.entries(tree.dependencies).map(([name, node]) => ({
-          name,
-          current: node.version,
-          type: "global"
-        }));
-        return resolveOutdatedWithNpmView(packages);
-      },
-      updateRunner: selection.shouldUpdate ? async (packages) => {
-        await bunUpdate({ cwd, global: true, packages });
-      } : void 0
-    });
-    if (opts.checkOutdated) {
-      if (result.outdated.length === 0) console.log("All global packages are up to date.");
-      else console.log(formatOutdatedTable(result.outdated));
-    }
-    if (!result.proceed) return;
-    const finalOutFile = outFile;
-    const { report, markdownExtras } = await produceReport2("global", {
-      outputFormat,
-      outFile: finalOutFile,
-      fullTree
-    });
-    await outputReport(report, outputFormat, finalOutFile, markdownExtras);
-  });
-  return globalCmd;
-}
-function createReadCommand2(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)", "bun-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 using Bun", false);
-  readCmd.action(async (reportArg, opts) => {
-    const chosen = opts.report || reportArg || "bun-report.json";
-    const reportPath = import_node_path9.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: "bun" });
-      }
-    } catch (err) {
-      const isMd = isMarkdownReportFile(reportPath);
-      const hint = isMd ? "Try generating a JSON report with: gex-bun global -f json -o global.json, then: gex-bun read global.json" : "Specify a report path with: gex-bun 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 createProgram2() {
-  const program = new import_commander2.Command().name("gex-bun").description("GEX: Dependency auditing and documentation for Bun (local and global).").version(await getToolVersion());
-  program.addHelpText("beforeAll", `
-${ASCII_BANNER}`);
-  createLocalCommand2(program);
-  createGlobalCommand2(program);
-  createReadCommand2(program);
-  return program;
-}
-async function readPackageManifest(cwd) {
-  try {
-    const raw = await (0, import_promises7.readFile)(import_node_path9.default.join(cwd, "package.json"), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-// src/runtimes/bun/cli.ts
-var import_meta3 = {};
-async function run2(argv = process.argv) {
-  const program = await createProgram2();
-  await program.parseAsync(argv);
-}
-var isMainModule2 = (() => {
-  try {
-    if (typeof require !== "undefined" && typeof module !== "undefined") {
-      return require.main === module;
-    }
-    if (typeof import_meta3 !== "undefined") {
-      return import_meta3.url === `file://${process.argv[1]}`;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-})();
-if (isMainModule2) {
-  run2().catch((error) => {
-    console.error("Bun CLI error:", error);
-    process.exitCode = 1;
-  });
-}
-
-// src/cli.ts
-var import_meta4 = {};
 async function promptRuntimeSelection(io = {}) {
   const input = io.input ?? process.stdin;
   const output = io.output ?? process.stdout;
@@ -1258,36 +59,40 @@ async function promptRuntimeSelection(io = {}) {
     });
   });
 }
-async function run3(argv = process.argv, io = {}) {
-  const effectiveArgv = argv ?? process.argv;
+async function run(argv = process.argv, io = {}) {
+  void argv;
   const choice = await promptRuntimeSelection(io);
+  const output = io.output ?? process.stdout;
   if (choice === "bun") {
-    await run2(effectiveArgv);
+    output.write(
+      "\nYou selected the Bun runtime.\nRun `gex-bun [command] [options]` to use the Bun CLI directly.\n"
+    );
     return;
   }
   if (choice === "npm") {
-    await run(effectiveArgv);
+    output.write(
+      "\nYou selected the npm/Node.js runtime.\nRun `gex-npm [command] [options]` to use the Node CLI directly.\n"
+    );
     return;
   }
-  const output = io.output ?? process.stdout;
   output.write("Invalid selection. Please run `gex` again and choose 1 or 2.\n");
   process.exitCode = 1;
 }
-var isMainModule3 = (() => {
+var isMainModule = (() => {
   try {
     if (typeof require !== "undefined" && typeof module !== "undefined") {
       return require.main === module;
     }
-    if (typeof import_meta4 !== "undefined") {
-      return import_meta4.url === `file://${process.argv[1]}`;
+    if (typeof import_meta !== "undefined") {
+      return import_meta.url === `file://${process.argv[1]}`;
     }
     return false;
   } catch {
     return false;
   }
 })();
-if (isMainModule3) {
-  run3().catch((error) => {
+if (isMainModule) {
+  run().catch((error) => {
     console.error("CLI error:", error);
     process.exitCode = 1;
   });