@reliverse/dler 1.7.140 → 1.7.142

package/bin/impl/update/utils.js

@@ -1,22 +1,14 @@
-import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { multiselectPrompt } from "@reliverse/rempts";
+import rematch from "@reliverse/rematch";
 import { $ } from "bun";
-import { lookpath } from "lookpath";
-import pMap from "p-map";
-import { readPackageJSON } from "pkg-types";
+import path from "path";
 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:");
 }
@@ -45,88 +37,76 @@ export function isSemverCompatible(currentVersionRange, latestVersion2) {
     return false;
   }
 }
-export function collectTargetDependencies(pkg, args) {
+export function collectTargetDependencies(pkg) {
   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];
+  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");
+  }
+  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");
+  }
+  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");
+  }
+  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");
+  }
+  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("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];
+      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("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}`);
-      }
+      map[dep].locations.add(`catalogs.${catalogName}`);
     }
   }
   return { map };
@@ -173,67 +153,6 @@ export function applyVersionUpdate(pkg, depName, newVersion, locations) {
     }
   }
 }
-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) {
@@ -243,25 +162,13 @@ export async function fetchVersionFromRegistry(packageName) {
   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;
+    return await latestVersion(packageName);
   } 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;
+      return await fetchVersionFromRegistry(packageName);
     } 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)}`
-      );
+      throw new Error(`Failed to get latest version for ${packageName}: ${error}`);
     }
   }
 }
@@ -298,14 +205,54 @@ 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(", ")}`);
+    const namePatterns = args.name;
+    filteredDeps = depsToUpdate.filter((dep) => {
+      return namePatterns.some((pattern) => {
+        if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[") || pattern.includes("{")) {
+          return rematch(pattern, dep);
+        }
+        return dep === pattern;
+      });
+    });
+    const exactMatches = filteredDeps.filter((dep) => namePatterns.includes(dep));
+    const patternMatches = filteredDeps.length - exactMatches.length;
+    if (patternMatches > 0) {
+      relinka(
+        "verbose",
+        `Found ${exactMatches.length} exact matches and ${patternMatches} pattern matches`
+      );
+    }
+    if (filteredDeps.length === 0) {
+      relinka("warn", `No dependencies found matching patterns: ${namePatterns.join(", ")}`);
     }
   } else {
     const ignoreList = args.ignore || [];
-    filteredDeps = depsToUpdate.filter((dep) => !ignoreList.includes(dep));
+    filteredDeps = depsToUpdate.filter((dep) => {
+      return !ignoreList.some((ignorePattern) => {
+        if (ignorePattern.includes("*") || ignorePattern.includes("?") || ignorePattern.includes("[") || ignorePattern.includes("{")) {
+          return rematch(ignorePattern, dep);
+        }
+        return dep === ignorePattern;
+      });
+    });
+    const ignoredCount = depsToUpdate.length - filteredDeps.length;
+    if (ignoredCount > 0 && ignoreList.length > 0) {
+      relinka("verbose", `Ignored ${ignoredCount} dependencies matching ignore patterns`);
+    }
+  }
+  const ignoreFields = args.ignoreFields || [];
+  if (ignoreFields.length > 0) {
+    filteredDeps = filteredDeps.filter((dep) => {
+      const locations = allDepsMap[dep]?.locations || /* @__PURE__ */ new Set();
+      return !Array.from(locations).some((location) => ignoreFields.includes(location));
+    });
+    const ignoredFieldsCount = depsToUpdate.length - filteredDeps.length;
+    if (ignoredFieldsCount > 0) {
+      relinka(
+        "verbose",
+        `Ignored ${ignoredFieldsCount} dependencies in ignored fields: ${ignoreFields.join(", ")}`
+      );
+    }
   }
   return filteredDeps.filter((dep) => {
     const versionSpec = allDepsMap[dep]?.versionSpec ?? "";
@@ -314,15 +261,30 @@ export function prepareDependenciesForUpdate(allDepsMap, args) {
     return true;
   });
 }
-export async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix) {
+export async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix, fieldsToIgnore = []) {
   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();
+      const shouldIgnore = Array.from(locations).some(
+        (location) => fieldsToIgnore.includes(location)
+      );
+      if (shouldIgnore) {
+        continue;
+      }
+      let newVersion;
+      if (locations.has("peerDependencies")) {
+        const currentVersion = dependencies[update.package]?.versionSpec || "";
+        if (currentVersion.startsWith(">=")) {
+          newVersion = `>=${update.latestVersion}`;
+        } else {
+          newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
+        }
+      } else {
+        newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
+      }
       applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
     }
     await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
