@yabasha/gex 1.3.4 → 1.3.5

package/README.md

@@ -37,15 +37,38 @@ node dist/cli.cjs --help
 
 ## Usage
 
-Synopsis:
+### Top-level entry: `gex` (interactive selector)
+
+Starting with v1.3.5, the primary `gex` binary is an interactive launcher that lets you choose which runtime to use:
+
+```bash
+gex
+```
+
+You will be prompted with:
+
+```text
+Select a runtime to use:
+  1) gex-bun (Bun package manager)
+  2) gex-npm (npm / Node.js package manager)
+```
+
+Enter `1` for the Bun-based CLI (`gex-bun`) or `2` for the Node/npm-based CLI (`gex-npm`). Any additional arguments you pass after `gex` are forwarded to the selected runtime, e.g.:
+
+```bash
+gex local --check-outdated   # choose Bun or npm, then run `local` on that runtime
+```
+
+### Direct runtimes: `gex-npm` (Node) and `gex-bun` (Bun)
+
+You can still call each runtime directly without the interactive selector:
 
 ```bash
-gex [options]          # defaults to: gex local
-gex local [options]
-gex global [options]
+gex-npm [command] [options]   # Node.js / npm runtime (formerly `gex`)
+gex-bun [command] [options]   # Bun runtime
 ```
 
-Common options:
+Common command options:
 
 - -f, --output-format <md|json> (default: json)
 - -o, --out-file <path>
@@ -54,45 +77,45 @@ Common options:
 - -c, --check-outdated Print a table of outdated packages (shows a lightweight spinner while checking; skips console report output unless `-o` is set so you can write the report to file instead)
 - -u, --update-outdated [pkg1 pkg2 ...] Update outdated packages (omit names to update everything). Node CLI shells out to `npm update`; Bun CLI mirrors `bun update` for locals and reinstalls globals via `bun add -g pkg@latest`.
 
-Examples:
+Examples (Node/npm runtime via `gex-npm`):
 
 ```bash
 # Local (default): JSON output to console
-gex                  # prints JSON to console (same as: gex local)
-gex -o report.json   # writes JSON to file
-gex -f md            # prints markdown to console
-gex -f md -o report.md  # writes markdown to file
+gex-npm                 # prints JSON to console (same as: gex-npm local)
+gex-npm -o report.json  # writes JSON to file
+gex-npm -f md           # prints markdown to console
+gex-npm -f md -o report.md  # writes markdown to file
 
 # Local: exclude devDependencies
-gex local --omit-dev    # prints JSON to console
-gex local --omit-dev -o deps.json  # writes JSON to file
+gex-npm local --omit-dev          # prints JSON to console
+gex-npm local --omit-dev -o deps.json  # writes JSON to file
 
 # Global packages
-gex global              # prints JSON to console
-gex global -o global.json  # writes JSON to file
-gex global -f md        # prints markdown to console
+gex-npm global                    # prints JSON to console
+gex-npm global -o global.json     # writes JSON to file
+gex-npm global -f md              # prints markdown to console
 
 # Read a previous report (JSON or Markdown)
 # Default prints names@versions; add -i to install
 # Positional path or -r/--report are accepted
 # JSON
-gex read
-gex read -r path/to/report.json -i
+gex-npm read
+gex-npm read -r path/to/report.json -i
 # Markdown
-gex read global.md
-gex read global.md -i
+gex-npm read global.md
+gex-npm read global.md -i
 
 # Shell redirection (alternative to -o flag)
-gex > report.json           # redirect JSON output to file
-gex global | jq '.global_packages'  # pipe output to jq for processing
+gex-npm > report.json                # redirect JSON output to file
+gex-npm global | jq '.global_packages'  # pipe output to jq for processing
 
 # Check outdated packages / update them (Node runtime)
-gex local --check-outdated                    # show outdated local deps as a table
-gex global -c                                 # short flag works too
-gex local --update-outdated                   # update every outdated local dependency
-gex local -u axios react                      # update specific packages
+gex-npm local --check-outdated                    # show outdated local deps as a table
+gex-npm global -c                                 # short flag works too
+gex-npm local --update-outdated                   # update every outdated local dependency
+gex-npm local -u axios react                      # update specific packages
 
-# Bun runtime uses the same flags
+# Bun runtime uses the same flags with Bun semantics
 gex-bun local --check-outdated
 gex-bun global --update-outdated              # updates global Bun installs via `bun update`/`bun add -g`
 ```

package/dist/cli.cjs

@@ -31,9 +31,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
-  run: () => run2
+  run: () => run3
 });
 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);
@@ -58,8 +59,8 @@ function formatSpec(pkg) {
 }
 async function getExecFileAsync() {
   const { execFile } = await import("child_process");
-  const { promisify: promisify2 } = await import("util");
-  return promisify2(execFile);
+  const { promisify: promisify3 } = await import("util");
+  return promisify3(execFile);
 }
 async function installFromReport(report, options) {
   const opts = typeof options === "string" ? { cwd: options } : options;
@@ -307,6 +308,20 @@ function formatNpmError(error, commandLabel) {
   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 = ["-", "\\", "|", "/"];
@@ -402,6 +417,26 @@ async function handleOutdatedWorkflow(opts) {
   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");
@@ -528,8 +563,8 @@ async function buildReportFromNpmTree(tree, opts) {
 // src/runtimes/node/package-manager.ts
 async function getExecFileAsync3() {
   const { execFile } = await import("child_process");
-  const { promisify: promisify2 } = await import("util");
-  return promisify2(execFile);
+  const { promisify: promisify3 } = await import("util");
+  return promisify3(execFile);
 }
 async function npmLs(options = {}) {
   const args = ["ls", "--json"];
@@ -759,10 +794,424 @@ if (isMainModule) {
   });
 }
 
-// src/cli.ts
+// 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) {
-  return run(argv);
+  const program = await createProgram2();
+  await program.parseAsync(argv);
 }
 var isMainModule2 = (() => {
   try {
@@ -779,6 +1228,66 @@ var isMainModule2 = (() => {
 })();
 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;
+  return new Promise((resolve) => {
+    const rl = import_node_readline.default.createInterface({ input, output });
+    output.write("\nSelect a runtime to use:\n");
+    output.write("  1) gex-bun (Bun package manager)\n");
+    output.write("  2) gex-npm (npm / Node.js package manager)\n\n");
+    rl.question("Enter your choice (1-2): ", (answer) => {
+      rl.close();
+      const choice = answer.trim().toLowerCase();
+      if (choice === "1" || choice === "gex-bun" || choice === "bun") {
+        resolve("bun");
+        return;
+      }
+      if (choice === "2" || choice === "gex-npm" || choice === "gex-node" || choice === "npm" || choice === "node") {
+        resolve("npm");
+        return;
+      }
+      resolve(null);
+    });
+  });
+}
+async function run3(argv = process.argv, io = {}) {
+  const effectiveArgv = argv ?? process.argv;
+  const choice = await promptRuntimeSelection(io);
+  if (choice === "bun") {
+    await run2(effectiveArgv);
+    return;
+  }
+  if (choice === "npm") {
+    await run(effectiveArgv);
+    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 = (() => {
+  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]}`;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule3) {
+  run3().catch((error) => {
     console.error("CLI error:", error);
     process.exitCode = 1;
   });