@yabasha/gex 1.0.1 → 1.3.0

package/dist/cli.mjs

@@ -6,36 +6,56 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/cli/commands.ts
+// src/runtimes/node/commands.ts
 import path6 from "path";
 import { Command } from "commander";
 
-// src/cli/install.ts
+// 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 } = await import("util");
-  return promisify(execFile);
+  const { promisify: promisify2 } = await import("util");
+  return promisify2(execFile);
 }
-async function installFromReport(report, cwd) {
-  const globalPkgs = report.global_packages.map((p) => `${p.name}@${p.version}`).filter(Boolean);
-  const localPkgs = report.local_dependencies.map((p) => `${p.name}@${p.version}`).filter(Boolean);
-  const devPkgs = report.local_dev_dependencies.map((p) => `${p.name}@${p.version}`).filter(Boolean);
+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("npm", ["i", "-g", ...globalPkgs], { cwd, maxBuffer: 10 * 1024 * 1024 });
+    await execFileAsync(binary, [...cmd.global, ...globalPkgs], { cwd, maxBuffer: MAX_BUFFER });
   }
   if (localPkgs.length > 0) {
     console.log(`Installing local deps: ${localPkgs.join(" ")}`);
-    await execFileAsync("npm", ["i", ...localPkgs], { cwd, maxBuffer: 10 * 1024 * 1024 });
+    await execFileAsync(binary, [...cmd.local, ...localPkgs], { cwd, maxBuffer: MAX_BUFFER });
   }
   if (devPkgs.length > 0) {
     console.log(`Installing local devDeps: ${devPkgs.join(" ")}`);
-    await execFileAsync("npm", ["i", "-D", ...devPkgs], { cwd, maxBuffer: 10 * 1024 * 1024 });
+    await execFileAsync(binary, [...cmd.dev, ...devPkgs], { cwd, maxBuffer: MAX_BUFFER });
   }
 }
 function printFromReport(report) {
@@ -66,10 +86,10 @@ function printFromReport(report) {
   console.log(lines.join("\n"));
 }
 
-// src/cli/output.ts
+// src/shared/cli/output.ts
 import path from "path";
 
-// src/report/json.ts
+// src/shared/report/json.ts
 function renderJson(report) {
   const r = {
     ...report,
@@ -82,7 +102,7 @@ function renderJson(report) {
   return JSON.stringify(r, null, 2);
 }
 
-// src/report/md.ts
+// src/shared/report/md.ts
 function table(headers, rows) {
   const header = `| ${headers.join(" | ")} |`;
   const sep = `| ${headers.map(() => "---").join(" | ")} |`;
@@ -135,211 +155,9 @@ function renderMarkdown(report) {
   return lines.join("\n");
 }
 
-// src/report/html.ts
-function table2(headers, rows) {
-  const headerHtml = `<tr>${headers.map((h) => `<th>${h}</th>`).join("")}</tr>`;
-  const bodyHtml = rows.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join("")}</tr>`).join("");
-  return `<table><thead>${headerHtml}</thead><tbody>${bodyHtml}</tbody></table>`;
-}
-function escapeHtml(text) {
-  const htmlEntities = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;"
-  };
-  return text.replace(/[&<>"']/g, (char) => htmlEntities[char]);
-}
-function renderHtml(report) {
-  const hasProjectMeta = report.project_name || report.project_version || report.project_description || report.project_homepage || report.project_bugs;
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>GEX Report - ${report.project_name || "Dependency Audit"}</title>
-  <style>
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
-      line-height: 1.6;
-      color: #333;
-      max-width: 1200px;
-      margin: 0 auto;
-      padding: 20px;
-      background-color: #f5f5f5;
-    }
-    .container {
-      background: white;
-      border-radius: 8px;
-      box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-      padding: 30px;
-    }
-    h1 {
-      color: #2c3e50;
-      border-bottom: 3px solid #3498db;
-      padding-bottom: 10px;
-      margin-top: 0;
-    }
-    h2 {
-      color: #34495e;
-      border-bottom: 2px solid #bdc3c7;
-      padding-bottom: 8px;
-      margin-top: 40px;
-      margin-bottom: 20px;
-    }
-    .metadata {
-      background: #ecf0f1;
-      border-radius: 6px;
-      padding: 20px;
-      margin-bottom: 20px;
-    }
-    .metadata dl {
-      margin: 0;
-    }
-    .metadata dt {
-      font-weight: bold;
-      color: #2c3e50;
-      margin-top: 10px;
-    }
-    .metadata dt:first-child {
-      margin-top: 0;
-    }
-    .metadata dd {
-      margin: 5px 0 0 20px;
-      color: #555;
-    }
-    .metadata dd a {
-      color: #3498db;
-      text-decoration: none;
-    }
-    .metadata dd a:hover {
-      text-decoration: underline;
-    }
-    table {
-      width: 100%;
-      border-collapse: collapse;
-      margin-bottom: 30px;
-      background: white;
-      border-radius: 6px;
-      overflow: hidden;
-      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-    }
-    th {
-      background: #3498db;
-      color: white;
-      padding: 12px;
-      text-align: left;
-      font-weight: 600;
-    }
-    td {
-      padding: 12px;
-      border-bottom: 1px solid #ecf0f1;
-      font-family: 'SFMono-Regular', Consolas, monospace;
-      font-size: 14px;
-    }
-    tr:nth-child(even) {
-      background: #f8f9fa;
-    }
-    tr:hover {
-      background: #e8f4fd;
-    }
-    .footer {
-      text-align: center;
-      color: #7f8c8d;
-      font-size: 14px;
-      margin-top: 40px;
-      padding-top: 20px;
-      border-top: 1px solid #ecf0f1;
-    }
-    .footer strong {
-      color: #2c3e50;
-    }
-    .no-data {
-      text-align: center;
-      color: #7f8c8d;
-      font-style: italic;
-      padding: 40px;
-    }
-    .timestamp {
-      color: #95a5a6;
-      font-size: 14px;
-      margin-top: 10px;
-    }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <h1>GEX Dependency Report</h1>
-
-    ${hasProjectMeta ? `
-    <section class="metadata">
-      <h2>Project Information</h2>
-      <dl>
-        ${report.project_name ? `<dt>Project Name</dt><dd>${escapeHtml(report.project_name)}</dd>` : ""}
-        ${report.project_version ? `<dt>Version</dt><dd>${escapeHtml(report.project_version)}</dd>` : ""}
-        ${report.project_description ? `<dt>Description</dt><dd>${escapeHtml(report.project_description)}</dd>` : ""}
-        ${report.project_homepage ? `<dt>Homepage</dt><dd><a href="${escapeHtml(report.project_homepage)}" target="_blank">${escapeHtml(report.project_homepage)}</a></dd>` : ""}
-        ${report.project_bugs ? `<dt>Bugs</dt><dd><a href="${escapeHtml(report.project_bugs)}" target="_blank">${escapeHtml(report.project_bugs)}</a></dd>` : ""}
-        <dt>Report Generated</dt><dd>${new Date(report.timestamp).toLocaleString()}</dd>
-      </dl>
-    </section>
-    ` : ""}
-
-    ${report.global_packages.length > 0 ? `
-    <section>
-      <h2>Global Packages <small>(${report.global_packages.length})</small></h2>
-      ${table2(
-    ["Name", "Version", "Path"],
-    report.global_packages.map((p) => [
-      escapeHtml(p.name),
-      escapeHtml(p.version || ""),
-      escapeHtml(p.resolved_path || "")
-    ])
-  )}
-    </section>
-    ` : '<section><h2>Global Packages</h2><div class="no-data">No global packages found</div></section>'}
-
-    ${report.local_dependencies.length > 0 ? `
-    <section>
-      <h2>Local Dependencies <small>(${report.local_dependencies.length})</small></h2>
-      ${table2(
-    ["Name", "Version", "Path"],
-    report.local_dependencies.map((p) => [
-      escapeHtml(p.name),
-      escapeHtml(p.version || ""),
-      escapeHtml(p.resolved_path || "")
-    ])
-  )}
-    </section>
-    ` : '<section><h2>Local Dependencies</h2><div class="no-data">No local dependencies found</div></section>'}
-
-    ${report.local_dev_dependencies.length > 0 ? `
-    <section>
-      <h2>Local Dev Dependencies <small>(${report.local_dev_dependencies.length})</small></h2>
-      ${table2(
-    ["Name", "Version", "Path"],
-    report.local_dev_dependencies.map((p) => [
-      escapeHtml(p.name),
-      escapeHtml(p.version || ""),
-      escapeHtml(p.resolved_path || "")
-    ])
-  )}
-    </section>
-    ` : '<section><h2>Local Dev Dependencies</h2><div class="no-data">No local dev dependencies found</div></section>'}
-
-    <footer class="footer">
-      <p>Generated by <strong>GEX v${escapeHtml(report.tool_version)}</strong> on ${new Date(report.timestamp).toLocaleString()}</p>
-      <p>Report format version: ${escapeHtml(report.report_version)}</p>
-    </footer>
-  </div>
-</body>
-</html>`;
-}
-
-// src/cli/output.ts
+// src/shared/cli/output.ts
 async function outputReport(report, format, outFile, markdownExtras) {
-  const content = format === "json" ? renderJson(report) : format === "html" ? renderHtml({ ...report, ...markdownExtras || {} }) : renderMarkdown({ ...report, ...markdownExtras || {} });
+  const content = format === "json" ? renderJson(report) : renderMarkdown({ ...report, ...markdownExtras || {} });
   if (outFile) {
     const outDir = path.dirname(outFile);
     const { mkdir, writeFile } = await import("fs/promises");
@@ -351,7 +169,7 @@ async function outputReport(report, format, outFile, markdownExtras) {
   }
 }
 
-// src/cli/parser.ts
+// src/shared/cli/parser.ts
 import { readFile } from "fs/promises";
 import path2 from "path";
 function isMarkdownReportFile(filePath) {
@@ -400,60 +218,227 @@ async function loadReportFromFile(reportPath) {
   return JSON.parse(raw);
 }
 
-// src/cli/report.ts
-import { readFile as readFile4 } from "fs/promises";
-import path5 from "path";
-
-// src/npm.ts
+// src/shared/npm-cli.ts
+import { promisify } from "util";
 async function getExecFileAsync2() {
   const { execFile } = await import("child_process");
-  const { promisify } = await import("util");
   return promisify(execFile);
 }
-async function npmLs(options = {}) {
-  const args = ["ls", "--json"];
+async function npmOutdated(options = {}) {
+  const args = ["outdated", "--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 getExecFileAsync2();
     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);
-        }
-      }
+    return normalizeOutdated(stdout);
+  } catch (error) {
+    const stdout = typeof error?.stdout === "string" ? error.stdout : "";
+    if (stdout.trim()) {
+      return normalizeOutdated(stdout);
     }
-    const stderr = err?.stderr;
-    const msg = typeof stderr === "string" && stderr.trim() || err?.message || "npm ls failed";
-    throw new Error(`npm ls failed: ${msg}`);
+    throw formatNpmError(error, "npm outdated");
   }
 }
-async function npmRootGlobal() {
+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();
-    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}`);
+    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/transform.ts
-import path3 from "path";
+// 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
+import { existsSync } from "fs";
 import { readFile as readFile2 } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+function getPkgJsonPath() {
+  let startDir;
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    startDir = path3.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 = path3.resolve(current, "package.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return path3.resolve(process.cwd(), "package.json");
+}
+async function getToolVersion() {
+  try {
+    const pkgPath = getPkgJsonPath();
+    const raw = await readFile2(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
+import { readFile as readFile4 } from "fs/promises";
+import path5 from "path";
+
+// src/shared/transform.ts
+import path4 from "path";
+import { readFile as readFile3 } from "fs/promises";
 function toPkgArray(obj) {
   if (!obj) return [];
   return Object.keys(obj).map((name) => ({ name, node: obj[name] })).filter((p) => p && p.node);
@@ -471,21 +456,30 @@ async function buildReportFromNpmTree(tree, opts) {
   if (opts.context === "local") {
     let pkgMeta = null;
     try {
-      const pkgJsonPath = path3.join(opts.cwd || process.cwd(), "package.json");
-      const raw = await readFile2(pkgJsonPath, "utf8");
+      const pkgJsonPath = path4.join(opts.cwd || process.cwd(), "package.json");
+      const raw = await readFile3(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 items = toPkgArray(depsObj);
-    const devKeys = new Set(Object.keys(pkgMeta?.devDependencies || {}));
-    for (const { name, node } of items) {
+    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 || path4.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 || path3.join(opts.cwd || process.cwd(), "node_modules", name);
+      const resolvedPath = node && node.path || path4.join(opts.cwd || process.cwd(), "node_modules", name);
       const pkg = { name, version, resolved_path: resolvedPath };
-      if (devKeys.has(name)) {
+      if (!treeDevItems.length && devKeys.has(name)) {
         report.local_dev_dependencies.push(pkg);
       } else {
         report.local_dependencies.push(pkg);
@@ -498,7 +492,7 @@ async function buildReportFromNpmTree(tree, opts) {
     const items = toPkgArray(depsObj);
     for (const { name, node } of items) {
       const version = node && node.version || "";
-      const resolvedPath = node && node.path || path3.join(opts.globalRoot || "", name);
+      const resolvedPath = node && node.path || path4.join(opts.globalRoot || "", name);
       const pkg = { name, version, resolved_path: resolvedPath };
       report.global_packages.push(pkg);
     }
@@ -510,41 +504,54 @@ async function buildReportFromNpmTree(tree, opts) {
   return report;
 }
 
-// src/cli/utils.ts
-import { readFile as readFile3 } from "fs/promises";
-import path4 from "path";
-import { fileURLToPath } from "url";
-function getPkgJsonPath() {
+// 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 __filename = fileURLToPath(import.meta.url);
-    const __dirnameLocal = path4.dirname(__filename);
-    return path4.resolve(__dirnameLocal, "..", "..", "package.json");
-  } catch {
-    const dir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    return path4.resolve(dir, "..", "package.json");
+    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 getToolVersion() {
+async function npmRootGlobal() {
   try {
-    const pkgPath = getPkgJsonPath();
-    const raw = await readFile3(pkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
+    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}`);
   }
 }
