@reliverse/dler 1.7.140 → 1.7.142

package/README.md

@@ -10,7 +10,7 @@ Visit [docs.reliverse.org/libraries/dler](https://docs.reliverse.org/libraries/d
 
 ## Stand With Ukraine
 
-- 💙 Please help fund drones, medkits, and victory. [Donate now](https://u24.gov.ua), it matters.
+- 💙 Please help fund drones, medkits, and victory. [Donate now](https://u24.gov.ua), please, it matters.
 - 💛 Every dollar helps stop [russia's war crimes](https://war.ukraine.ua/russia-war-crimes) and saves lives.
 
 ## Stand With Reliverse

package/bin/impl/config/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const PROJECT_ROOT: string;
-export declare const cliVersion = "1.7.140";
+export declare const cliVersion = "1.7.142";
 export declare const cliName = "@reliverse/rse";
 export declare const rseName = "@reliverse/rse";
 export declare const dlerName = "@reliverse/dler";

package/bin/impl/config/constants.js

@@ -1,7 +1,7 @@
 import os from "node:os";
 import path from "@reliverse/pathkit";
 export const PROJECT_ROOT = path.resolve(process.cwd());
-const version = "1.7.140";
+const version = "1.7.142";
 export const cliVersion = version;
 export const cliName = "@reliverse/rse";
 export const rseName = "@reliverse/rse";

package/bin/impl/update/impl.d.ts

@@ -1,49 +1,23 @@
-import { type PackageCheckOptions, type UpdateResult } from "./utils";
+import { type UpdateResult } from "./utils";
 interface UpdateArgs {
+    ci?: boolean;
+    cwd?: string;
     name?: string[];
     ignore?: string[];
-    devOnly?: boolean;
-    prodOnly?: boolean;
-    peerOnly?: boolean;
-    optionalOnly?: boolean;
-    catalogsOnly?: boolean;
     dryRun?: boolean;
-    concurrency?: number;
-    withCheckScript?: boolean;
-    linker?: string;
-    withInstall?: boolean;
-    global?: boolean;
-    interactive?: boolean;
-    filter?: string[];
-    allWorkspaces?: boolean;
-    rootOnly?: boolean;
-    recursive?: boolean;
-    savePrefix?: string;
+    install?: boolean;
     allowMajor?: boolean;
+    concurrency?: number;
+    ignoreFields?: string[];
 }
-export declare function validateUpdateArgs(args: UpdateArgs): Promise<void>;
-export declare function handleCatalogOnlyUpdate(args: UpdateArgs): Promise<boolean>;
 export declare function validatePackageJson(): Promise<string>;
-export declare function getEffectiveLinker(args: UpdateArgs): Promise<{
-    effectiveLinker: string;
-    linkerSource: string;
-}>;
-export declare function prepareUpdateCandidates(args: UpdateArgs): Promise<{
-    candidates: string[];
-    allDepsMap: Record<string, any>;
-}>;
 export declare function prepareAllUpdateCandidates(args: UpdateArgs): Promise<{
     candidates: string[];
     allDepsMap: Record<string, any>;
     packageJsonFiles: string[];
+    fileDepsMap: Map<string, Record<string, any>>;
 }>;
 export declare function checkPackageUpdates(candidates: string[], allDepsMap: Record<string, any>, args: UpdateArgs): Promise<UpdateResult[]>;
-export declare function handleInteractiveSelection(results: UpdateResult[]): Promise<UpdateResult[]>;
-export declare function updateRootPackageJson(packageJsonPath: string, allDepsMap: Record<string, any>, toUpdate: UpdateResult[], savePrefix: string): Promise<number>;
-export declare function updateAllPackageJsonFiles(packageJsonFiles: string[], toUpdate: UpdateResult[], savePrefix: string): Promise<number>;
-export declare function handleRecursiveUpdates(args: UpdateArgs, options: PackageCheckOptions): Promise<number>;
-export declare function handleWorkspaceUpdates(args: UpdateArgs, options: PackageCheckOptions): Promise<number>;
-export declare function displayUpdateSummary(totalUpdated: number, args: UpdateArgs, isMonorepoProject: boolean, shouldUpdateWorkspaces: boolean): void;
-export declare function handleInstallation(args: UpdateArgs, effectiveLinker: string, packageJson: any): Promise<void>;
-export declare function handleToolUpgrades(args: any): Promise<void>;
+export declare function updateAllPackageJsonFiles(packageJsonFiles: string[], toUpdate: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
+export declare function handleInstallation(): Promise<void>;
 export {};

package/bin/impl/update/impl.js

@@ -1,80 +1,16 @@
 import path from "@reliverse/pathkit";
-import { re } from "@reliverse/relico";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { multiselectPrompt } from "@reliverse/rempts";
-import { $ } from "bun";
 import pMap from "p-map";
-import { readPackageJSON } from "pkg-types";
-import { getConfigBunfig } from "../config/load.js";
-import { isCatalogSupported, updateCatalogs } from "../utils/pm/pm-catalog.js";
+import { glob } from "tinyglobby";
 import { detectPackageManager } from "../utils/pm/pm-detect.js";
 import {
   checkPackageUpdate,
   collectTargetDependencies,
-  findAllPackageJsons,
-  findWorkspacePackageJsons,
-  isMonorepo,
   prepareDependenciesForUpdate,
   runInstallCommand,
-  runInstallCommandWithFilter,
-  updatePackageJsonFile,
-  updateWorkspacePackages,
-  upgradeBun,
-  upgradeDlerGlobal,
-  upgradeDlerLocal,
-  upgradeGit,
-  upgradeNode,
-  upgradeNpm,
-  upgradePnpm,
-  upgradeYarn
+  updatePackageJsonFile
 } from "./utils.js";
-export async function validateUpdateArgs(args) {
-  const exclusiveFlags = [
-    args["devOnly"],
-    args["prodOnly"],
-    args["peerOnly"],
-    args["optionalOnly"],
-    args["catalogsOnly"]
-  ];
-  if (exclusiveFlags.filter(Boolean).length > 1) {
-    relinka(
-      "error",
-      "Cannot specify multiple exclusive flags (--dev-only, --prod-only, --peer-only, --optional-only, --catalogs-only)"
-    );
-    process.exit(1);
-  }
-  if (args["allWorkspaces"] && args["rootOnly"]) {
-    relinka("error", "Cannot specify both --all-workspaces and --root-only flags");
-    process.exit(1);
-  }
-  if (args.recursive && (args["allWorkspaces"] || args["rootOnly"])) {
-    relinka(
-      "error",
-      "Cannot use --recursive with --all-workspaces or --root-only flags. Use --no-recursive to disable recursive mode."
-    );
-    process.exit(1);
-  }
-}
-export async function handleCatalogOnlyUpdate(args) {
-  if (!args["catalogsOnly"]) {
-    return false;
-  }
-  const packageManager = await detectPackageManager(process.cwd());
-  if (!packageManager) {
-    relinka("error", "Could not detect package manager");
-    process.exit(1);
-  }
-  if (!isCatalogSupported(packageManager)) {
-    relinka(
-      "error",
-      `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
-    );
-    process.exit(1);
-  }
-  await updateCatalogs(process.cwd());
-  return true;
-}
 export async function validatePackageJson() {
   const packageJsonPath = path.resolve(process.cwd(), "package.json");
   if (!await fs.pathExists(packageJsonPath)) {
@@ -83,47 +19,37 @@ export async function validatePackageJson() {
   }
   return packageJsonPath;
 }
-export async function getEffectiveLinker(args) {
-  let effectiveLinker = args.linker || "hoisted";
-  let linkerSource = "CLI default";
-  if (typeof Bun !== "undefined") {
-    const bunfigConfig = await getConfigBunfig();
-    const bunfigLinker = bunfigConfig?.install?.linker;
-    if (bunfigLinker && ["isolated", "hoisted"].includes(bunfigLinker) && args.linker === "hoisted") {
-      effectiveLinker = bunfigLinker;
-      linkerSource = bunfigLinker === "hoisted" ? "bunfig.toml (same as default)" : "bunfig.toml";
-    }
-  }
-  if (args.linker !== "hoisted") {
-    effectiveLinker = args.linker;
-    linkerSource = "CLI override";
-  }
-  relinka("verbose", `Using linker strategy: ${effectiveLinker} (from ${linkerSource})`);
-  return { effectiveLinker, linkerSource };
-}
-export async function prepareUpdateCandidates(args) {
-  const packageJson = await readPackageJSON();
-  const { map: allDepsMap } = collectTargetDependencies(packageJson, args);
-  const candidates = prepareDependenciesForUpdate(allDepsMap, args);
-  if (candidates.length === 0) {
-    relinka("warn", "No dependencies to update based on provided filters");
-    return { candidates: [], allDepsMap };
-  }
-  return { candidates, allDepsMap };
-}
 export async function prepareAllUpdateCandidates(args) {
-  const packageJsonFiles = await determinePackageJsonFiles(args);
+  const packageJsonFiles = await glob("**/package.json", {
+    cwd: process.cwd(),
+    absolute: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/coverage/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/out/**",
+      "**/target/**",
+      "**/.turbo/**"
+    ]
+  });
   if (packageJsonFiles.length === 0) {
-    relinka("warn", "No package.json files found to process");
-    return { candidates: [], allDepsMap: {}, packageJsonFiles: [] };
+    relinka("warn", "No package.json files found");
+    return { candidates: [], allDepsMap: {}, packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
   }
+  relinka("verbose", `Found ${packageJsonFiles.length} package.json files`);
   const allDepsMap = {};
   const allCandidates = /* @__PURE__ */ new Set();
+  const fileDepsMap = /* @__PURE__ */ new Map();
   for (const packageJsonPath of packageJsonFiles) {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-      const { map } = collectTargetDependencies(packageJson, args);
+      const { map } = collectTargetDependencies(packageJson);
       const candidates2 = prepareDependenciesForUpdate(map, args);
+      fileDepsMap.set(packageJsonPath, map);
       for (const [dep, info] of Object.entries(map)) {
         if (!allDepsMap[dep]) {
           allDepsMap[dep] = { ...info, locations: new Set(info.locations) };
@@ -146,41 +72,17 @@ export async function prepareAllUpdateCandidates(args) {
   }
   const candidates = Array.from(allCandidates);
   if (candidates.length === 0) {
-    relinka(
-      "warn",
-      "No dependencies to update based on provided filters across all package.json files"
-    );
-    return { candidates: [], allDepsMap: {}, packageJsonFiles };
+    relinka("warn", "No dependencies to update");
+    return { candidates: [], allDepsMap: {}, packageJsonFiles, fileDepsMap };
   }
-  return { candidates, allDepsMap, packageJsonFiles };
-}
-async function determinePackageJsonFiles(args) {
-  const cwd = process.cwd();
-  const rootPackageJsonPath = path.resolve(cwd, "package.json");
-  const packageJsonFiles = [];
-  if (await fs.pathExists(rootPackageJsonPath)) {
-    packageJsonFiles.push(rootPackageJsonPath);
-  }
-  if (args.recursive) {
-    const allPackageJsons = await findAllPackageJsons(cwd);
-    const otherPackageJsons = allPackageJsons.filter((p) => p !== rootPackageJsonPath);
-    packageJsonFiles.push(...otherPackageJsons);
-    return packageJsonFiles;
-  }
-  const isMonorepoProject = await isMonorepo(cwd);
-  if (args.allWorkspaces) {
-    const workspacePkgJsons = await findWorkspacePackageJsons(cwd);
-    packageJsonFiles.push(...workspacePkgJsons);
-  } else if (!args.rootOnly && isMonorepoProject) {
-    const workspacePkgJsons = await findWorkspacePackageJsons(cwd);
-    packageJsonFiles.push(...workspacePkgJsons);
-  }
-  return packageJsonFiles;
+  relinka("verbose", `Processing ${packageJsonFiles.length} package.json files`);
+  return { candidates, allDepsMap, packageJsonFiles, fileDepsMap };
 }
 export async function checkPackageUpdates(candidates, allDepsMap, args) {
   const options = {
-    allowMajor: !!args["allowMajor"],
-    savePrefix: args["savePrefix"],
+    allowMajor: !!args.allowMajor,
+    savePrefix: "^",
+    // Use default prefix
     concurrency: args.concurrency || 5
   };
   return await pMap(
@@ -195,7 +97,7 @@ export async function checkPackageUpdates(candidates, allDepsMap, args) {
           updated: false,
           error: "Current version not found",
           semverCompatible: false,
-          location: Array.from(depInfo?.locations || ["unknown"]).join(", ")
+          location: "unknown"
         };
       }
       return checkPackageUpdate(dep, depInfo.versionSpec, depInfo.locations, options);
@@ -203,62 +105,7 @@ export async function checkPackageUpdates(candidates, allDepsMap, args) {
     { concurrency: args.concurrency || 5 }
   );
 }
-export async function handleInteractiveSelection(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);
-  const allPackages = [
-    ...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 dependencies to update",
-    options: [
-      { label: "Exit", value: "exit" },
-      ...allPackages.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 update process");
-    return [];
-  }
-  const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
-  const filteredToUpdate = toUpdate.filter(
-    (update) => actualSelectedPackages.includes(update.package)
-  );
-  relinka("log", `Updating ${actualSelectedPackages.length} selected dependencies...`);
-  return filteredToUpdate;
-}
-export async function updateRootPackageJson(packageJsonPath, allDepsMap, toUpdate, savePrefix) {
-  return await updatePackageJsonFile(packageJsonPath, allDepsMap, toUpdate, savePrefix);
-}
-export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, savePrefix) {
+export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, savePrefix, fieldsToIgnore = []) {
   if (packageJsonFiles.length === 0 || toUpdate.length === 0) {
     return 0;
   }
@@ -266,14 +113,15 @@ export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, save
   for (const packageJsonPath of packageJsonFiles) {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-      const { map: fileDepsMap } = collectTargetDependencies(packageJson, {});
+      const { map: fileDepsMap } = collectTargetDependencies(packageJson);
       const fileSpecificUpdates = toUpdate.filter((update) => fileDepsMap[update.package]);
       if (fileSpecificUpdates.length > 0) {
         const updated = await updatePackageJsonFile(
           packageJsonPath,
           fileDepsMap,
           fileSpecificUpdates,
-          savePrefix
+          savePrefix,
+          fieldsToIgnore
         );
         totalUpdated += updated;
         if (updated > 0) {
@@ -290,170 +138,17 @@ export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, save
   }
   return totalUpdated;
 }
-export async function handleRecursiveUpdates(args, options) {
-  const allPackageJsons = await findAllPackageJsons(process.cwd());
-  const rootPackageJsonPath = path.resolve(process.cwd(), "package.json");
-  const otherPackageJsons = allPackageJsons.filter((p) => p !== rootPackageJsonPath);
-  if (otherPackageJsons.length > 0) {
-    relinka(
-      "verbose",
-      `Found ${otherPackageJsons.length} additional package.json files to update recursively`
-    );
-    return await updateWorkspacePackages(otherPackageJsons, args, options);
-  }
-  return 0;
-}
-export async function handleWorkspaceUpdates(args, options) {
-  const isMonorepoProject = await isMonorepo(process.cwd());
-  const shouldUpdateWorkspaces = args["allWorkspaces"] || !args["rootOnly"] && isMonorepoProject;
-  if (shouldUpdateWorkspaces) {
-    const workspacePkgJsons = await findWorkspacePackageJsons(process.cwd());
-    if (workspacePkgJsons.length > 0) {
-      return await updateWorkspacePackages(workspacePkgJsons, args, options);
-    } else if (args["allWorkspaces"]) {
-      relinka("warn", "No workspace packages found but --all-workspaces flag was provided");
-    }
-  } else if (isMonorepoProject) {
-    relinka("log", "Skipping workspace packages due to --root-only flag");
-  }
-  return 0;
-}
-export function displayUpdateSummary(totalUpdated, args, isMonorepoProject, shouldUpdateWorkspaces) {
-  if (args.recursive) {
-    relinka("log", `Updated ${totalUpdated} dependencies across all package.json files`);
-  } else {
-    if (isMonorepoProject && shouldUpdateWorkspaces) {
-      relinka("log", `Updated ${totalUpdated} dependencies across workspace (root + workspaces)`);
-    } else if (isMonorepoProject) {
-      relinka("log", `Updated ${totalUpdated} dependencies in root package.json only`);
-    } else {
-      relinka("log", `Updated ${totalUpdated} dependencies`);
-    }
-  }
-}
-export async function handleInstallation(args, effectiveLinker, packageJson) {
-  if (!args["withInstall"]) {
-    const packageManager2 = await detectPackageManager(process.cwd());
-    const installCommand = packageManager2?.command || "your package manager";
-    relinka(
-      "log",
-      `Install step is skipped by default. Run '${installCommand} install' manually to apply the changes.`
-    );
-    relinka(
-      "log",
-      `(experimental) Next time you can try --withInstall flag to run it automatically.`
-    );
-    return;
-  }
+export async function handleInstallation() {
   const packageManager = await detectPackageManager(process.cwd());
   if (!packageManager) {
     relinka("warn", "Could not detect package manager. Please run install manually.");
     return;
   }
   try {
-    if (args.filter && args.filter.length > 0) {
-      const filterArgs = args.filter.flatMap((filter) => ["--filter", filter]);
-      await runInstallCommandWithFilter(packageManager, effectiveLinker, filterArgs);
-    } else {
-      await runInstallCommand(packageManager, effectiveLinker);
-    }
-    if (packageManager.name === "bun" && packageJson.scripts?.check && args["withCheckScript"]) {
-      await $`bun check`;
-    }
+    await runInstallCommand(packageManager);
+    relinka("log", "Installation completed successfully");
   } catch (error) {
     relinka("warn", `Install failed: ${error instanceof Error ? error.message : String(error)}`);
     relinka("log", `Run '${packageManager.command} install' manually to apply the changes`);
   }
 }
-export async function handleToolUpgrades(args) {
-  const toolUpgradeFunctions = [
-    { name: "dler (local)", fn: upgradeDlerLocal },
-    { name: "dler (global)", fn: upgradeDlerGlobal },
-    { name: "git", fn: upgradeGit },
-    { name: "node.js", fn: upgradeNode },
-    { name: "npm", fn: upgradeNpm },
-    { name: "bun", fn: upgradeBun },
-    { name: "yarn", fn: upgradeYarn },
-    { name: "pnpm", fn: upgradePnpm }
-  ];
-  let results = [];
-  if (args["upgrade-interactive"]) {
-    const preliminaryResults = await Promise.all(
-      toolUpgradeFunctions.map(async ({ fn }) => await fn())
-    );
-    const availableTools = toolUpgradeFunctions.map((tool, index) => ({
-      ...tool,
-      result: preliminaryResults[index]
-    })).filter(({ result }) => result && result.status !== "not-found");
-    if (availableTools.length === 0) {
-      relinka("warn", "No tools available for upgrade");
-      return;
-    }
-    const selectedTools = await multiselectPrompt({
-      title: "Select tools to upgrade",
-      displayInstructions: true,
-      options: [
-        { label: "Exit", value: "exit" },
-        ...availableTools.map(({ name, result }) => {
-          const isUpToDate = result && result.status === "up-to-date";
-          const hasErrors = result && result.status === "error";
-          const canUpgrade = result && result.status === "upgraded";
-          let label = name;
-          if (isUpToDate) {
-            label += " (up-to-date)";
-          } else if (hasErrors) {
-            label += " (has errors)";
-          } else if (canUpgrade) {
-            label += " (can be upgraded)";
-          }
-          return {
-            label: isUpToDate || hasErrors ? re.gray(label) : label,
-            value: name,
-            disabled: isUpToDate || hasErrors,
-            hint: hasErrors ? result.message : void 0
-          };
-        })
-      ]
-    });
-    if (selectedTools.length === 0 || selectedTools.includes("exit")) {
-      relinka("info", "Exiting upgrade process");
-      return;
-    }
-    const actualSelectedTools = selectedTools.filter((tool) => tool !== "exit");
-    relinka("info", `Upgrading ${actualSelectedTools.length} selected tools...`);
-    for (const toolName of actualSelectedTools) {
-      const tool = availableTools.find((t) => t.name === toolName);
-      if (tool) {
-        const result = await tool.fn();
-        results.push(result);
-      }
-    }
-  } else {
-    results = await Promise.all(toolUpgradeFunctions.map(async ({ fn }) => await fn()));
-  }
-  const upgraded = results.filter((r) => r.status === "upgraded");
-  const upToDate = results.filter((r) => r.status === "up-to-date");
-  const notFound = results.filter((r) => r.status === "not-found");
-  const errors = results.filter((r) => r.status === "error");
-  if (upgraded.length > 0) {
-    relinka("success", `Upgraded ${upgraded.length} tools:`);
-    upgraded.forEach(
-      (r) => relinka("verbose", `  \u2713 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
-    );
-  }
-  if (upToDate.length > 0) {
-    relinka("info", `${upToDate.length} tools already up-to-date:`);
-    upToDate.forEach(
-      (r) => relinka("verbose", `  \u2022 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
-    );
-  }
-  if (notFound.length > 0) {
-    relinka("warn", `${notFound.length} tools not installed (skipped):`);
-    notFound.forEach((r) => relinka("verbose", `  - ${r.tool}`));
-  }
-  if (errors.length > 0) {
-    relinka("error", `${errors.length} tools had errors:`);
-    errors.forEach((r) => relinka("verbose", `  \u2717 ${r.tool}${r.message ? ` - ${r.message}` : ""}`));
-  }
-  relinka("success", "Upgrade check completed!");
-}

package/bin/impl/update/utils.d.ts

@@ -1,9 +1,4 @@
 import { type PackageManager } from "../utils/dependencies/getUserPkgManager.js";
-export interface UpgradeResult {
-    tool: string;
-    status: "upgraded" | "up-to-date" | "not-found" | "error";
-    message?: string;
-}
 export interface UpdateResult {
     package: string;
     currentVersion: string;
@@ -22,11 +17,6 @@ export interface PackageCheckOptions {
     savePrefix: string;
     concurrency: number;
 }
-export declare const versionCache: Map<string, {
-    version: string;
-    timestamp: number;
-}>;
-export declare const CACHE_TTL: number;
 /**
  * Check if a dependency is an npm alias (e.g., "npm:package-name@version")
  */
@@ -43,31 +33,22 @@ export declare function isNonSemverSpecifier(versionSpec: string): boolean;
  */
 export declare function isSemverCompatible(currentVersionRange: string, latestVersion: string): boolean;
 /**
- * Collect dependencies from package.json according to flags.
+ * Collect ALL dependencies from package.json.
  * Returns a map of dependency name to its version and all locations where it appears.
  */
-export declare function collectTargetDependencies(pkg: any, args: any): {
+export declare function collectTargetDependencies(pkg: any): {
     map: Record<string, DependencyInfo>;
 };
 /**
  * Apply a version update into all relevant places in package.json for a dependency.
  */
 export declare function applyVersionUpdate(pkg: any, depName: string, newVersion: string, locations: Set<string>): void;
-export declare function findWorkspacePackageJsons(cwd: string): Promise<string[]>;
-/**
- * Check if we're in a monorepo by detecting workspace configuration
- */
-export declare function isMonorepo(cwd: string): Promise<boolean>;
-/**
- * Recursively find ALL package.json files in the directory tree
- */
-export declare function findAllPackageJsons(cwd: string): Promise<string[]>;
 /**
  * Fallback function to fetch package version directly from npm registry
  */
 export declare function fetchVersionFromRegistry(packageName: string): Promise<string>;
 /**
- * Get latest version with fallback mechanism and caching
+ * Get latest version of a package
  */
 export declare function getLatestVersion(packageName: string): Promise<string>;
 /**
@@ -81,41 +62,21 @@ export declare function getLatestVersion(packageName: string): Promise<string>;
  */
 export declare function checkPackageUpdate(packageName: string, versionSpec: string, locations: Set<string>, options: PackageCheckOptions): Promise<UpdateResult>;
 /**
- * Filter and prepare dependencies for updating
+ * Filter and prepare dependencies for updating with glob pattern support
  */
 export declare function prepareDependenciesForUpdate(allDepsMap: Record<string, DependencyInfo>, args: any): string[];
 /**
  * Update a single package.json file with new dependency versions
  */
-export declare function updatePackageJsonFile(packageJsonPath: string, dependencies: Record<string, DependencyInfo>, updatesToApply: UpdateResult[], savePrefix: string): Promise<number>;
-/**
- * Update dependencies across all workspace packages
- */
-export declare function updateWorkspacePackages(workspacePaths: string[], args: any, options: PackageCheckOptions): Promise<number>;
+export declare function updatePackageJsonFile(packageJsonPath: string, dependencies: Record<string, DependencyInfo>, updatesToApply: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
 /**
- * Display update results in a formatted way
+ * Display update results in a structured, file-by-file format
  */
-export declare function displayUpdateResults(results: UpdateResult[]): void;
-/**
- * Get globally installed packages for different package managers
- */
-export declare function getGlobalPackages(packageManager: string): Promise<Record<string, string>>;
+export declare function displayStructuredUpdateResults(results: UpdateResult[], packageJsonFiles: string[], fileDepsMap: Map<string, Record<string, any>>, showDetails?: boolean): void;
 /**
  * Run install command for the detected package manager
  */
-export declare function runInstallCommand(packageManager: any, linker?: string): Promise<void>;
-/**
- * Run install command with filter arguments for monorepo support
- */
-export declare function runInstallCommandWithFilter(packageManager: any, linker?: string, filterArgs?: string[]): Promise<void>;
-/**
- * Update global packages for different package managers
- */
-export declare function updateGlobalPackage(packageManager: string, packageName: string): Promise<boolean>;
-/**
- * Handle global package updates
- */
-export declare function handleGlobalUpdates(args: any): Promise<void>;
+export declare function runInstallCommand(packageManager: any): Promise<void>;
 export declare function getPmOptions(): Promise<{
     pmOptions: {
         label: string;
@@ -124,11 +85,3 @@ export declare function getPmOptions(): Promise<{
     }[];
     defaultValue: any;
 }>;
-export declare function upgradeDlerLocal(): Promise<UpgradeResult>;
-export declare function upgradeDlerGlobal(): Promise<UpgradeResult>;
-export declare function upgradeGit(): Promise<UpgradeResult>;
-export declare function upgradeNode(): Promise<UpgradeResult>;
-export declare function upgradeNpm(): Promise<UpgradeResult>;
-export declare function upgradeBun(): Promise<UpgradeResult>;
-export declare function upgradeYarn(): Promise<UpgradeResult>;
-export declare function upgradePnpm(): Promise<UpgradeResult>;