@yabasha/gex 1.1.0 → 1.3.1

package/README.md

@@ -47,10 +47,12 @@ gex global [options]
 
 Common options:
 
-- f, --output-format <md|json> (default: json)
-- o, --out-file <path>
-- -full-tree Include the full npm ls JSON under `tree` (default uses depth=0)
-- -omit-dev Local only; exclude devDependencies
+- -f, --output-format <md|json> (default: json)
+- -o, --out-file <path>
+- --full-tree Include the full npm ls JSON under `tree` (default uses depth=0)
+- --omit-dev Local only; exclude devDependencies
+- -c, --check-outdated Print a table of outdated packages (skips console report output unless `-o` is set)
+- -u, --update-outdated [pkg1 pkg2 ...] Update outdated packages (omit names to update everything). Node CLI shells out to `npm update`, Bun CLI runs `bun update`/`bun update --global`.
 
 Examples:
 
@@ -83,6 +85,16 @@ gex 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
+
+# Check outdated packages / update them (Node runtime)
+gex local --check-outdated                    # show outdated local deps as a table
+gex global --check-outdated                   # show outdated globals
+gex local --update-outdated                   # update every outdated local dependency
+gex local --update-outdated axios react       # update specific packages
+
+# Bun runtime uses the same flags
+gex-bun local --check-outdated
+gex-bun global --update-outdated              # updates global Bun installs via `bun update`
 ```
 
 > **Note**: Starting from v0.4.0, GEX outputs to console by default instead of creating files automatically. Use the `-o/--out-file` flag to write to a file.

package/dist/cli-bun.mjs

@@ -8,6 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/runtimes/bun/commands.ts
 import path7 from "path";
+import { readFile as readFile6 } from "fs/promises";
 import { Command } from "commander";
 
 // src/shared/cli/install.ts
@@ -29,8 +30,8 @@ function formatSpec(pkg) {
 }
 async function getExecFileAsync() {
   const { execFile } = await import("child_process");
-  const { promisify } = await import("util");
-  return promisify(execFile);
+  const { promisify: promisify3 } = await import("util");
+  return promisify3(execFile);
 }
 async function installFromReport(report, options) {
   const opts = typeof options === "string" ? { cwd: options } : options;
@@ -218,6 +219,156 @@ async function loadReportFromFile(reportPath) {
   return JSON.parse(raw);
 }
 
+// src/shared/npm-cli.ts
+import { promisify } from "util";
+async function getExecFileAsync2() {
+  const { execFile } = await import("child_process");
+  return promisify(execFile);
+}
+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 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;
+}
+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
 import { existsSync } from "fs";
 import { readFile as readFile2 } from "fs/promises";
@@ -343,6 +494,7 @@ async function buildReportFromNpmTree(tree, opts) {
 import path5 from "path";
 import { constants as fsConstants } from "fs";
 import { access, readFile as readFile4, readdir, stat } from "fs/promises";
+import { promisify as promisify2 } from "util";
 var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".bin"]);
 async function bunPmLs(options = {}) {
   if (options.global) {
@@ -389,6 +541,36 @@ async function bunPmRootLocal(cwd = process.cwd()) {
   }
   return path5.join(cwd, "node_modules");
 }
+async function bunUpdate(options) {
+  const execFileAsync = await getExecFileAsync3();
+  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(
@@ -506,6 +688,10 @@ function getGlobalRootCandidates() {
   maybeAdd("/opt/homebrew/var/bun/install/global/node_modules");
   return Array.from(candidates);
 }
+async function getExecFileAsync3() {
+  const { execFile } = await import("child_process");
+  return promisify2(execFile);
+}
 
 // src/runtimes/bun/report.ts
 async function produceReport(ctx, options) {
@@ -551,7 +737,10 @@ function addCommonOptions(cmd, { allowOmitDev }) {
     "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("-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);
   }
@@ -565,6 +754,44 @@ 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: 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 (!proceed) return;
     const finalOutFile = outFile;
     const { report, markdownExtras } = await produceReport("local", {
       outputFormat,
@@ -583,6 +810,27 @@ 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: 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 (!proceed) return;
     const finalOutFile = outFile;
     const { report, markdownExtras } = await produceReport("global", {
       outputFormat,
@@ -629,6 +877,14 @@ ${ASCII_BANNER}`);
   createReadCommand(program);
   return program;
 }
+async function readPackageManifest(cwd) {
+  try {
+    const raw = await readFile6(path7.join(cwd, "package.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 
 // src/runtimes/bun/cli.ts
 async function run(argv = process.argv) {