@reliverse/dler 1.7.111 → 1.7.113

package/bin/app/update/utils.js

@@ -0,0 +1,899 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { multiselectPrompt } from "@reliverse/rempts";
+import { $ } from "bun";
+import { lookpath } from "lookpath";
+import pMap from "p-map";
+import { readPackageJSON } from "pkg-types";
+import semver from "semver";
+import { glob } from "tinyglobby";
+import { getAllPkgManagers } from "../utils/dependencies/getUserPkgManager.js";
+import { x } from "../utils/exec/exec-mod.js";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
+import { latestVersion } from "../utils/pm/pm-meta.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+export const versionCache = /* @__PURE__ */ new Map();
+export const CACHE_TTL = 5 * 60 * 1e3;
+export function isNpmAlias(versionSpec) {
+  return versionSpec.startsWith("npm:");
+}
+export function isWorkspaceDependency(versionSpec) {
+  return versionSpec.startsWith("workspace:");
+}
+export function isCatalogReference(versionSpec) {
+  return versionSpec.startsWith("catalog:");
+}
+export function isNonSemverSpecifier(versionSpec) {
+  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
+}
+export function isSemverCompatible(currentVersionRange, latestVersion2) {
+  try {
+    if (isNpmAlias(currentVersionRange)) {
+      return false;
+    }
+    if (isWorkspaceDependency(currentVersionRange)) {
+      return false;
+    }
+    if (!currentVersionRange.startsWith("^") && !currentVersionRange.startsWith("~")) {
+      return false;
+    }
+    return semver.satisfies(latestVersion2, currentVersionRange);
+  } catch {
+    return false;
+  }
+}
+export function collectTargetDependencies(pkg, args) {
+  const map = {};
+  const dependencies = pkg.dependencies || {};
+  const devDependencies = pkg.devDependencies || {};
+  const peerDependencies = pkg.peerDependencies || {};
+  const optionalDependencies = pkg.optionalDependencies || {};
+  const includeDeps = !args["dev-only"] && !args["peer-only"] && !args["optional-only"] && !args["catalogs-only"];
+  const includeCatalogs = !args["dev-only"] && !args["peer-only"] && !args["optional-only"] && !args["prod-only"];
+  if (args["prod-only"] || includeDeps) {
+    for (const dep of Object.keys(dependencies)) {
+      const version = dependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("dependencies");
+    }
+  }
+  if (args["dev-only"] || includeDeps) {
+    for (const dep of Object.keys(devDependencies)) {
+      const version = devDependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("devDependencies");
+    }
+  }
+  if (args["peer-only"] || includeDeps) {
+    for (const dep of Object.keys(peerDependencies)) {
+      const version = peerDependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("peerDependencies");
+    }
+  }
+  if (args["optional-only"] || includeDeps) {
+    for (const dep of Object.keys(optionalDependencies)) {
+      const version = optionalDependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("optionalDependencies");
+    }
+  }
+  if (args["catalogs-only"] || includeCatalogs) {
+    const workspacesCatalog = pkg.workspaces?.catalog || {};
+    for (const dep of Object.keys(workspacesCatalog)) {
+      const version = workspacesCatalog[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("catalog");
+    }
+    const workspacesCatalogs = pkg.workspaces?.catalogs || {};
+    for (const catalogName of Object.keys(workspacesCatalogs)) {
+      const catalog = workspacesCatalogs[catalogName] || {};
+      for (const dep of Object.keys(catalog)) {
+        const version = catalog[dep];
+        if (!version) continue;
+        if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+        map[dep].versionSpec = version;
+        map[dep].locations.add(`catalogs.${catalogName}`);
+      }
+    }
+    const topLevelCatalog = pkg.catalog || {};
+    for (const dep of Object.keys(topLevelCatalog)) {
+      const version = topLevelCatalog[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("catalog");
+    }
+    const topLevelCatalogs = pkg.catalogs || {};
+    for (const catalogName of Object.keys(topLevelCatalogs)) {
+      const catalog = topLevelCatalogs[catalogName] || {};
+      for (const dep of Object.keys(catalog)) {
+        const version = catalog[dep];
+        if (!version) continue;
+        if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+        map[dep].versionSpec = version;
+        map[dep].locations.add(`catalogs.${catalogName}`);
+      }
+    }
+  }
+  return { map };
+}
+export function applyVersionUpdate(pkg, depName, newVersion, locations) {
+  if (locations.has("dependencies")) {
+    if (!pkg.dependencies) pkg.dependencies = {};
+    pkg.dependencies[depName] = newVersion;
+  }
+  if (locations.has("devDependencies")) {
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    pkg.devDependencies[depName] = newVersion;
+  }
+  if (locations.has("peerDependencies")) {
+    if (!pkg.peerDependencies) pkg.peerDependencies = {};
+    pkg.peerDependencies[depName] = newVersion;
+  }
+  if (locations.has("optionalDependencies")) {
+    if (!pkg.optionalDependencies) pkg.optionalDependencies = {};
+    pkg.optionalDependencies[depName] = newVersion;
+  }
+  const ensureWorkspaces = () => {
+    if (!pkg.workspaces) pkg.workspaces = {};
+  };
+  if (locations.has("catalog")) {
+    ensureWorkspaces();
+    if (!pkg.workspaces.catalog) pkg.workspaces.catalog = {};
+    pkg.workspaces.catalog[depName] = newVersion;
+    if (pkg.catalog) pkg.catalog[depName] = newVersion;
+  }
+  for (const loc of locations) {
+    const match = /^catalogs\.(.+)$/.exec(loc);
+    if (match) {
+      const catalogName = match[1] ?? "";
+      if (!catalogName) continue;
+      ensureWorkspaces();
+      if (!pkg.workspaces.catalogs) pkg.workspaces.catalogs = {};
+      if (!pkg.workspaces.catalogs[catalogName])
+        pkg.workspaces.catalogs[catalogName] = {};
+      pkg.workspaces.catalogs[catalogName][depName] = newVersion;
+      if (pkg.catalogs && pkg.catalogs[catalogName]) {
+        pkg.catalogs[catalogName][depName] = newVersion;
+      }
+    }
+  }
+}
+export async function findWorkspacePackageJsons(cwd) {
+  const root = await readPackageJSON(cwd);
+  const ws = root.workspaces;
+  let patterns = [];
+  if (Array.isArray(ws)) {
+    patterns = ws;
+  } else if (ws && Array.isArray(ws.packages)) {
+    patterns = ws.packages;
+  }
+  if (!patterns.length) return [];
+  const dirs = await glob(patterns, {
+    cwd,
+    onlyDirectories: true,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  const pkgJsonPaths = [];
+  for (const dir of dirs) {
+    const pj = path.join(dir, "package.json");
+    if (await fs.pathExists(pj)) pkgJsonPaths.push(pj);
+  }
+  return pkgJsonPaths;
+}
+export async function isMonorepo(cwd) {
+  try {
+    const root = await readPackageJSON(cwd);
+    const ws = root.workspaces;
+    if (Array.isArray(ws) && ws.length > 0) {
+      return true;
+    }
+    if (ws && Array.isArray(ws.packages) && ws.packages.length > 0) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+export async function findAllPackageJsons(cwd) {
+  const packageJsonFiles = await glob("**/package.json", {
+    cwd,
+    absolute: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/coverage/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/out/**"
+    ]
+  });
+  const existingFiles = [];
+  for (const file of packageJsonFiles) {
+    if (await fs.pathExists(file)) {
+      existingFiles.push(file);
+    }
+  }
+  return existingFiles;
+}
+export async function fetchVersionFromRegistry(packageName) {
+  const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.version;
+}
+export async function getLatestVersion(packageName) {
+  const cached = versionCache.get(packageName);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL) {
+    return cached.version;
+  }
+  try {
+    const version = await latestVersion(packageName);
+    versionCache.set(packageName, { version, timestamp: now });
+    return version;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    try {
+      const version = await fetchVersionFromRegistry(packageName);
+      versionCache.set(packageName, { version, timestamp: now });
+      return version;
+    } catch (fallbackError) {
+      throw new Error(
+        `Latest version main check and npm registry fallback failed. Main check error: ${errorMessage}. Registry error: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
+      );
+    }
+  }
+}
+export async function checkPackageUpdate(packageName, versionSpec, locations, options) {
+  try {
+    const latest = await getLatestVersion(packageName);
+    const cleanCurrent = versionSpec.replace(/^[\^~]/, "");
+    let isCompatible = isSemverCompatible(versionSpec, latest);
+    const isExact = !versionSpec.startsWith("^") && !versionSpec.startsWith("~");
+    if (isExact || !isCompatible && options.allowMajor) {
+      isCompatible = true;
+    }
+    return {
+      package: packageName,
+      currentVersion: cleanCurrent,
+      latestVersion: latest,
+      updated: latest !== cleanCurrent && isCompatible,
+      semverCompatible: isCompatible,
+      location: Array.from(locations).join(", ")
+    };
+  } catch (error) {
+    return {
+      package: packageName,
+      currentVersion: versionSpec,
+      latestVersion: versionSpec,
+      updated: false,
+      error: error instanceof Error ? error.message : String(error),
+      semverCompatible: false,
+      location: Array.from(locations).join(", ")
+    };
+  }
+}
+export function prepareDependenciesForUpdate(allDepsMap, args) {
+  const depsToUpdate = Object.keys(allDepsMap);
+  let filteredDeps = [];
+  if (args.name && args.name.length > 0) {
+    filteredDeps = args.name.filter((dep) => dep in allDepsMap);
+    const notFound = args.name.filter((dep) => !(dep in allDepsMap));
+    if (notFound.length > 0) {
+      relinka("warn", `Dependencies not found: ${notFound.join(", ")}`);
+    }
+  } else {
+    const ignoreList = args.ignore || [];
+    filteredDeps = depsToUpdate.filter((dep) => !ignoreList.includes(dep));
+  }
+  return filteredDeps.filter((dep) => {
+    const versionSpec = allDepsMap[dep]?.versionSpec ?? "";
+    if (!versionSpec) return false;
+    if (isNonSemverSpecifier(versionSpec)) return false;
+    return true;
+  });
+}
+export async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix) {
+  if (updatesToApply.length === 0) return 0;
+  try {
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+    const updatedPackageJson = { ...packageJson };
+    for (const update of updatesToApply) {
+      const prefix = savePrefix === "none" ? "" : savePrefix;
+      const newVersion = `${prefix}${update.latestVersion}`;
+      const locations = dependencies[update.package]?.locations || /* @__PURE__ */ new Set();
+      applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
+    return updatesToApply.length;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+export async function updateWorkspacePackages(workspacePaths, args, options) {
+  if (workspacePaths.length === 0) return 0;
+  relinka("log", `Scanning ${workspacePaths.length} workspace packages...`);
+  let totalWorkspaceUpdated = 0;
+  for (const packageJsonPath of workspacePaths) {
+    try {
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+      const { map } = collectTargetDependencies(packageJson, args);
+      const candidates = prepareDependenciesForUpdate(map, args);
+      if (candidates.length === 0) continue;
+      const results = await pMap(
+        candidates,
+        (dep) => {
+          const depInfo = map[dep];
+          if (!depInfo?.versionSpec) {
+            return Promise.resolve({
+              package: dep,
+              currentVersion: "unknown",
+              latestVersion: "unknown",
+              updated: false,
+              error: "Current version not found",
+              semverCompatible: false,
+              location: Array.from(depInfo?.locations || ["unknown"]).join(", ")
+            });
+          }
+          return checkPackageUpdate(dep, depInfo.versionSpec, depInfo.locations, options);
+        },
+        { concurrency: options.concurrency }
+      );
+      const toUpdate = results.filter((r) => r.updated && !r.error);
+      const updated = await updatePackageJsonFile(
+        packageJsonPath,
+        map,
+        toUpdate,
+        options.savePrefix
+      );
+      if (updated > 0) {
+        totalWorkspaceUpdated += updated;
+        relinka("log", `Updated ${updated} deps in ${packageJsonPath}`);
+      }
+    } catch (error) {
+      relinka(
+        "warn",
+        `Skipping ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return totalWorkspaceUpdated;
+}
+export function displayUpdateResults(results) {
+  const toUpdate = results.filter((r) => r.updated && !r.error);
+  const errors = results.filter((r) => r.error);
+  const upToDate = results.filter((r) => !r.updated && !r.error && r.semverCompatible);
+  if (errors.length > 0) {
+    relinka("warn", `Failed to check ${errors.length} dependencies:`);
+    for (const error of errors) {
+      relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
+    }
+  }
+  if (upToDate.length > 0) {
+    relinka("log", `${upToDate.length} deps are already up to date`);
+  }
+  if (toUpdate.length === 0) {
+    relinka("verbose", `All ${upToDate.length} deps are already up to date`);
+    return;
+  }
+  relinka("log", `${toUpdate.length} deps can be updated:`);
+  const byLocation = /* @__PURE__ */ new Map();
+  for (const update of toUpdate) {
+    const location = update.location || "unknown";
+    if (!byLocation.has(location)) {
+      byLocation.set(location, []);
+    }
+    byLocation.get(location).push(update);
+  }
+  for (const [location, updates] of byLocation.entries()) {
+    relinka("log", `  ${location}:`);
+    for (const update of updates) {
+      relinka("log", `    ${update.package}: ${update.currentVersion} \u2192 ${update.latestVersion}`);
+    }
+  }
+}
+export async function getGlobalPackages(packageManager) {
+  try {
+    let result;
+    if (packageManager === "npm") {
+      result = await $`npm list -g --depth=0 --json`.json();
+    } else if (packageManager === "yarn") {
+      try {
+        result = await $`yarn global list --json`.json();
+      } catch {
+        result = await $`yarn global list`.text();
+        const packages2 = {};
+        const lines = result.split("\n");
+        for (const line of lines) {
+          const match = line.match(/^(.+)@([^@]+)$/);
+          if (match) {
+            packages2[match[1]] = match[2];
+          }
+        }
+        return packages2;
+      }
+    } else if (packageManager === "pnpm") {
+      result = await $`pnpm list -g --depth=0 --json`.json();
+    } else if (packageManager === "bun") {
+      result = await $`bun pm ls -g --json`.json();
+    } else {
+      throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+    const dependencies = result?.dependencies || {};
+    const packages = {};
+    for (const [name, info] of Object.entries(dependencies)) {
+      if (info && typeof info === "object" && "version" in info) {
+        packages[name] = info.version;
+      }
+    }
+    return packages;
+  } catch (error) {
+    relinka("warn", `Failed to get global packages for ${packageManager}: ${error}`);
+    return {};
+  }
+}
+export async function runInstallCommand(packageManager, linker) {
+  try {
+    switch (packageManager.name) {
+      case "bun": {
+        const linkerArg = linker ? `--linker ${linker}` : "";
+        await $`bun install ${linkerArg}`;
+        break;
+      }
+      case "npm":
+        await $`npm install`;
+        break;
+      case "yarn":
+        await $`yarn install`;
+        break;
+      case "pnpm":
+        await $`pnpm install`;
+        break;
+      case "deno":
+        await $`deno cache --reload import_map.json`;
+        break;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager.name}`);
+    }
+  } catch (error) {
+    relinka("warn", `Failed to run install command for ${packageManager.name}: ${error}`);
+    throw error;
+  }
+}
+export async function runInstallCommandWithFilter(packageManager, linker, filterArgs = []) {
+  try {
+    switch (packageManager.name) {
+      case "bun": {
+        const linkerArg = linker ? `--linker ${linker}` : "";
+        const filterStr = filterArgs.join(" ");
+        await $`bun install ${linkerArg} ${filterStr}`;
+        break;
+      }
+      case "npm": {
+        const npmFilterStr = filterArgs.join(" ");
+        await $`npm install ${npmFilterStr}`;
+        break;
+      }
+      case "yarn": {
+        const yarnFilterStr = filterArgs.join(" ");
+        await $`yarn install ${yarnFilterStr}`;
+        break;
+      }
+      case "pnpm": {
+        const pnpmFilterStr = filterArgs.join(" ");
+        await $`pnpm install ${pnpmFilterStr}`;
+        break;
+      }
+      case "deno":
+        await $`deno cache --reload import_map.json`;
+        break;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager.name}`);
+    }
+  } catch (error) {
+    relinka("warn", `Failed to run install command for ${packageManager.name}: ${error}`);
+    throw error;
+  }
+}
+export async function updateGlobalPackage(packageManager, packageName) {
+  try {
+    if (packageManager === "npm") {
+      await $`npm install -g ${packageName}@latest`;
+    } else if (packageManager === "yarn") {
+      await $`yarn global add ${packageName}@latest`;
+    } else if (packageManager === "pnpm") {
+      await $`pnpm add -g ${packageName}@latest`;
+    } else if (packageManager === "bun") {
+      await $`bun install -g ${packageName}@latest`;
+    } else {
+      throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+    return true;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to update global package ${packageName} with ${packageManager}: ${error}`
+    );
+    return false;
+  }
+}
+export async function handleGlobalUpdates(args) {
+  const packageManagers = ["bun", "npm", "yarn", "pnpm"];
+  const availablePackageManagers = [];
+  for (const pm of packageManagers) {
+    if (await lookpath(pm)) {
+      availablePackageManagers.push(pm);
+    }
+  }
+  if (availablePackageManagers.length === 0) {
+    relinka("error", "No supported package managers found");
+    return process.exit(1);
+  }
+  relinka("log", `Found package managers: ${availablePackageManagers.join(", ")}`);
+  const allGlobalPackages = {};
+  for (const pm of availablePackageManagers) {
+    const packages = await getGlobalPackages(pm);
+    for (const [name, version] of Object.entries(packages)) {
+      if (!allGlobalPackages[name] || semver.gt(version, allGlobalPackages[name].version)) {
+        allGlobalPackages[name] = { version, packageManager: pm };
+      }
+    }
+  }
+  const globalPackageNames = Object.keys(allGlobalPackages);
+  if (globalPackageNames.length === 0) {
+    relinka("warn", "No global packages found");
+    return;
+  }
+  let filteredPackages = [];
+  if (args.name && args.name.length > 0) {
+    filteredPackages = args.name.filter((pkg) => pkg in allGlobalPackages);
+    const notFound = args.name.filter((pkg) => !(pkg in allGlobalPackages));
+    if (notFound.length > 0) {
+      relinka("warn", `Global packages not found: ${notFound.join(", ")}`);
+    }
+  } else {
+    const ignoreList = args.ignore || [];
+    filteredPackages = globalPackageNames.filter((pkg) => !ignoreList.includes(pkg));
+  }
+  if (filteredPackages.length === 0) {
+    relinka("warn", "No global packages to update");
+    return;
+  }
+  relinka("log", `Checking ${filteredPackages.length} global packages for updates...`);
+  const results = await pMap(
+    filteredPackages,
+    async (packageName) => {
+      const globalPackage = allGlobalPackages[packageName];
+      if (!globalPackage) {
+        return {
+          package: packageName,
+          currentVersion: "unknown",
+          latestVersion: "unknown",
+          updated: false,
+          error: "Package not found in global packages",
+          location: "global"
+        };
+      }
+      try {
+        const latest = await getLatestVersion(packageName);
+        const needsUpdate = semver.gt(latest, globalPackage.version);
+        return {
+          package: packageName,
+          currentVersion: globalPackage.version,
+          latestVersion: latest,
+          updated: needsUpdate,
+          location: `global (${globalPackage.packageManager})`
+        };
+      } catch (error) {
+        return {
+          package: packageName,
+          currentVersion: globalPackage.version,
+          latestVersion: globalPackage.version,
+          updated: false,
+          error: error instanceof Error ? error.message : String(error),
+          location: `global (${globalPackage.packageManager})`
+        };
+      }
+    },
+    { concurrency: args.concurrency }
+  );
+  let toUpdate = results.filter((r) => r.updated && !r.error);
+  const errors = results.filter((r) => r.error);
+  const upToDate = results.filter((r) => !r.updated && !r.error);
+  if (errors.length > 0) {
+    relinka("warn", `Failed to check ${errors.length} global packages:`);
+    for (const error of errors) {
+      relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
+    }
+  }
+  if (upToDate.length > 0) {
+    relinka("log", `${upToDate.length} global packages are up to date`);
+  }
+  if (toUpdate.length === 0) {
+    relinka("log", "All global packages are up to date");
+    return;
+  }
+  relinka("log", `${toUpdate.length} global packages can be updated:`);
+  for (const update of toUpdate) {
+    relinka(
+      "log",
+      `  ${update.package} (${update.location}): ${update.currentVersion} \u2192 ${update.latestVersion}`
+    );
+  }
+  if (args.interactive) {
+    const allGlobalPackages2 = [
+      ...toUpdate.map((pkg) => ({ ...pkg, canUpdate: true, isUpToDate: false, hasError: false })),
+      ...upToDate.map((pkg) => ({ ...pkg, canUpdate: false, isUpToDate: true, hasError: false })),
+      ...errors.map((pkg) => ({ ...pkg, canUpdate: false, isUpToDate: false, hasError: true }))
+    ];
+    const selectedPackages = await multiselectPrompt({
+      title: "Select global packages to update",
+      options: [
+        { label: "Exit", value: "exit" },
+        ...allGlobalPackages2.map((pkg) => {
+          let label = `${pkg.package} (${pkg.location})`;
+          if (pkg.canUpdate) {
+            label += `: ${pkg.currentVersion} \u2192 ${pkg.latestVersion}`;
+          } else if (pkg.isUpToDate) {
+            label += `: ${pkg.currentVersion} (up-to-date)`;
+          } else if (pkg.hasError) {
+            label += `: ${pkg.currentVersion} (has errors)`;
+          }
+          return {
+            label,
+            value: pkg.package,
+            disabled: !pkg.canUpdate,
+            hint: pkg.hasError ? pkg.error : void 0
+          };
+        })
+      ]
+    });
+    if (selectedPackages.length === 0 || selectedPackages.includes("exit")) {
+      relinka("log", "Exiting global update process");
+      return;
+    }
+    const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
+    toUpdate = toUpdate.filter((update) => actualSelectedPackages.includes(update.package));
+    relinka("log", `Updating ${actualSelectedPackages.length} selected global packages...`);
+  }
+  if (args["dry-run"]) {
+    relinka("log", "Dry run mode - no changes were made");
+    return;
+  }
+  let successCount = 0;
+  for (const update of toUpdate) {
+    const globalPackage = allGlobalPackages[update.package];
+    if (globalPackage && await updateGlobalPackage(globalPackage.packageManager, update.package)) {
+      successCount++;
+    }
+  }
+  relinka("log", `Successfully updated ${successCount}/${toUpdate.length} global packages`);
+}
+export async function getPmOptions() {
+  const projectPath = getCurrentWorkingDirectory();
+  const detectedPMs = await getAllPkgManagers(projectPath);
+  const detectedPMMap = new Map(detectedPMs.map((pm) => [pm.packageManager, pm.source]));
+  const pmOptions = ["bun", "pnpm", "npm", "yarn"].map((pm) => {
+    const option = {
+      label: pm,
+      value: pm
+    };
+    const source = detectedPMMap.get(pm);
+    if (source && source !== "default") {
+      option.hint = "detected";
+    }
+    return option;
+  });
+  const defaultValue = [...detectedPMMap.keys()][0] ?? "npm";
+  return { pmOptions, defaultValue };
+}
+export async function upgradeDlerLocal() {
+  try {
+    const pkg = await readPackageJSON();
+    const hasDler = pkg.dependencies && "@reliverse/dler" in pkg.dependencies || pkg.devDependencies && "@reliverse/dler" in pkg.devDependencies;
+    if (!hasDler) {
+      return { tool: "dler (local)", status: "not-found" };
+    }
+    const packageManager = await detectPackageManager(process.cwd());
+    if (!packageManager) {
+      return { tool: "dler (local)", status: "error", message: "No package manager detected" };
+    }
+    const { exitCode } = await x(packageManager.command, ["update", "@reliverse/dler"], {
+      nodeOptions: { stdio: "pipe" }
+    });
+    return exitCode === 0 ? { tool: "dler (local)", status: "upgraded", message: `via ${packageManager.command}` } : { tool: "dler (local)", status: "error", message: "Upgrade failed" };
+  } catch (error) {
+    return {
+      tool: "dler (local)",
+      status: "not-found"
+    };
+  }
+}
+export async function upgradeDlerGlobal() {
+  try {
+    const dlerPath = await lookpath("dler");
+    if (!dlerPath) {
+      return { tool: "dler (global)", status: "not-found" };
+    }
+    const packageManagers = ["bun", "npm", "yarn", "pnpm"];
+    for (const pm of packageManagers) {
+      const pmPath = await lookpath(pm);
+      if (pmPath) {
+        try {
+          const args = pm === "npm" ? ["install", "-g", "@reliverse/dler@latest"] : pm === "yarn" ? ["global", "add", "@reliverse/dler@latest"] : ["install", "-g", "@reliverse/dler@latest"];
+          const { exitCode } = await x(pm, args, {
+            nodeOptions: { stdio: "pipe" }
+          });
+          if (exitCode === 0) {
+            return { tool: "dler (global)", status: "upgraded", message: `via ${pm}` };
+          }
+        } catch {
+        }
+      }
+    }
+    return { tool: "dler (global)", status: "error", message: "No suitable package manager found" };
+  } catch (error) {
+    return { tool: "dler (global)", status: "error", message: String(error) };
+  }
+}
+export async function upgradeGit() {
+  try {
+    const gitPath = await lookpath("git");
+    if (!gitPath) {
+      return { tool: "git", status: "not-found" };
+    }
+    const { stdout } = await x("git", ["--version"], {
+      nodeOptions: { stdio: "pipe" }
+    });
+    return {
+      tool: "git",
+      status: "up-to-date",
+      message: `${stdout.trim()} - manual upgrade required`
+    };
+  } catch (error) {
+    return { tool: "git", status: "error", message: String(error) };
+  }
+}
+export async function upgradeNode() {
+  try {
+    const nodePath = await lookpath("node");
+    if (!nodePath) {
+      return { tool: "node.js", status: "not-found" };
+    }
+    const { stdout } = await x("node", ["--version"], {
+      nodeOptions: { stdio: "pipe" }
+    });
+    return {
+      tool: "node.js",
+      status: "up-to-date",
+      message: `${stdout.trim()} - manual upgrade required`
+    };
+  } catch (error) {
+    return { tool: "node.js", status: "error", message: String(error) };
+  }
+}
+export async function upgradeNpm() {
+  try {
+    const npmPath = await lookpath("npm");
+    if (!npmPath) {
+      return { tool: "npm", status: "not-found" };
+    }
+    try {
+      const { exitCode, stdout, stderr } = await x("npm", ["install", "-g", "npm@latest"], {
+        nodeOptions: { stdio: "pipe" }
+      });
+      if (exitCode === 0) {
+        const output = (stdout + stderr).toLowerCase();
+        if (output.includes("unchanged") || output.includes("up-to-date") || output.includes("already")) {
+          return { tool: "npm", status: "up-to-date" };
+        }
+        return { tool: "npm", status: "upgraded" };
+      } else {
+        return { tool: "npm", status: "error", message: "Upgrade failed" };
+      }
+    } catch (pipeError) {
+      const { exitCode } = await x("npm", ["install", "-g", "npm@latest"], {
+        nodeOptions: { stdio: "inherit" }
+      });
+      return exitCode === 0 ? { tool: "npm", status: "upgraded" } : { tool: "npm", status: "error", message: "Upgrade failed" };
+    }
+  } catch (error) {
+    return { tool: "npm", status: "error", message: String(error) };
+  }
+}
+export async function upgradeBun() {
+  try {
+    const bunPath = await lookpath("bun");
+    if (!bunPath) {
+      return { tool: "bun", status: "not-found" };
+    }
+    const { exitCode, stdout, stderr } = await x("bun", ["upgrade"], {
+      nodeOptions: { stdio: "pipe" }
+    });
+    if (exitCode !== 0) {
+      return { tool: "bun", status: "error", message: "Upgrade failed" };
+    }
+    const output = (stdout + stderr).toLowerCase();
+    if (output.includes("already") || output.includes("up-to-date") || output.includes("latest")) {
+      return { tool: "bun", status: "up-to-date" };
+    }
+    return { tool: "bun", status: "upgraded" };
+  } catch (error) {
+    return { tool: "bun", status: "error", message: String(error) };
+  }
+}
+export async function upgradeYarn() {
+  try {
+    const yarnPath = await lookpath("yarn");
+    if (!yarnPath) {
+      return { tool: "yarn", status: "not-found" };
+    }
+    try {
+      const { exitCode: upgradeResult } = await x("yarn", ["self-update"], {
+        nodeOptions: { stdio: "pipe" }
+      });
+      if (upgradeResult === 0) {
+        return { tool: "yarn", status: "upgraded", message: "self-update" };
+      }
+    } catch {
+    }
+    const npmPath = await lookpath("npm");
+    if (npmPath) {
+      const { exitCode } = await x("npm", ["install", "-g", "yarn@latest"], {
+        nodeOptions: { stdio: "pipe" }
+      });
+      return exitCode === 0 ? { tool: "yarn", status: "upgraded", message: "via npm" } : { tool: "yarn", status: "error", message: "Upgrade failed" };
+    }
+    return { tool: "yarn", status: "error", message: "No upgrade method available" };
+  } catch (error) {
+    return { tool: "yarn", status: "error", message: String(error) };
+  }
+}
+export async function upgradePnpm() {
+  try {
+    const pnpmPath = await lookpath("pnpm");
+    if (!pnpmPath) {
+      return { tool: "pnpm", status: "not-found" };
+    }
+    try {
+      const { exitCode } = await x("pnpm", ["add", "-g", "pnpm@latest"], {
+        nodeOptions: { stdio: "pipe" }
+      });
+      return exitCode === 0 ? { tool: "pnpm", status: "upgraded" } : { tool: "pnpm", status: "error", message: "Upgrade failed" };
+    } catch {
+      const npmPath = await lookpath("npm");
+      if (npmPath) {
+        const { exitCode } = await x("npm", ["install", "-g", "pnpm@latest"], {
+          nodeOptions: { stdio: "pipe" }
+        });
+        return exitCode === 0 ? { tool: "pnpm", status: "upgraded", message: "via npm" } : { tool: "pnpm", status: "error", message: "Upgrade failed" };
+      }
+      return { tool: "pnpm", status: "error", message: "No upgrade method available" };
+    }
+  } catch (error) {
+    return { tool: "pnpm", status: "error", message: String(error) };
+  }
+}