-var ASCII_BANNER = String.raw`
-  ________                __
- /  _____/  ____   _____/  |_  ____   ____
-/   \  ___ /  _ \ /  _ \   __\/ __ \ /    \
-\    \_\  (  <_> |  <_> )  | \  ___/|   |  \
- \______  /\____/ \____/|__|  \___  >___|  /
-        \/                         \/     \/
-                      GEX
-`;
 
-// src/cli/report.ts
+// src/runtimes/node/report.ts
 async function produceReport(ctx, options) {
   const toolVersion = await getToolVersion();
   const depth0 = !options.fullTree;
@@ -582,18 +589,17 @@ async function produceReport(ctx, options) {
   return { report, markdownExtras };
 }
 
-// src/cli/commands.ts
+// src/runtimes/node/commands.ts
 function addCommonOptions(cmd, { allowOmitDev }) {
   cmd.option(
     "-f, --output-format <format>",
-    "Output format: json, md, or html",
-    (val) => {
-      if (val === "md") return "md";
-      if (val === "html") return "html";
-      return "json";
-    },
+    "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("-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);
   }
@@ -607,6 +613,19 @@ function createLocalCommand(program) {
     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,
@@ -625,6 +644,19 @@ function createGlobalCommand(program) {
     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,
@@ -650,7 +682,7 @@ function createReadCommand(program) {
         printFromReport(parsed);
       }
       if (doInstall) {
-        await installFromReport(parsed, process.cwd());
+        await installFromReport(parsed, { cwd: process.cwd(), packageManager: "npm" });
       }
     } catch (err) {
       const isMd = isMarkdownReportFile(reportPath);
@@ -672,7 +704,7 @@ ${ASCII_BANNER}`);
   return program;
 }
 
-// src/cli.ts
+// src/runtimes/node/cli.ts
 async function run(argv = process.argv) {
   const program = await createProgram();
   await program.parseAsync(argv);
@@ -696,7 +728,31 @@ if (isMainModule) {
     process.exitCode = 1;
   });
 }
+
+// src/cli.ts
+async function run2(argv = process.argv) {
+  return run(argv);
+}
+var isMainModule2 = (() => {
+  try {
+    if (typeof __require !== "undefined" && typeof module !== "undefined") {
+      return __require.main === module;
+    }
+    if (typeof import.meta !== "undefined") {
+      return import.meta.url === `file://${process.argv[1]}`;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule2) {
+  run2().catch((error) => {
+    console.error("CLI error:", error);
+    process.exitCode = 1;
+  });
+}
 export {
-  run
+  run2 as run
 };
 //# sourceMappingURL=cli.mjs.map