@reliverse/dler 2.3.2 → 2.3.4

package/dist/cmds/unused/impl.js

@@ -0,0 +1,415 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { createIncludeFilter } from "@reliverse/matcha";
+import path from "@reliverse/pathkit";
+import { logger } from "@reliverse/relinka";
+import { hasWorkspaces, readPackageJSON } from "@reliverse/typerso";
+const monorepoCache = /* @__PURE__ */ new Map();
+async function detectMonorepo(startDir) {
+  const cwd = resolve(startDir ?? process.cwd());
+  if (monorepoCache.has(cwd)) {
+    return monorepoCache.get(cwd);
+  }
+  let currentDir = cwd;
+  while (true) {
+    const packageJsonPath2 = path.join(currentDir, "package.json");
+    if (existsSync(packageJsonPath2)) {
+      const packageJson2 = await readPackageJSON(currentDir);
+      if (packageJson2 && hasWorkspaces(packageJson2)) {
+        const workspacePackages = await discoverWorkspacePackages(currentDir, packageJson2);
+        const result2 = {
+          isMonorepo: true,
+          rootPath: currentDir,
+          rootPackageJson: packageJson2,
+          workspacePackages
+        };
+        monorepoCache.set(cwd, result2);
+        return result2;
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error("No package.json found in current directory or any parent directory");
+  }
+  const packageJson = await readPackageJSON(cwd);
+  if (!packageJson) {
+    throw new Error("Could not read package.json");
+  }
+  const result = {
+    isMonorepo: false,
+    rootPath: cwd,
+    rootPackageJson: packageJson
+  };
+  monorepoCache.set(cwd, result);
+  return result;
+}
+const workspaceCache = /* @__PURE__ */ new Map();
+function hasBiomeConfig(rootPath) {
+  return existsSync(path.join(rootPath, "biome.json")) || existsSync(path.join(rootPath, "biome.jsonc"));
+}
+function hasTurboConfig(rootPath) {
+  return existsSync(path.join(rootPath, "turbo.json"));
+}
+async function discoverWorkspacePackages(monorepoRoot, rootPackageJson) {
+  if (workspaceCache.has(monorepoRoot)) {
+    return workspaceCache.get(monorepoRoot);
+  }
+  const packages = [];
+  if (!rootPackageJson.workspaces?.packages) {
+    workspaceCache.set(monorepoRoot, packages);
+    return packages;
+  }
+  const patterns = Array.isArray(rootPackageJson.workspaces.packages) ? rootPackageJson.workspaces.packages : [];
+  const packagePaths = [];
+  const validationPromises = [];
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      const glob = new Bun.Glob(pattern);
+      const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
+      for (const match of matches) {
+        const packagePath = resolve(monorepoRoot, match);
+        packagePaths.push(packagePath);
+        validationPromises.push(isValidWorkspacePackage(packagePath));
+      }
+    } else {
+      const packagePath = resolve(monorepoRoot, pattern);
+      packagePaths.push(packagePath);
+      validationPromises.push(isValidWorkspacePackage(packagePath));
+    }
+  }
+  const validationResults = await Promise.all(validationPromises);
+  for (let i = 0; i < packagePaths.length; i++) {
+    if (validationResults[i]) {
+      packages.push(packagePaths[i]);
+    }
+  }
+  workspaceCache.set(monorepoRoot, packages);
+  return packages;
+}
+async function isValidWorkspacePackage(packagePath) {
+  const packageJsonPath = path.join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  const packageJson = await readPackageJSON(packagePath);
+  return !!packageJson?.name;
+}
+function containsGlobPattern(str) {
+  return str.includes("*") || str.includes("?") || str.includes("[") || str.includes("{");
+}
+function containsMultipleTargets(str) {
+  return str.includes(" ") && str.trim().split(/\s+/).length > 1;
+}
+const packageInfoCache = /* @__PURE__ */ new Map();
+async function getPackageInfo(monorepoInfo) {
+  if (packageInfoCache.has(monorepoInfo.rootPath)) {
+    return packageInfoCache.get(monorepoInfo.rootPath);
+  }
+  const packages = [];
+  if (monorepoInfo.isMonorepo) {
+    if (hasDependencies(monorepoInfo.rootPackageJson)) {
+      packages.push({
+        name: monorepoInfo.rootPackageJson.name || "root",
+        path: monorepoInfo.rootPath,
+        json: monorepoInfo.rootPackageJson,
+        packagePath: monorepoInfo.rootPath,
+        packageJson: monorepoInfo.rootPackageJson
+      });
+    }
+    if (monorepoInfo.workspacePackages) {
+      for (const packagePath of monorepoInfo.workspacePackages) {
+        const packageJson = await readPackageJSON(packagePath);
+        if (packageJson && hasDependencies(packageJson)) {
+          packages.push({
+            name: packageJson.name || "unnamed",
+            path: packagePath,
+            json: packageJson,
+            packagePath,
+            packageJson
+          });
+        }
+      }
+    }
+  } else {
+    packages.push({
+      name: monorepoInfo.rootPackageJson.name || "project",
+      path: monorepoInfo.rootPath,
+      json: monorepoInfo.rootPackageJson,
+      packagePath: monorepoInfo.rootPath,
+      packageJson: monorepoInfo.rootPackageJson
+    });
+  }
+  packageInfoCache.set(monorepoInfo.rootPath, packages);
+  return packages;
+}
+function hasDependencies(packageJson) {
+  return !!(packageJson.dependencies || packageJson.devDependencies || packageJson.peerDependencies || packageJson.optionalDependencies);
+}
+async function resolveTargetPackages(monorepoInfo, targetOption, w) {
+  const allPackages = await getPackageInfo(monorepoInfo);
+  if (!(targetOption || w)) {
+    const currentDir = process.cwd();
+    const currentPackage = allPackages.find((pkg) => pkg.path === currentDir);
+    if (currentPackage) {
+      return [currentPackage];
+    }
+    return allPackages;
+  }
+  if (w) {
+    const rootPackage = allPackages.find((pkg) => pkg.path === monorepoInfo.rootPath);
+    return rootPackage ? [rootPackage] : [];
+  }
+  if (targetOption) {
+    if (containsGlobPattern(targetOption) || containsMultipleTargets(targetOption)) {
+      const targets = [];
+      if (containsMultipleTargets(targetOption)) {
+        targets.push(...targetOption.trim().split(/\s+/));
+      } else {
+        targets.push(targetOption);
+      }
+      const matchedPackages = [];
+      const filter = createIncludeFilter(targets);
+      const matchingPackages = filter(allPackages);
+      matchedPackages.push(...matchingPackages);
+      return matchedPackages;
+    } else {
+      const pkg = allPackages.find(
+        (p) => p.name === targetOption || relative(monorepoInfo.rootPath, p.path) === targetOption || p.path === resolve(monorepoInfo.rootPath, targetOption)
+      );
+      return pkg ? [pkg] : [];
+    }
+  }
+  return [];
+}
+function getSourceFiles(packagePath, rootPath) {
+  const files = [];
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  const skipDirs = ["node_modules", ".git", "dist", "build", ".cache", "coverage", ".turbo"];
+  function scanDir(dir) {
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          if (!skipDirs.includes(entry)) {
+            scanDir(fullPath);
+          }
+        } else if (stat.isFile()) {
+          const ext = path.extname(entry);
+          if (extensions.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  scanDir(packagePath);
+  return files;
+}
+function analyzePackageScripts(packageJson) {
+  const usedPackages = /* @__PURE__ */ new Set();
+  if (packageJson.scripts) {
+    for (const script of Object.values(packageJson.scripts)) {
+      const buildTools = ["biome", "turbo", "ultracite"];
+      for (const tool of buildTools) {
+        if (script.includes(tool)) {
+          if (tool === "biome") {
+            usedPackages.add("@biomejs/biome");
+          } else {
+            usedPackages.add(tool);
+          }
+        }
+      }
+    }
+  }
+  return usedPackages;
+}
+function analyzeSourceFile(filePath, packageJson) {
+  const usedPackages = /* @__PURE__ */ new Set();
+  const packageName = packageJson.name || "";
+  try {
+    const content = require("node:fs").readFileSync(filePath, "utf8");
+    const importPatterns = [
+      // ES6 imports
+      /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+      // Dynamic imports
+      /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      // Require statements
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      // TypeScript type imports
+      /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+    ];
+    for (const pattern of importPatterns) {
+      let match = pattern.exec(content);
+      while (match !== null) {
+        const importedPackage = match[1];
+        if (!importedPackage) continue;
+        if (!(importedPackage.startsWith(".") || path.extname(importedPackage))) {
+          const basePackage = importedPackage.split("/")[0];
+          if (basePackage && basePackage.startsWith("@")) {
+            const parts = importedPackage.split("/");
+            if (parts.length >= 2) {
+              usedPackages.add(`${parts[0]}/${parts[1]}`);
+            }
+          } else if (basePackage) {
+            usedPackages.add(basePackage);
+          }
+        }
+        match = pattern.exec(content);
+      }
+    }
+    if (content.includes(packageName)) {
+      usedPackages.delete(packageName);
+    }
+  } catch (error) {
+  }
+  return usedPackages;
+}
+function collectAllDependencies(packageJson, scope, includePeer = false) {
+  const allDeps = {};
+  const depTypes = [
+    { key: "dependencies", type: "prod" },
+    { key: "devDependencies", type: "dev" },
+    { key: "peerDependencies", type: "peer" },
+    { key: "optionalDependencies", type: "optional" }
+  ];
+  for (const { key, type } of depTypes) {
+    if (packageJson[key] && (!scope || scope === type)) {
+      if (type === "peer" && !includePeer) {
+        continue;
+      }
+      Object.assign(allDeps, packageJson[key]);
+    }
+  }
+  return allDeps;
+}
+export async function findUnusedDependencies(options) {
+  const monorepoInfo = await detectMonorepo(options.cwd);
+  const targetPackages = await resolveTargetPackages(monorepoInfo, options.target, options.w);
+  if (targetPackages.length === 0) {
+    logger.warn("No packages found to analyze");
+    return;
+  }
+  const hasBiome = hasBiomeConfig(monorepoInfo.rootPath);
+  const hasTurbo = hasTurboConfig(monorepoInfo.rootPath);
+  let totalUnused = 0;
+  const results = [];
+  for (const targetPackage of targetPackages) {
+    if (options.verbose) {
+      logger.log(`Analyzing ${targetPackage.packageJson.name || "unnamed package"}...`);
+    }
+    const sourceFiles = getSourceFiles(targetPackage.packagePath, monorepoInfo.rootPath);
+    const usedPackages = /* @__PURE__ */ new Set();
+    for (const file of sourceFiles) {
+      const fileUsedPackages = analyzeSourceFile(file, targetPackage.packageJson);
+      for (const pkg of fileUsedPackages) {
+        usedPackages.add(pkg);
+      }
+    }
+    const scriptUsedPackages = analyzePackageScripts(targetPackage.packageJson);
+    for (const pkg of scriptUsedPackages) {
+      usedPackages.add(pkg);
+    }
+    if (hasBiome) {
+      usedPackages.add("@biomejs/biome");
+      usedPackages.add("ultracite");
+    }
+    if (hasTurbo) {
+      usedPackages.add("turbo");
+    }
+    const allDeps = collectAllDependencies(
+      targetPackage.packageJson,
+      options.scope,
+      options.includePeer
+    );
+    const unusedDeps = [];
+    for (const [depName, depVersion] of Object.entries(allDeps)) {
+      if (options.ignore?.includes(depName)) {
+        continue;
+      }
+      if (!usedPackages.has(depName)) {
+        let scope = "unknown";
+        if (targetPackage.packageJson.dependencies?.[depName]) {
+          scope = "prod";
+        } else if (targetPackage.packageJson.devDependencies?.[depName]) {
+          scope = "dev";
+        } else if (targetPackage.packageJson.peerDependencies?.[depName]) {
+          scope = "peer";
+        } else if (targetPackage.packageJson.optionalDependencies?.[depName]) {
+          scope = "optional";
+        }
+        unusedDeps.push({
+          name: depName,
+          scope,
+          version: depVersion
+        });
+      }
+    }
+    if (unusedDeps.length > 0) {
+      results.push({
+        packageName: targetPackage.packageJson.name || "unnamed package",
+        packagePath: targetPackage.packagePath,
+        unusedDeps
+      });
+      totalUnused += unusedDeps.length;
+    }
+  }
+  if (results.length === 0) {
+    logger.success("\u2705 No unused dependencies found!");
+    return;
+  }
+  logger.log(`
+\u{1F4E6} Found ${totalUnused} unused dependencies across ${results.length} packages:
+`);
+  const packageSuggestions = [];
+  for (const result of results) {
+    const relativePath = relative(process.cwd(), result.packagePath);
+    const depsByScope = {};
+    const allDeps = [];
+    for (const dep of result.unusedDeps) {
+      if (!depsByScope[dep.scope]) {
+        depsByScope[dep.scope] = [];
+      }
+      depsByScope[dep.scope].push(dep.name);
+      allDeps.push(dep);
+    }
+    packageSuggestions.push({
+      packageName: result.packageName,
+      packagePath: result.packagePath,
+      relativePath,
+      depsByScope,
+      allDeps
+    });
+  }
+  for (const suggestion of packageSuggestions) {
+    logger.log(`\u{1F4C1} ${suggestion.packageName} (${suggestion.relativePath}):`);
+    for (const dep of suggestion.allDeps) {
+      logger.log(`  \u274C ${dep.name}@${dep.version} (${dep.scope})`);
+    }
+    logger.log("");
+  }
+  logger.log("\u{1F527} Suggested removal commands:");
+  for (const suggestion of packageSuggestions) {
+    const packageTarget = suggestion.relativePath === "package.json" ? "." : suggestion.relativePath;
+    for (const [scope, deps] of Object.entries(suggestion.depsByScope)) {
+      if (deps.length > 0) {
+        const scopeFlag = scope === "prod" ? "" : ` --${scope}`;
+        const depList = deps.join(" ");
+        logger.log(`  bun dler rm ${depList} --target "${packageTarget}"${scopeFlag}`);
+      }
+    }
+    logger.log("");
+  }
+  logger.log(`\u{1F4A1} Use --ignore flag to exclude specific packages from analysis`);
+  logger.log(
+    `\u{1F4A1} If some dep is used, but was marked as unused, please create an issue: https://github.com/reliverse/dler/issues`
+  );
+}

package/dist/cmds/update/cmd.d.ts

@@ -1,12 +1,2 @@
-declare const _default: import("@reliverse/rempts-core").Command<{
-    ci: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    cwd: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-    name: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-    ignore: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-    dryRun: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    install: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    allowMajor: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    details: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    ignoreFields: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-}, {}, string>;
+declare const _default: any;
 export default _default;

package/dist/cmds/update/cmd.js

@@ -1,16 +1,21 @@
 import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 import { logger } from "@reliverse/relinka";
 import { defineCommand, option } from "@reliverse/rempts-core";
 import { type } from "arktype";
 import { msgs } from "../../const.js";
 import {
-  checkPackageUpdatesForFile,
+  checkPackageUpdatesForAllFiles,
   handleInstallation,
   prepareAllUpdateCandidates,
   updatePackageJsonFileDirectly,
   validatePackageJson
 } from "./impl.js";
-import { displayStructuredUpdateResults } from "./utils.js";
+import {
+  displayStructuredUpdateResults,
+  initializeCache,
+  prepareDependenciesForUpdate
+} from "./utils.js";
 export default defineCommand({
   description: "Update all dependencies to their latest versions across all package.json files. Supports selective updates with glob patterns and comprehensive filtering options.",
   options: {
@@ -27,11 +32,13 @@ export default defineCommand({
       description: "Dependencies to exclude from updates, supports glob patterns (e.g. 'eslint-*', '@types/*')"
     }),
     dryRun: option(type("boolean | undefined"), {
+      short: "n",
       description: "Preview updates without making changes"
     }),
     install: option(type("boolean | undefined"), {
       description: "Run install after updating (default: true)",
-      short: "i"
+      short: "i",
+      default: true
     }),
     allowMajor: option(type("boolean | undefined"), {
       description: "Allow major version updates (default: true)"
@@ -42,6 +49,10 @@ export default defineCommand({
     }),
     ignoreFields: option(type("string | undefined"), {
       description: "Dependency fields to ignore (e.g., 'peerDependencies,catalog')"
+    }),
+    verbose: option(type("boolean | undefined"), {
+      description: "Verbose output (shows install command output)",
+      short: "v"
     })
   },
   handler: async ({ flags }) => {
@@ -51,48 +62,91 @@ export default defineCommand({
         process.exit(1);
       }
       const ci = flags.ci ?? (!process.stdout.isTTY || !!process.env.CI);
+      const cwd = flags.cwd;
       const dryRun = flags.dryRun ?? false;
-      const install = flags.install ?? true;
-      const allowMajor = flags.allowMajor ?? true;
+      const install = flags.install;
+      const allowMajor = true;
       const details = flags.details ?? false;
+      const verbose = flags.verbose ?? false;
       const isDryRun = dryRun;
       const shouldInstall = install;
       const showDetails = details;
+      const isVerbose = verbose;
       const fieldsToIgnore = flags.ignoreFields ? typeof flags.ignoreFields === "string" ? flags.ignoreFields.split(",").map((s) => s.trim()) : [] : [];
       await validatePackageJson();
-      const { packageJsonFiles, fileDepsMap } = await prepareAllUpdateCandidates();
+      await initializeCache(isVerbose);
+      let effectiveCwd = cwd;
+      if (!effectiveCwd) {
+        const currentDir = process.cwd();
+        const hasLocalPackageJson = await fs.pathExists(path.join(currentDir, "package.json"));
+        if (hasLocalPackageJson) {
+          effectiveCwd = ".";
+        }
+      }
+      const { packageJsonFiles, fileDepsMap } = await prepareAllUpdateCandidates(effectiveCwd);
       if (packageJsonFiles.length === 0) {
         logger.log("No package.json files found");
         return;
       }
-      let totalUpdated = 0;
-      const allResults = [];
+      const allUpdateResults = [];
+      const updateArgs = {
+        ci,
+        ...flags.name && {
+          name: typeof flags.name === "string" ? [flags.name] : flags.name
+        },
+        ...flags.ignore && {
+          ignore: typeof flags.ignore === "string" ? [flags.ignore] : flags.ignore
+        },
+        allowMajor,
+        dryRun: isDryRun,
+        install: shouldInstall,
+        ignoreFields: fieldsToIgnore,
+        concurrency: 50
+      };
       for (const packageJsonPath of packageJsonFiles) {
         const fileDeps = fileDepsMap.get(packageJsonPath);
-        if (!fileDeps) {
-          continue;
+        if (!fileDeps) continue;
+        const filteredDeps = prepareDependenciesForUpdate(fileDeps, {
+          name: updateArgs.name,
+          ignore: updateArgs.ignore,
+          ignoreFields: updateArgs.ignoreFields
+        });
+        if (filteredDeps.length === 0) continue;
+        const fileDepsMapForCheck = /* @__PURE__ */ new Map();
+        for (const depName of filteredDeps) {
+          const depInfo = fileDeps[depName];
+          if (depInfo) {
+            fileDepsMapForCheck.set(depName, {
+              versionSpec: depInfo.versionSpec,
+              locations: new Set(depInfo.locations),
+              files: /* @__PURE__ */ new Set([packageJsonPath])
+            });
+          }
         }
-        const updateArgs = {
-          ci,
-          ...flags.name && {
-            name: typeof flags.name === "string" ? [flags.name] : flags.name
-          },
-          ...flags.ignore && {
-            ignore: typeof flags.ignore === "string" ? [flags.ignore] : flags.ignore
-          },
-          allowMajor,
-          dryRun: isDryRun,
-          install: shouldInstall,
-          ignoreFields: fieldsToIgnore
-        };
-        const results = await checkPackageUpdatesForFile(fileDeps, updateArgs);
-        allResults.push(...results);
-        const toUpdate = results.filter((r) => r.updated && !r.error);
+        const filteredUpdateArgs = { ...updateArgs };
+        filteredUpdateArgs.name = void 0;
+        filteredUpdateArgs.ignore = void 0;
+        const fileResults2 = await checkPackageUpdatesForAllFiles(
+          fileDepsMapForCheck,
+          filteredUpdateArgs
+        );
+        allUpdateResults.push(...fileResults2);
+      }
+      const fileUpdatePromises = packageJsonFiles.map(async (packageJsonPath) => {
+        const fileDeps = fileDepsMap.get(packageJsonPath);
+        if (!fileDeps) return { results: [], updated: 0 };
+        const fileResults2 = allUpdateResults.filter((result) => {
+          return fileDeps[result.package] !== void 0;
+        });
+        const toUpdate = fileResults2.filter((r) => r.updated && !r.error);
         if (toUpdate.length > 0) {
           if (isDryRun) {
             const relativePath = path.relative(process.cwd(), packageJsonPath);
-            logger.debug(`Would update ${toUpdate.length} dependencies in ${relativePath}`);
-            continue;
+            const updateDetails = toUpdate.map((update) => `${update.package}\u2192${update.latestVersion}`).join(", ");
+            logger.log(
+              `Would update ${toUpdate.length} dependencies in ${relativePath}: ${updateDetails}`
+            );
+            return { results: fileResults2, updated: toUpdate.length };
           }
           const updated = await updatePackageJsonFileDirectly(
             packageJsonPath,
@@ -101,14 +155,32 @@ export default defineCommand({
             "^",
             fieldsToIgnore
           );
-          totalUpdated += updated;
           if (updated > 0) {
             const relativePath = path.relative(process.cwd(), packageJsonPath);
-            logger.debug(`Updated ${updated} dependencies in ${relativePath}`);
+            const updateDetails = toUpdate.map((update) => `${update.package}\u2192${update.latestVersion}`).join(", ");
+            logger.log(`Updated ${updated} dependencies in ${relativePath}: ${updateDetails}`);
           }
+          return { results: fileResults2, updated };
         }
+        return { results: fileResults2, updated: 0 };
+      });
+      const fileResults = await Promise.allSettled(fileUpdatePromises);
+      const processedFileResults = fileResults.map((result, index) => {
+        if (result.status === "fulfilled") {
+          return result.value;
+        } else {
+          const packageJsonPath = packageJsonFiles[index];
+          logger.warn(
+            `Failed to process ${packageJsonPath ? path.relative(process.cwd(), packageJsonPath) : `file at index ${index}`}: ${result.reason}`
+          );
+          return { results: [], updated: 0 };
+        }
+      });
+      let totalUpdated = 0;
+      for (const result of processedFileResults) {
+        totalUpdated += result.updated;
       }
-      displayStructuredUpdateResults(allResults, packageJsonFiles, fileDepsMap, showDetails);
+      displayStructuredUpdateResults(allUpdateResults, packageJsonFiles, fileDepsMap, showDetails);
       if (totalUpdated === 0) {
         if (isDryRun) {
           logger.log("Dry run mode - no changes would be made");
@@ -117,16 +189,21 @@ export default defineCommand({
         }
         return;
       }
+      const action = isDryRun ? "Would update" : "Updated";
       if (packageJsonFiles.length > 1) {
         logger.log(
-          `Updated ${totalUpdated} dependencies across ${packageJsonFiles.length} package.json files`
+          `${action} ${totalUpdated} dependencies across ${packageJsonFiles.length} package.json files`
         );
       } else {
-        logger.log(`Updated ${totalUpdated} dependencies`);
+        logger.log(`${action} ${totalUpdated} dependencies`);
       }
-      if (shouldInstall) {
-        await handleInstallation();
-      } else {
+      if (shouldInstall && totalUpdated > 0 && !isDryRun) {
+        await handleInstallation(isVerbose);
+      } else if (shouldInstall && totalUpdated === 0) {
+        logger.log("No dependencies were updated, skipping install");
+      } else if (shouldInstall && totalUpdated > 0 && isDryRun) {
+        logger.log("Dry run mode - no changes were made, skipping install");
+      } else if (!shouldInstall && totalUpdated > 0) {
         logger.log(
           "Run 'bun install' to apply the changes (use --no-install to skip automatic installation)"
         );

package/dist/cmds/update/impl.d.ts

@@ -9,13 +9,19 @@ interface UpdateArgs {
     allowMajor?: boolean;
     concurrency?: number;
     ignoreFields?: string[];
+    verbose?: boolean;
 }
 export declare function validatePackageJson(): Promise<string>;
-export declare function prepareAllUpdateCandidates(): Promise<{
+export declare function prepareAllUpdateCandidates(cwd?: string): Promise<{
     packageJsonFiles: string[];
     fileDepsMap: Map<string, Record<string, DependencyInfo>>;
 }>;
 export declare function checkPackageUpdatesForFile(fileDepsMap: Record<string, DependencyInfo>, args: UpdateArgs): Promise<UpdateResult[]>;
+export declare function checkPackageUpdatesForAllFiles(globalDepsMap: Map<string, {
+    versionSpec: string;
+    locations: Set<string>;
+    files: Set<string>;
+}>, args: UpdateArgs): Promise<UpdateResult[]>;
 export declare function updatePackageJsonFileDirectly(packageJsonPath: string, fileDepsMap: Record<string, DependencyInfo>, updatesToApply: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
-export declare function handleInstallation(): Promise<void>;
+export declare function handleInstallation(verbose?: boolean): Promise<void>;
 export {};