@reliverse/dler 1.7.82 → 1.7.84

package/bin/app/update/cmd.d.ts

@@ -64,9 +64,24 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "array";
         description: string;
     };
-    "update-catalogs": {
+    "all-workspaces": {
         type: "boolean";
         description: string;
     };
+    "root-only": {
+        type: "boolean";
+        description: string;
+    };
+    "save-prefix": {
+        type: "string";
+        description: string;
+        allowed: string[];
+        default: string;
+    };
+    "allow-major": {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
 }>;
 export default _default;

package/bin/app/update/cmd.js

@@ -7,16 +7,25 @@ import { lookpath } from "lookpath";
 import pMap from "p-map";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
+import { glob } from "tinyglobby";
 import { getConfigBunfig } from "../../libs/sdk/sdk-impl/config/load.js";
 import { updateCatalogs, isCatalogSupported } from "../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
 import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
 import { latestVersion } from "../../libs/sdk/sdk-impl/utils/pm/pm-meta.js";
+const versionCache = /* @__PURE__ */ new Map();
+const CACHE_TTL = 5 * 60 * 1e3;
 function isNpmAlias(versionSpec) {
   return versionSpec.startsWith("npm:");
 }
 function isWorkspaceDependency(versionSpec) {
   return versionSpec.startsWith("workspace:");
 }
+function isCatalogReference(versionSpec) {
+  return versionSpec.startsWith("catalog:");
+}
+function isNonSemverSpecifier(versionSpec) {
+  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
+}
 function isSemverCompatible(currentVersionRange, latestVersion2) {
   try {
     if (isNpmAlias(currentVersionRange)) {
@@ -33,6 +42,172 @@ function isSemverCompatible(currentVersionRange, latestVersion2) {
     return false;
   }
 }
+function collectTargetDependencies(pkg, args) {
+  const map = {};
+  const dependencies = pkg.dependencies || {};
+  const devDependencies = pkg.devDependencies || {};
+  const peerDependencies = pkg.peerDependencies || {};
+  const optionalDependencies = pkg.optionalDependencies || {};
+  const includeDeps = !args["dev-only"] && !args["peer-only"] && !args["optional-only"] && !args["catalogs-only"];
+  const includeCatalogs = !args["dev-only"] && !args["peer-only"] && !args["optional-only"] && !args["prod-only"];
+  if (args["prod-only"] || includeDeps) {
+    for (const dep of Object.keys(dependencies)) {
+      const version = dependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("dependencies");
+    }
+  }
+  if (args["dev-only"] || includeDeps) {
+    for (const dep of Object.keys(devDependencies)) {
+      const version = devDependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("devDependencies");
+    }
+  }
+  if (args["peer-only"] || includeDeps) {
+    for (const dep of Object.keys(peerDependencies)) {
+      const version = peerDependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("peerDependencies");
+    }
+  }
+  if (args["optional-only"] || includeDeps) {
+    for (const dep of Object.keys(optionalDependencies)) {
+      const version = optionalDependencies[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("optionalDependencies");
+    }
+  }
+  if (args["catalogs-only"] || includeCatalogs) {
+    const workspacesCatalog = pkg.workspaces?.catalog || {};
+    for (const dep of Object.keys(workspacesCatalog)) {
+      const version = workspacesCatalog[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("catalog");
+    }
+    const workspacesCatalogs = pkg.workspaces?.catalogs || {};
+    for (const catalogName of Object.keys(workspacesCatalogs)) {
+      const catalog = workspacesCatalogs[catalogName] || {};
+      for (const dep of Object.keys(catalog)) {
+        const version = catalog[dep];
+        if (!version) continue;
+        if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+        map[dep].versionSpec = version;
+        map[dep].locations.add(`catalogs.${catalogName}`);
+      }
+    }
+    const topLevelCatalog = pkg.catalog || {};
+    for (const dep of Object.keys(topLevelCatalog)) {
+      const version = topLevelCatalog[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add("catalog");
+    }
+    const topLevelCatalogs = pkg.catalogs || {};
+    for (const catalogName of Object.keys(topLevelCatalogs)) {
+      const catalog = topLevelCatalogs[catalogName] || {};
+      for (const dep of Object.keys(catalog)) {
+        const version = catalog[dep];
+        if (!version) continue;
+        if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+        map[dep].versionSpec = version;
+        map[dep].locations.add(`catalogs.${catalogName}`);
+      }
+    }
+  }
+  return { map };
+}
+function applyVersionUpdate(pkg, depName, newVersion, locations) {
+  if (locations.has("dependencies")) {
+    if (!pkg.dependencies) pkg.dependencies = {};
+    pkg.dependencies[depName] = newVersion;
+  }
+  if (locations.has("devDependencies")) {
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    pkg.devDependencies[depName] = newVersion;
+  }
+  if (locations.has("peerDependencies")) {
+    if (!pkg.peerDependencies) pkg.peerDependencies = {};
+    pkg.peerDependencies[depName] = newVersion;
+  }
+  if (locations.has("optionalDependencies")) {
+    if (!pkg.optionalDependencies) pkg.optionalDependencies = {};
+    pkg.optionalDependencies[depName] = newVersion;
+  }
+  const ensureWorkspaces = () => {
+    if (!pkg.workspaces) pkg.workspaces = {};
+  };
+  if (locations.has("catalog")) {
+    ensureWorkspaces();
+    if (!pkg.workspaces.catalog) pkg.workspaces.catalog = {};
+    pkg.workspaces.catalog[depName] = newVersion;
+    if (pkg.catalog) pkg.catalog[depName] = newVersion;
+  }
+  for (const loc of locations) {
+    const match = /^catalogs\.(.+)$/.exec(loc);
+    if (match) {
+      const catalogName = match[1] ?? "";
+      if (!catalogName) continue;
+      ensureWorkspaces();
+      if (!pkg.workspaces.catalogs) pkg.workspaces.catalogs = {};
+      if (!pkg.workspaces.catalogs[catalogName])
+        pkg.workspaces.catalogs[catalogName] = {};
+      pkg.workspaces.catalogs[catalogName][depName] = newVersion;
+      if (pkg.catalogs && pkg.catalogs[catalogName]) {
+        pkg.catalogs[catalogName][depName] = newVersion;
+      }
+    }
+  }
+}
+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;
+}
+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;
+  }
+}
 async function fetchVersionFromRegistry(packageName) {
   const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
   if (!response.ok) {
@@ -42,12 +217,21 @@ async function fetchVersionFromRegistry(packageName) {
   return data.version;
 }
 async function getLatestVersion(packageName) {
+  const cached = versionCache.get(packageName);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL) {
+    return cached.version;
+  }
   try {
-    return await latestVersion(packageName);
+    const version = await latestVersion(packageName);
+    versionCache.set(packageName, { version, timestamp: now });
+    return version;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     try {
-      return await fetchVersionFromRegistry(packageName);
+      const version = await fetchVersionFromRegistry(packageName);
+      versionCache.set(packageName, { version, timestamp: now });
+      return version;
     } catch (fallbackError) {
       throw new Error(
         `Latest version main check and npm registry fallback failed. Main check error: ${errorMessage}. Registry error: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
@@ -55,6 +239,158 @@ async function getLatestVersion(packageName) {
     }
   }
 }
+async function checkPackageUpdate(packageName, versionSpec, locations, options) {
+  try {
+    const latest = await getLatestVersion(packageName);
+    const cleanCurrent = versionSpec.replace(/^[\^~]/, "");
+    let isCompatible = isSemverCompatible(versionSpec, latest);
+    const isExact = !versionSpec.startsWith("^") && !versionSpec.startsWith("~");
+    if (isExact || !isCompatible && options.allowMajor) {
+      isCompatible = true;
+    }
+    return {
+      package: packageName,
+      currentVersion: cleanCurrent,
+      latestVersion: latest,
+      updated: latest !== cleanCurrent && isCompatible,
+      semverCompatible: isCompatible,
+      location: Array.from(locations).join(", ")
+    };
+  } catch (error) {
+    return {
+      package: packageName,
+      currentVersion: versionSpec,
+      latestVersion: versionSpec,
+      updated: false,
+      error: error instanceof Error ? error.message : String(error),
+      semverCompatible: false,
+      location: Array.from(locations).join(", ")
+    };
+  }
+}
+function prepareDependenciesForUpdate(allDepsMap, args) {
+  const depsToUpdate = Object.keys(allDepsMap);
+  let filteredDeps = [];
+  if (args.name && args.name.length > 0) {
+    filteredDeps = args.name.filter((dep) => dep in allDepsMap);
+    const notFound = args.name.filter((dep) => !(dep in allDepsMap));
+    if (notFound.length > 0) {
+      relinka("warn", `Dependencies not found: ${notFound.join(", ")}`);
+    }
+  } else {
+    const ignoreList = args.ignore || [];
+    filteredDeps = depsToUpdate.filter((dep) => !ignoreList.includes(dep));
+  }
+  return filteredDeps.filter((dep) => {
+    const versionSpec = allDepsMap[dep]?.versionSpec ?? "";
+    if (!versionSpec) return false;
+    if (isNonSemverSpecifier(versionSpec)) return false;
+    return true;
+  });
+}
+async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix) {
+  if (updatesToApply.length === 0) return 0;
+  try {
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+    const updatedPackageJson = { ...packageJson };
+    for (const update of updatesToApply) {
+      const prefix = savePrefix === "none" ? "" : savePrefix;
+      const newVersion = `${prefix}${update.latestVersion}`;
+      const locations = dependencies[update.package]?.locations || /* @__PURE__ */ new Set();
+      applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
+    return updatesToApply.length;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+async function updateWorkspacePackages(workspacePaths, args, options) {
+  if (workspacePaths.length === 0) return 0;
+  relinka("info", `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;
+}
+function displayUpdateResults(results) {
+  const toUpdate = results.filter((r) => r.updated && !r.error);
+  const errors = results.filter((r) => r.error);
+  const upToDate = results.filter((r) => !r.updated && !r.error && r.semverCompatible);
+  if (errors.length > 0) {
+    relinka("warn", `Failed to check ${errors.length} dependencies:`);
+    for (const error of errors) {
+      relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
+    }
+  }
+  if (upToDate.length > 0) {
+    relinka("success", `${upToDate.length} dependencies are up to date`);
+  }
+  if (toUpdate.length === 0) {
+    relinka("success", `All ${upToDate.length} deps are already up to date`);
+    return;
+  }
+  relinka("info", `${toUpdate.length} dependencies can be updated:`);
+  const byLocation = /* @__PURE__ */ new Map();
+  for (const update of toUpdate) {
+    const location = update.location || "unknown";
+    if (!byLocation.has(location)) {
+      byLocation.set(location, []);
+    }
+    byLocation.get(location).push(update);
+  }
+  for (const [location, updates] of byLocation.entries()) {
+    relinka("log", `  ${location}:`);
+    for (const update of updates) {
+      relinka("log", `    ${update.package}: ${update.currentVersion} \u2192 ${update.latestVersion}`);
+    }
+  }
+}
 async function getGlobalPackages(packageManager) {
   try {
     let result;
@@ -335,16 +671,16 @@ async function handleGlobalUpdates(args) {
 export default defineCommand({
   meta: {
     name: "update",
-    description: "Update dependencies to the latest version"
+    description: "Update all dependencies and catalogs to their latest available versions (includes workspaces in monorepos)"
   },
   args: defineArgs({
     name: {
       type: "array",
-      description: "The names of the dependencies to update (leave empty to update all)"
+      description: "Specific dependencies to update (default: all dependencies)"
     },
     ignore: {
       type: "array",
-      description: "The names of the dependencies to ignore when --name is not provided"
+      description: "Dependencies to exclude from updates"
     },
     "dev-only": {
       type: "boolean",
@@ -364,11 +700,11 @@ export default defineCommand({
     },
     "catalogs-only": {
       type: "boolean",
-      description: "Update only catalog dependencies"
+      description: "Update ONLY catalog dependencies (catalogs are included by default)"
     },
     "dry-run": {
       type: "boolean",
-      description: "Show what would be updated without making changes"
+      description: "Preview updates without making changes"
     },
     concurrency: {
       type: "number",
@@ -377,43 +713,76 @@ export default defineCommand({
     },
     "with-check-script": {
       type: "boolean",
-      description: "Run `bun check` after updating (exclusive for bun environment at the moment)"
+      description: "Run `bun check` after updating (Bun only)"
     },
     linker: {
       type: "string",
-      description: "Linker strategy (pro tip: use 'isolated' in a monorepo project, 'hoisted' (default) in a project where you have only one package.json). When this option is explicitly set, it takes precedence over bunfig.toml install.linker setting.",
+      description: "Linker strategy: 'isolated' for monorepos, 'hoisted' for single packages",
       allowed: ["isolated", "hoisted"],
       default: "hoisted"
     },
     "with-install": {
       type: "boolean",
-      description: "Run the install step after updating dependencies",
+      description: "Run install after updating",
       alias: "with-i"
     },
     global: {
       type: "boolean",
-      description: "Update global packages instead of local dependencies",
+      description: "Update global packages",
       alias: "g"
     },
     interactive: {
       type: "boolean",
-      description: "Interactively select which dependencies to update"
+      description: "Interactively select dependencies to update"
     },
     filter: {
       type: "array",
-      description: "Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c', './packages/pkg-*')"
+      description: "Filter workspaces (e.g., 'pkg-*', '!pkg-c')"
+    },
+    "all-workspaces": {
+      type: "boolean",
+      description: "Update dependencies across all workspace packages (automatic in monorepos)"
+    },
+    "root-only": {
+      type: "boolean",
+      description: "Update only the root package.json (skip workspace packages in monorepos)"
     },
-    "update-catalogs": {
+    "save-prefix": {
+      type: "string",
+      description: "Version prefix: '^', '~', or 'none' for exact",
+      allowed: ["^", "~", "none"],
+      default: "^"
+    },
+    "allow-major": {
       type: "boolean",
-      description: "Update catalog dependencies to latest versions"
+      description: "Allow major version updates to latest available (disable with --no-allow-major)",
+      default: true
     }
   }),
   async run({ args }) {
     try {
+      const exclusiveFlags = [
+        args["dev-only"],
+        args["prod-only"],
+        args["peer-only"],
+        args["optional-only"],
+        args["catalogs-only"]
+      ];
+      if (exclusiveFlags.filter(Boolean).length > 1) {
+        relinka(
+          "error",
+          "Cannot specify multiple exclusive flags (--dev-only, --prod-only, --peer-only, --optional-only, --catalogs-only)"
+        );
+        return process.exit(1);
+      }
+      if (args["all-workspaces"] && args["root-only"]) {
+        relinka("error", "Cannot specify both --all-workspaces and --root-only flags");
+        return process.exit(1);
+      }
       if (args.global) {
         return await handleGlobalUpdates(args);
       }
-      if (args["update-catalogs"]) {
+      if (args["catalogs-only"]) {
         const packageManager2 = await detectPackageManager(process.cwd());
         if (!packageManager2) {
           relinka("error", "Could not detect package manager");
@@ -438,146 +807,34 @@ export default defineCommand({
       let linkerSource = "CLI default";
       if (typeof Bun !== "undefined") {
         const bunfigConfig = await getConfigBunfig();
-        if (bunfigConfig?.install?.linker) {
-          const bunfigLinker = bunfigConfig.install.linker;
-          if ((bunfigLinker === "isolated" || bunfigLinker === "hoisted") && args.linker === "hoisted") {
-            effectiveLinker = bunfigLinker;
-            linkerSource = bunfigLinker === "hoisted" ? "bunfig.toml (same as default)" : "bunfig.toml";
-          }
+        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 argument (explicit override)";
+        linkerSource = "CLI override";
       }
       relinka("verbose", `Using linker strategy: ${effectiveLinker} (from ${linkerSource})`);
       const packageJson = await readPackageJSON();
-      const dependencies = packageJson.dependencies || {};
-      const devDependencies = packageJson.devDependencies || {};
-      const peerDependencies = packageJson.peerDependencies || {};
-      const optionalDependencies = packageJson.optionalDependencies || {};
-      const workspaces = packageJson.workspaces || {};
-      const catalog = workspaces.catalog || packageJson.catalog || {};
-      const catalogs = workspaces.catalogs || packageJson.catalogs || {};
-      let targetDeps = {};
-      const depSources = {};
-      const exclusiveFlags = [
-        args["dev-only"],
-        args["prod-only"],
-        args["peer-only"],
-        args["optional-only"],
-        args["catalogs-only"]
-      ].filter(Boolean);
-      if (exclusiveFlags.length > 1) {
-        relinka(
-          "error",
-          "Cannot specify multiple exclusive flags (--dev-only, --prod-only, --peer-only, --optional-only, --catalogs-only)"
-        );
-        return process.exit(1);
-      }
-      if (args["dev-only"]) {
-        targetDeps = { ...devDependencies };
-        Object.keys(devDependencies).forEach((dep) => {
-          depSources[dep] = "devDependencies";
-        });
-      } else if (args["prod-only"]) {
-        targetDeps = { ...dependencies };
-        Object.keys(dependencies).forEach((dep) => {
-          depSources[dep] = "dependencies";
-        });
-      } else if (args["peer-only"]) {
-        targetDeps = { ...peerDependencies };
-        Object.keys(peerDependencies).forEach((dep) => {
-          depSources[dep] = "peerDependencies";
-        });
-      } else if (args["optional-only"]) {
-        targetDeps = { ...optionalDependencies };
-        Object.keys(optionalDependencies).forEach((dep) => {
-          depSources[dep] = "optionalDependencies";
-        });
-      } else if (args["catalogs-only"]) {
-        Object.keys(catalog).forEach((dep) => {
-          targetDeps[dep] = catalog[dep];
-          depSources[dep] = "catalog";
-        });
-        Object.keys(catalogs).forEach((catalogName) => {
-          Object.keys(catalogs[catalogName]).forEach((dep) => {
-            targetDeps[dep] = catalogs[catalogName][dep];
-            depSources[dep] = `catalogs.${catalogName}`;
-          });
-        });
-      } else {
-        const allDeps = {};
-        const allDepSources = {};
-        Object.keys(dependencies).forEach((dep) => {
-          const version = dependencies[dep];
-          if (version) {
-            allDeps[dep] = version;
-            allDepSources[dep] = "dependencies";
-          }
-        });
-        Object.keys(devDependencies).forEach((dep) => {
-          const version = devDependencies[dep];
-          if (version) {
-            allDeps[dep] = version;
-            allDepSources[dep] = "devDependencies";
-          }
-        });
-        Object.keys(peerDependencies).forEach((dep) => {
-          const version = peerDependencies[dep];
-          if (version) {
-            allDeps[dep] = version;
-            allDepSources[dep] = "peerDependencies";
-          }
-        });
-        Object.keys(optionalDependencies).forEach((dep) => {
-          const version = optionalDependencies[dep];
-          if (version) {
-            allDeps[dep] = version;
-            allDepSources[dep] = "optionalDependencies";
-          }
-        });
-        Object.keys(catalog).forEach((dep) => {
-          allDeps[dep] = catalog[dep];
-          allDepSources[dep] = "catalog";
-        });
-        Object.keys(catalogs).forEach((catalogName) => {
-          Object.keys(catalogs[catalogName]).forEach((dep) => {
-            allDeps[dep] = catalogs[catalogName][dep];
-            allDepSources[dep] = `catalogs.${catalogName}`;
-          });
-        });
-        targetDeps = allDeps;
-        Object.assign(depSources, allDepSources);
-      }
-      const depsToUpdate = Object.keys(targetDeps);
-      let filteredDeps = [];
-      if (args.name && args.name.length > 0) {
-        filteredDeps = args.name.filter((dep) => dep in targetDeps);
-        const notFound = args.name.filter((dep) => !(dep in targetDeps));
-        if (notFound.length > 0) {
-          relinka("warn", `Dependencies not found: ${notFound.join(", ")}`);
-        }
-      } else {
-        const ignoreList = args.ignore || [];
-        filteredDeps = depsToUpdate.filter((dep) => !ignoreList.includes(dep));
-      }
-      const semverDeps = filteredDeps.filter((dep) => {
-        const versionSpec = targetDeps[dep];
-        return versionSpec && (versionSpec.startsWith("^") || versionSpec.startsWith("~"));
-      });
-      if (semverDeps.length === 0) {
-        relinka(
-          "warn",
-          "No dependencies to update (only semver-compatible dependencies with ^ or ~ prefixes are supported)"
-        );
+      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;
       }
+      const options = {
+        allowMajor: !!args["allow-major"],
+        savePrefix: args["save-prefix"],
+        concurrency: args.concurrency
+      };
       const results = await pMap(
-        semverDeps,
+        candidates,
         async (dep) => {
-          const currentVersion = targetDeps[dep];
-          if (!currentVersion) {
+          const depInfo = allDepsMap[dep];
+          if (!depInfo?.versionSpec) {
             return {
               package: dep,
               currentVersion: "unknown",
@@ -585,63 +842,21 @@ export default defineCommand({
               updated: false,
               error: "Current version not found",
               semverCompatible: false,
-              location: depSources[dep]
-            };
-          }
-          try {
-            const latest = await getLatestVersion(dep);
-            const cleanCurrent = currentVersion.replace(/^[\^~]/, "");
-            const isCompatible = isSemverCompatible(currentVersion, latest);
-            return {
-              package: dep,
-              currentVersion: cleanCurrent,
-              latestVersion: latest,
-              updated: latest !== cleanCurrent && isCompatible,
-              semverCompatible: isCompatible,
-              location: depSources[dep]
-            };
-          } catch (error) {
-            return {
-              package: dep,
-              currentVersion,
-              latestVersion: currentVersion,
-              updated: false,
-              error: error instanceof Error ? error.message : String(error),
-              semverCompatible: false,
-              location: depSources[dep]
+              location: Array.from(depInfo?.locations || ["unknown"]).join(", ")
             };
           }
+          return checkPackageUpdate(dep, depInfo.versionSpec, depInfo.locations, options);
         },
         { concurrency: args.concurrency }
       );
+      displayUpdateResults(results);
       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 && r.semverCompatible);
-      if (errors.length > 0) {
-        relinka("warn", `Failed to check ${errors.length} dependencies:`);
-        for (const error of errors) {
-          relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
-        }
-      }
       if (toUpdate.length === 0) {
-        relinka("success", `All ${upToDate.length} deps are already up to date`);
         return;
       }
-      if (upToDate.length > 0) {
-        relinka("success", `${upToDate.length} dependencies are up to date`);
-      }
-      if (toUpdate.length === 0) {
-        relinka("success", `All ${upToDate.length} deps are already up to date`);
-        return;
-      }
-      relinka("info", `${toUpdate.length} dependencies can be updated:`);
-      for (const update of toUpdate) {
-        relinka(
-          "log",
-          `  ${update.package} (${update.location}): ${update.currentVersion} \u2192 ${update.latestVersion}`
-        );
-      }
       if (args.interactive) {
+        const errors = results.filter((r) => r.error);
+        const upToDate = results.filter((r) => !r.updated && !r.error && r.semverCompatible);
         const allPackages = [
           ...toUpdate.map((pkg) => ({
             ...pkg,
@@ -691,68 +906,46 @@ export default defineCommand({
         relinka("info", "Dry run mode - no changes were made");
         return;
       }
-      const updatedPackageJson = { ...packageJson };
-      for (const update of toUpdate) {
-        const dep = update.package;
-        const newVersion = `^${update.latestVersion}`;
-        if (dependencies[dep]) {
-          if (!updatedPackageJson.dependencies) updatedPackageJson.dependencies = {};
-          updatedPackageJson.dependencies[dep] = newVersion;
-        }
-        if (devDependencies[dep]) {
-          if (!updatedPackageJson.devDependencies) updatedPackageJson.devDependencies = {};
-          updatedPackageJson.devDependencies[dep] = newVersion;
-        }
-        if (peerDependencies[dep]) {
-          if (!updatedPackageJson.peerDependencies) updatedPackageJson.peerDependencies = {};
-          updatedPackageJson.peerDependencies[dep] = newVersion;
-        }
-        if (optionalDependencies[dep]) {
-          if (!updatedPackageJson.optionalDependencies)
-            updatedPackageJson.optionalDependencies = {};
-          updatedPackageJson.optionalDependencies[dep] = newVersion;
-        }
-        if (catalog[dep]) {
-          if (!updatedPackageJson.workspaces) updatedPackageJson.workspaces = {};
-          if (!updatedPackageJson.workspaces.catalog)
-            updatedPackageJson.workspaces.catalog = {};
-          updatedPackageJson.workspaces.catalog[dep] = newVersion;
-          if (updatedPackageJson.catalog) {
-            updatedPackageJson.catalog[dep] = newVersion;
-          }
-        }
-        Object.keys(catalogs).forEach((catalogName) => {
-          if (catalogs[catalogName][dep]) {
-            if (!updatedPackageJson.workspaces)
-              updatedPackageJson.workspaces = {};
-            if (!updatedPackageJson.workspaces.catalogs)
-              updatedPackageJson.workspaces.catalogs = {};
-            if (!updatedPackageJson.workspaces.catalogs[catalogName]) {
-              updatedPackageJson.workspaces.catalogs[catalogName] = {};
-            }
-            updatedPackageJson.workspaces.catalogs[catalogName][dep] = newVersion;
-            if (updatedPackageJson.catalogs && updatedPackageJson.catalogs[catalogName]) {
-              updatedPackageJson.catalogs[catalogName][dep] = newVersion;
-            }
-          }
-        });
-      }
-      await fs.writeFile(
+      const rootUpdated = await updatePackageJsonFile(
         packageJsonPath,
-        JSON.stringify(updatedPackageJson, null, 2) + "\n",
-        "utf8"
+        allDepsMap,
+        toUpdate,
+        args["save-prefix"]
       );
-      relinka("success", `Updated ${toUpdate.length} dependencies in package.json`);
-      if (args["with-install"] !== true) {
-        const packageManager2 = await detectPackageManager(process.cwd());
-        const installCommand = packageManager2 ? `${packageManager2.command} install` : "your package manager's install command";
+      let totalUpdated = rootUpdated;
+      const shouldUpdateWorkspaces = args["all-workspaces"] || // Explicit flag
+      !args["root-only"] && await isMonorepo(process.cwd());
+      if (shouldUpdateWorkspaces) {
+        const workspacePkgJsons = await findWorkspacePackageJsons(process.cwd());
+        if (workspacePkgJsons.length > 0) {
+          const workspaceUpdated = await updateWorkspacePackages(workspacePkgJsons, args, options);
+          totalUpdated += workspaceUpdated;
+        } else if (args["all-workspaces"]) {
+          relinka("warn", "No workspace packages found but --all-workspaces flag was provided");
+        }
+      } else if (await isMonorepo(process.cwd())) {
+        relinka("info", "Skipping workspace packages due to --root-only flag");
+      }
+      const isMonorepoProject = await isMonorepo(process.cwd());
+      if (isMonorepoProject && shouldUpdateWorkspaces) {
+        relinka(
+          "success",
+          `Updated ${totalUpdated} dependencies across workspace (root + workspaces)`
+        );
+      } else if (isMonorepoProject && !shouldUpdateWorkspaces) {
+        relinka("success", `Updated ${totalUpdated} dependencies in root package.json only`);
+      } else {
+        relinka("success", `Updated ${totalUpdated} dependencies`);
+      }
+      const packageManager = await detectPackageManager(process.cwd());
+      if (!args["with-install"]) {
+        const installCommand = packageManager?.command || "your package manager";
         relinka(
           "info",
-          `Skipped install step. Use --with-install flag to run '${installCommand}' after updating.`
+          `Skipped install step. Use --with-install to run '${installCommand} install'.`
         );
         return;
       }
-      const packageManager = await detectPackageManager(process.cwd());
       if (packageManager) {
         try {
           if (args.filter && args.filter.length > 0) {

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/make.js

@@ -13,13 +13,13 @@ export async function mkdist(options = {}) {
   options.srcDir = resolve(options.rootDir, options.srcDir || "src");
   options.distDir = resolve(options.rootDir, options.distDir || "dist");
   if (options.cleanDist !== false) {
-    relinka("info", "Cleaning distribution directory...");
+    relinka("verbose", "Cleaning distribution directory...");
     await fsp.unlink(options.distDir).catch(() => {
     });
     await fsp.rm(options.distDir, { recursive: true, force: true });
     await fsp.mkdir(options.distDir, { recursive: true });
   }
-  relinka("info", "Scanning input files...");
+  relinka("verbose", "Scanning input files...");
   const filePaths = await glob(options.pattern || "**", {
     absolute: false,
     ignore: ["**/node_modules", "**/coverage", "**/.git"],
@@ -36,10 +36,10 @@ export async function mkdist(options = {}) {
       getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
     };
   });
-  relinka("info", `Found ${files.length} files to process`);
+  relinka("verbose", `Found ${files.length} files to process`);
   options.typescript ||= {};
   if (options.typescript.compilerOptions) {
-    relinka("info", "Normalizing TypeScript compiler options...");
+    relinka("verbose", "Normalizing TypeScript compiler options...");
     options.typescript.compilerOptions = await normalizeCompilerOptions(
       options.typescript.compilerOptions
     );
@@ -57,9 +57,9 @@ export async function mkdist(options = {}) {
       allowNonTsExtensions: true
     }
   );
-  relinka("info", "Creating file loaders...");
+  relinka("verbose", "Creating file loaders...");
   const { loadFile } = createLoader(options);
-  relinka("info", "Processing files with loaders...");
+  relinka("verbose", "Processing files with loaders...");
   const outputs = [];
   let processedCount = 0;
   await Promise.all(
@@ -71,7 +71,7 @@ export async function mkdist(options = {}) {
       processedCount++;
     })
   );
-  relinka("info", "Normalizing output extensions...");
+  relinka("verbose", "Normalizing output extensions...");
   const pathConflicts = [];
   for (const output of outputs.filter((o) => o.extension)) {
     const renamed = basename(output.path, extname(output.path)) + output.extension;
@@ -88,7 +88,7 @@ export async function mkdist(options = {}) {
   }
   const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
   if (dtsOutputs.length > 0) {
-    relinka("info", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
+    relinka("verbose", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
     const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
     const declarations = /* @__PURE__ */ Object.create(null);
     for (const loader of [getVueDeclarations, getDeclarations]) {
@@ -104,7 +104,7 @@ export async function mkdist(options = {}) {
       dtsProcessed++;
     }
   }
-  relinka("info", "Resolving relative imports...");
+  relinka("verbose", "Resolving relative imports...");
   const outPaths = new Set(outputs.map((o) => o.path));
   const resolveId = (from, id = "", resolveExtensions) => {
     if (!id.startsWith(".")) {
@@ -137,7 +137,7 @@ export async function mkdist(options = {}) {
     );
   }
   const outputsToWrite = outputs.filter((o) => !o.skip);
-  relinka("info", `Writing ${outputsToWrite.length} output files...`);
+  relinka("verbose", `Writing ${outputsToWrite.length} output files...`);
   const writtenFiles = [];
   const errors = [];
   let writtenCount = 0;

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.82";
+const version = "1.7.84";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/package.json

@@ -17,7 +17,7 @@
     "bun-plugin-tailwind": "^0.0.15",
     "cssnano": "^7.1.0",
     "defu": "^6.1.4",
-    "esbuild": "^0.25.8",
+    "esbuild": "^0.25.9",
     "execa": "^9.6.0",
     "file-type": "^21.0.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
@@ -33,7 +33,7 @@
     "pkg-types": "^2.2.0",
     "postcss": "^8.5.6",
     "postcss-nested": "^7.0.2",
-    "pretty-bytes": "^7.0.0",
+    "pretty-bytes": "^7.0.1",
     "pretty-ms": "^9.2.0",
     "registry-auth-token": "^5.1.0",
     "registry-url": "^7.2.0",
@@ -52,7 +52,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.82",
+  "version": "1.7.84",
   "keywords": [
     "reliverse",
     "cli",