@@ -335,56 +297,7 @@ export async function updatePackageJsonFile(packageJsonPath, dependencies, updat
     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) {
+export function displayStructuredUpdateResults(results, packageJsonFiles, fileDepsMap, showDetails = false) {
   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);
@@ -393,78 +306,109 @@ export function displayUpdateResults(results) {
     for (const error of errors) {
       relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
     }
+    relinka("log", "");
   }
-  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`);
+  if (!showDetails) {
+    if (toUpdate.length === 0) {
+      relinka("log", `All ${upToDate.length} dependencies are already up to date`);
+    } else {
+      relinka(
+        "log",
+        `${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
+      );
+    }
     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, []);
+  const resultsByFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    let filePath = "unknown";
+    for (const [pkgPath, deps] of fileDepsMap.entries()) {
+      if (deps[result.package]) {
+        filePath = pkgPath;
+        break;
+      }
     }
-    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}`);
+    if (!resultsByFile.has(filePath)) {
+      resultsByFile.set(filePath, []);
+    }
+    const fileResults = resultsByFile.get(filePath);
+    if (fileResults) {
+      fileResults.push(result);
     }
   }
-}
-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];
+  for (const [filePath, fileResults] of resultsByFile.entries()) {
+    const relativePath = filePath !== "unknown" ? path.relative(process.cwd(), filePath) : "unknown";
+    relinka("info", `${relativePath}`);
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const result of fileResults) {
+      const category = result.location || "unknown";
+      if (!byCategory.has(category)) {
+        byCategory.set(category, []);
+      }
+      byCategory.get(category).push(result);
+    }
+    const upToDateInFile = fileResults.filter((r) => !r.updated && !r.error && r.semverCompatible);
+    if (upToDateInFile.length > 0) {
+      relinka("log", `  * ${upToDateInFile.length} deps are already up to date`);
+    }
+    const toUpdateInFile = fileResults.filter((r) => r.updated && !r.error);
+    if (toUpdateInFile.length > 0) {
+      relinka("log", `  * ${toUpdateInFile.length} deps can be updated:`);
+      const sortedCategories = Array.from(byCategory.entries()).sort(([a], [b]) => {
+        const order = {
+          catalog: 0,
+          dependencies: 1,
+          devDependencies: 2,
+          peerDependencies: 3,
+          optionalDependencies: 4
+        };
+        const aOrder = order[a] ?? 999;
+        const bOrder = order[b] ?? 999;
+        return aOrder - bOrder;
+      });
+      for (const [category, updates] of sortedCategories) {
+        const categoryUpdates = updates.filter((r) => r.updated && !r.error);
+        if (categoryUpdates.length > 0) {
+          let displayCategory = category;
+          if (category.startsWith("catalogs.")) {
+            displayCategory = `workspaces.${category}`;
+          } else if (category === "catalog") {
+            displayCategory = "workspaces.catalog";
+          }
+          relinka("log", `    - ${displayCategory}:`);
+          for (const update of categoryUpdates) {
+            relinka(
+              "log",
+              `      ${update.package}: ${update.currentVersion} \u2192 ${update.latestVersion}`
+            );
           }
         }
-        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;
+    const errorsInFile = fileResults.filter((r) => r.error);
+    if (errorsInFile.length > 0) {
+      relinka("warn", `  * ${errorsInFile.length} deps failed to check:`);
+      for (const error of errorsInFile) {
+        relinka("warn", `    ${error.package}: ${error.error}`);
       }
     }
-    return packages;
-  } catch (error) {
-    relinka("warn", `Failed to get global packages for ${packageManager}: ${error}`);
-    return {};
+    relinka("log", "");
+  }
+  if (toUpdate.length === 0) {
+    relinka("log", `All ${upToDate.length} dependencies are already up to date`);
+  } else {
+    relinka(
+      "success",
+      `Summary: ${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
+    );
   }
 }
-export async function runInstallCommand(packageManager, linker) {
+export async function runInstallCommand(packageManager) {
   try {
     switch (packageManager.name) {
-      case "bun": {
-        const linkerArg = linker ? `--linker ${linker}` : "";
-        await $`bun install ${linkerArg}`;
+      case "bun":
+        await $`bun install`;
         break;
-      }
       case "npm":
         await $`npm install`;
         break;
@@ -474,44 +418,6 @@ export async function runInstallCommand(packageManager, linker) {
       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}`);
     }
@@ -520,180 +426,6 @@ export async function runInstallCommandWithFilter(packageManager, linker, filter
     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);
@@ -712,190 +444,3 @@ export async function getPmOptions() {
   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) };
-  }
-}