@reliverse/dler 2.0.9 → 2.0.12

package/README.md

@@ -4,69 +4,75 @@
 
 [Sponsor](https://github.com/sponsors/blefnk) — [Discord](https://discord.gg/Pb8uKbwpsJ) — [GitHub](https://github.com/reliverse/dler) — [NPM](https://npmjs.com/@reliverse/dler) — [Introduction](https://blefnk.reliverse.org/blog/articles/package-managers)
 
-## Installation
+## CLI Installation
 
 ```bash
-bun add @reliverse/dler
+# install as a dev dep:
+bun add -D @reliverse/dler
+# or, install globally:
+bun i -g @reliverse/dler
 ```
 
-## v2 Docs
+## CLI Usage
 
-Docs for v2 will be available soon. For now, you can read the v1 docs, or check alpha docs in [relidocs](./relidocs) directory in the root of the project. For example, you can [learn Dler CLI defaults](./relidocs/DEFAULTS.md) there.
+```bash
+# when installed as a dev dep:
+bun dler [command] [options]
+# when installed globally:
+dler [command] [options]
+```
 
-Note on `bun publish` and `bun tsc`: we don't display npm/tsc raw output, because both are not reliable for concurrent display, so we display them on our own.
+## Framework Installation
 
-## v1 Docs
+Both CLI and framework packages work independently, you're not required to install both.
 
-Visit [docs.reliverse.org/libraries/dler](https://docs.reliverse.org/libraries/dler) to learn how to install and use `@reliverse/dler` library.
+```bash
+bun add @reliverse/dler-logger
+```
 
-## Declaration Generation
+## Framework Usage
 
-Dler uses Rslib's recommended approach for TypeScript declaration generation, supporting both bundled and bundleless declarations.
+```ts
+import { logger } from "@reliverse/dler-logger";
+```
 
-### Optional Dependencies
+## Available Packages
+
+1. `@reliverse/dler-bump`
+2. `@reliverse/dler-build`
+3. `@reliverse/dler-config`
+4. `@reliverse/dler-helpers`
+5. `@reliverse/dler-colors`
+6. `@reliverse/dler-mapper`
+7. `@reliverse/dler-launcher`
+8. `@reliverse/dler-logger`
+9. `@reliverse/dler-matcher`
+10. `@reliverse/dler-pkg-tsc`
+11. `@reliverse/dler-prompt`
+12. `@reliverse/dler-spinner`
+13. `@reliverse/dler-publish`
+
+## Available CLI Commands
+
+All `@reliverse/dler` v2+ commands support both monorepo (recommended) and single-repo (not tested too much yet) contexts.
+
+1. `dler build` can build packages as libraries, frontends (experimental), or standalone apps (experimental; already includes Bun, so the user doesn't even need to install it). Handles not only building, but also package.json modification, and other build-related tasks. Supports dler.ts configuration for per-package settings.
+2. `dler clean` nicely cleans up the codebase, with presets and with support for custom paths.
+3. `dler init` automatically generates a monorepo and the requested packages.
+4. `dler integrate` automatically installs and configures integrations like Next.js, Ultracite/Biome, etc.
+5. `dler perf` runs performance benchmarks for the requested target.
+6. `dler publish` publishes all packages to npm and jsr (soon). Handles version bumping, and different validations. Supports dler.ts configuration for per-package settings.
+7. `dler shell` uses Bun's `$`, making it handy for running cross-platform custom terminal commands.
+8. `dler tsc` finds TypeScript errors across all monorepo packages and shows only real ones (unlike the native `tsc`, which sometimes shows errors of its dependencies). It also has a `--copy-logs` flag that copies errors/warnings straight to your clipboard (with an inserted prompt for fixing them), so you can just hit Ctrl/Cmd+V and send it to AI.
+9. `dler update` updates the dependencies of all packages to the latest version (yes, even across the monorepo).
 
-For advanced declaration generation features, you can install these optional dependencies:
+## v2 Docs
 
-```bash
-# For bundled declarations (single .d.ts file per package)
-bun add -D @microsoft/api-extractor
+Docs for v2 will be available soon. For now, you can read the v1 docs, or check alpha docs in [relidocs](./relidocs) directory in the root of the project. For example, you can [learn Dler CLI defaults](./relidocs/DEFAULTS.md) there.
 
-# For experimental tsgo support (faster generation)
-bun add -D @typescript/native-preview
-```
+## v1 Docs
 
-### Configuration
-
-Configure declaration generation in your `dler.ts`:
-
-```typescript
-export default defineConfig({
-  build: {
-    global: {
-      dts: {
-        enable: true,
-        bundle: false, // Bundleless by default
-        abortOnError: true,
-      },
-    },
-    packages: {
-      "my-library": {
-        dts: {
-          bundle: true, // Bundled declarations
-          distPath: "types",
-        },
-      },
-      "my-other-package": {
-        dts: {
-          tsgo: true, // Use experimental tsgo
-          bundle: false,
-        },
-      },
-    },
-  },
-});
-```
+Visit [docs.reliverse.org/libraries/dler](https://docs.reliverse.org/libraries/dler) to learn how to install and use `@reliverse/dler` library.
 
 ## Contributing
 
@@ -82,6 +88,12 @@ bun install
 
 This monorepo was generated by dler init. It uses bun workspaces to manage multiple packages.
 
+## Locations
+
+- `dler` (v2): `./cli`;
+- `dler-v1`: `./deprecated` (contains both CLI and all-in-one library);
+- packages: `./packages/*`;
+
 ### Scripts
 
 Run scripts across all workspaces:

package/dist/cmds/const.d.ts

@@ -0,0 +1,13 @@
+export type CmdName = "rse" | "build" | "publish" | "deploy" | "native" | "update" | "agg" | "upgrade";
+export declare const msgs: {
+    args: {
+        ci: string;
+        cwd: string;
+        dev: string;
+    };
+    cmds: Record<CmdName, string>;
+    info: {
+        ci: string;
+        dev: string;
+    };
+};

package/dist/cmds/const.js

@@ -0,0 +1,21 @@
+export const msgs = {
+  args: {
+    ci: "Whether to run in CI mode (useful for GitHub Actions and other non-interactive environments)",
+    cwd: "The working directory to run the CLI in",
+    dev: "Whether to run in dev mode (useful only for debugging and Rse CLI contributors)"
+  },
+  cmds: {
+    rse: "Displays an interactive Rse CLI main menu. To see ALL available commands and their flags, run: rse --help",
+    build: "Build the project (without publishing or deploying)",
+    publish: "Build and publish the project to the NPM or JSR registry",
+    deploy: "Deploy the project to GitHub or/and Vercel",
+    native: "Run or install Rse CLI native binaries (kinds: bun, web)",
+    update: "Update all dependencies, even catalog deps, to their latest available versions",
+    agg: "Aggregate your project exports into a single file",
+    upgrade: "Upgrade your dev tools to the latest version (alias for `update --upgrade-tools`)"
+  },
+  info: {
+    ci: "CI mode was activated. Proceeding with: default values -> reliverse.ts overrides -> flags overrides.",
+    dev: "Running the CLI in dev mode."
+  }
+};

package/dist/cmds/publish/cmd.js

@@ -48,8 +48,7 @@ const publishCmd = async (args) => {
       process.exit(1);
     }
     logger.success(
-      `
-\u2705 All packages published successfully! (${results.successCount} packages)`
+      "\nAll packages published successfully!"
     );
     if (args.verbose) {
       for (const result of results.results) {

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/cmds/update/cmd.js

@@ -0,0 +1,165 @@
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import path from "path";
+import {
+  checkPackageUpdatesForFile,
+  handleInstallation,
+  prepareAllUpdateCandidates,
+  updatePackageJsonFileDirectly,
+  validatePackageJson
+} from "./impl.js";
+import {
+  displayStructuredUpdateResults
+} from "./utils.js";
+import { msgs } from "../const.js";
+import { getCurrentWorkingDirectory } from "@reliverse/dler-helpers";
+const updateCmd = async (args) => {
+  try {
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+    const { dryRun, install, details, ignoreFields } = args;
+    const isDryRun = Boolean(dryRun);
+    const showDetails = Boolean(details);
+    const fieldsToIgnore = Array.isArray(ignoreFields) ? ignoreFields : [];
+    await validatePackageJson();
+    const { packageJsonFiles, fileDepsMap } = await prepareAllUpdateCandidates();
+    if (packageJsonFiles.length === 0) {
+      logger.log("No package.json files found");
+      return;
+    }
+    let totalUpdated = 0;
+    const allResults = [];
+    for (const packageJsonPath of packageJsonFiles) {
+      const fileDeps = fileDepsMap.get(packageJsonPath);
+      if (!fileDeps) continue;
+      const results = await checkPackageUpdatesForFile(fileDeps, args);
+      allResults.push(...results);
+      const toUpdate = results.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 updated = await updatePackageJsonFileDirectly(
+          packageJsonPath,
+          fileDeps,
+          toUpdate,
+          "^",
+          fieldsToIgnore
+        );
+        totalUpdated += updated;
+        if (updated > 0) {
+          const relativePath = path.relative(process.cwd(), packageJsonPath);
+          logger.debug(
+            `Updated ${updated} dependencies in ${relativePath}`
+          );
+        }
+      }
+    }
+    displayStructuredUpdateResults(
+      allResults,
+      packageJsonFiles,
+      fileDepsMap,
+      showDetails
+    );
+    if (totalUpdated === 0) {
+      if (isDryRun) {
+        logger.log("Dry run mode - no changes would be made");
+      } else {
+        logger.log("No dependencies to update");
+      }
+      return;
+    }
+    if (packageJsonFiles.length > 1) {
+      logger.log(
+        `Updated ${totalUpdated} dependencies across ${packageJsonFiles.length} package.json files`
+      );
+    } else {
+      logger.log(`Updated ${totalUpdated} dependencies`);
+    }
+    if (install) {
+      await handleInstallation();
+    } else {
+      logger.log(
+        "Run 'bun install' to apply the changes (use --install to do this automatically)"
+      );
+    }
+  } catch (error) {
+    logger.error(
+      `Failed to update dependencies: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+};
+const updateCmdArgs = defineCmdArgs({
+  ci: {
+    type: "boolean",
+    description: msgs.args.ci,
+    default: !process.stdout.isTTY || !!process.env["CI"]
+  },
+  cwd: {
+    type: "string",
+    description: msgs.args.cwd,
+    default: getCurrentWorkingDirectory()
+  },
+  name: {
+    type: "string",
+    description: "Specific dependencies to update, supports glob patterns (e.g. '@types/*', 'react*')"
+  },
+  ignore: {
+    type: "string",
+    description: "Dependencies to exclude from updates, supports glob patterns (e.g. 'eslint-*', '@types/*')"
+  },
+  dryRun: {
+    type: "boolean",
+    description: "Preview updates without making changes"
+  },
+  install: {
+    type: "boolean",
+    description: "Run install after updating",
+    aliases: ["i"]
+  },
+  allowMajor: {
+    type: "boolean",
+    description: "Allow major version updates (default: true)",
+    default: true
+  },
+  details: {
+    type: "boolean",
+    description: "Show detailed dependency information (default: false)",
+    aliases: ["d"]
+  },
+  ignoreFields: {
+    type: "string",
+    description: "Dependency fields to ignore (e.g., 'peerDependencies,catalog')"
+  }
+});
+const updateCmdCfg = defineCmdCfg({
+  name: "update",
+  description: "Update all dependencies to their latest versions across all package.json files. Supports selective updates with glob patterns and comprehensive filtering options.",
+  examples: [
+    "dler update",
+    "dler update --install",
+    "dler update --dryRun",
+    "dler update --name @types/* --name react*",
+    'dler update --ignore "eslint-*" --ignore "@babel/*"',
+    "dler update --no-allowMajor",
+    "dler update --details",
+    "dler update --ignoreFields peerDependencies",
+    "dler update --dryRun --install",
+    "dler update --name react --name react-dom --install",
+    "dler update --ignore @types/* --allowMajor"
+  ]
+});
+export default defineCmd(updateCmd, updateCmdArgs, updateCmdCfg);

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

@@ -0,0 +1,21 @@
+import { type UpdateResult } from "./utils.js";
+interface UpdateArgs {
+    ci?: boolean;
+    cwd?: string;
+    name?: string[];
+    ignore?: string[];
+    dryRun?: boolean;
+    install?: boolean;
+    allowMajor?: boolean;
+    concurrency?: number;
+    ignoreFields?: string[];
+}
+export declare function validatePackageJson(): Promise<string>;
+export declare function prepareAllUpdateCandidates(): Promise<{
+    packageJsonFiles: string[];
+    fileDepsMap: Map<string, Record<string, any>>;
+}>;
+export declare function checkPackageUpdatesForFile(fileDepsMap: Record<string, any>, args: UpdateArgs): Promise<UpdateResult[]>;
+export declare function updatePackageJsonFileDirectly(packageJsonPath: string, fileDepsMap: Record<string, any>, updatesToApply: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
+export declare function handleInstallation(): Promise<void>;
+export {};

package/dist/cmds/update/impl.js

@@ -0,0 +1,157 @@
+import path from "path";
+import fs from "fs/promises";
+import { logger } from "@reliverse/dler-logger";
+import pMap from "@reliverse/dler-mapper";
+import { Glob } from "bun";
+import {
+  applyVersionUpdate,
+  checkPackageUpdate,
+  collectTargetDependencies,
+  prepareDependenciesForUpdate,
+  runInstallCommand
+} from "./utils.js";
+export async function validatePackageJson() {
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  try {
+    await fs.access(packageJsonPath);
+  } catch {
+    logger.error("No package.json found in current directory");
+    process.exit(1);
+  }
+  return packageJsonPath;
+}
+export async function prepareAllUpdateCandidates() {
+  const glob = new Glob("**/package.json");
+  const packageJsonFiles = [];
+  for await (const file of glob.scan({
+    cwd: process.cwd(),
+    onlyFiles: true
+  })) {
+    const fullPath = path.resolve(process.cwd(), file);
+    if (!file.includes("node_modules") && !file.includes("dist") && !file.includes("build") && !file.includes(".git") && !file.includes("coverage") && !file.includes(".next") && !file.includes(".nuxt") && !file.includes("out") && !file.includes("target") && !file.includes(".turbo")) {
+      packageJsonFiles.push(fullPath);
+    }
+  }
+  if (packageJsonFiles.length === 0) {
+    logger.warn("No package.json files found");
+    return { packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
+  }
+  logger.debug(`Found ${packageJsonFiles.length} package.json files`);
+  const fileDepsMap = /* @__PURE__ */ new Map();
+  for (const packageJsonPath of packageJsonFiles) {
+    try {
+      const packageJson = JSON.parse(
+        await fs.readFile(packageJsonPath, "utf8")
+      );
+      const { map } = collectTargetDependencies(packageJson);
+      fileDepsMap.set(packageJsonPath, map);
+    } catch (error) {
+      logger.warn(
+        `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  logger.debug(
+    `Processing ${packageJsonFiles.length} package.json files`
+  );
+  return { packageJsonFiles, fileDepsMap };
+}
+export async function checkPackageUpdatesForFile(fileDepsMap, args) {
+  const options = {
+    allowMajor: !!args.allowMajor,
+    savePrefix: "^",
+    // Use default prefix
+    concurrency: args.concurrency || 5
+  };
+  const candidates = prepareDependenciesForUpdate(fileDepsMap, args);
+  if (candidates.length === 0) {
+    return [];
+  }
+  return await pMap(
+    candidates,
+    async (dep) => {
+      const depInfo = fileDepsMap[dep];
+      if (!depInfo?.versionSpec) {
+        return {
+          package: dep,
+          currentVersion: "unknown",
+          latestVersion: "unknown",
+          updated: false,
+          error: "Current version not found",
+          semverCompatible: false,
+          location: "unknown"
+        };
+      }
+      return checkPackageUpdate(
+        dep,
+        depInfo.versionSpec,
+        depInfo.locations,
+        options
+      );
+    },
+    { concurrency: args.concurrency || 5 }
+  );
+}
+export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap, updatesToApply, savePrefix, fieldsToIgnore = []) {
+  if (updatesToApply.length === 0) return 0;
+  try {
+    const packageJson = JSON.parse(
+      await fs.readFile(packageJsonPath, "utf8")
+    );
+    const updatedPackageJson = { ...packageJson };
+    for (const update of updatesToApply) {
+      const depInfo = fileDepsMap[update.package];
+      if (!depInfo) continue;
+      const locations = depInfo.locations || /* @__PURE__ */ new Set();
+      const shouldIgnore = Array.from(locations).some(
+        (location) => fieldsToIgnore.includes(String(location))
+      );
+      if (shouldIgnore) {
+        continue;
+      }
+      let newVersion;
+      if (locations.has("peerDependencies")) {
+        const currentVersion = String(
+          fileDepsMap[update.package]?.versionSpec || ""
+        );
+        if (currentVersion.startsWith(">=")) {
+          newVersion = `>=${update.latestVersion}`;
+        } else {
+          newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
+        }
+      } else {
+        newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
+      }
+      applyVersionUpdate(
+        updatedPackageJson,
+        update.package,
+        newVersion,
+        locations
+      );
+    }
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(updatedPackageJson, null, 2) + "\n",
+      "utf8"
+    );
+    return updatesToApply.length;
+  } catch (error) {
+    logger.warn(
+      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+export async function handleInstallation() {
+  try {
+    await runInstallCommand();
+    logger.log("Installation completed successfully");
+  } catch (error) {
+    logger.warn(
+      `Install failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    logger.log(
+      "Run 'bun install' manually to apply the changes"
+    );
+  }
+}

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

@@ -0,0 +1,78 @@
+export interface UpdateResult {
+    package: string;
+    currentVersion: string;
+    latestVersion: string;
+    updated: boolean;
+    error?: string;
+    semverCompatible?: boolean;
+    location?: string;
+}
+export interface DependencyInfo {
+    versionSpec: string;
+    locations: Set<string>;
+}
+export interface PackageCheckOptions {
+    allowMajor: boolean;
+    savePrefix: string;
+    concurrency: number;
+}
+/**
+ * Check if a dependency is an npm alias (e.g., "npm:package-name@version")
+ */
+export declare function isNpmAlias(versionSpec: string): boolean;
+/**
+ * Check if a dependency is a workspace dependency (e.g., "workspace:*")
+ */
+export declare function isWorkspaceDependency(versionSpec: string): boolean;
+export declare function isCatalogReference(versionSpec: string): boolean;
+export declare function isNonSemverSpecifier(versionSpec: string): boolean;
+/**
+ * Check if a version update is semver-compatible with the current version range
+ * Note: Returns false for exact versions (handled separately in checkPackageUpdate)
+ */
+export declare function isSemverCompatible(currentVersionRange: string, latestVersion: string): boolean;
+/**
+ * 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): {
+    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;
+/**
+ * Fallback function to fetch package version directly from npm registry
+ */
+export declare function fetchVersionFromRegistry(packageName: string): Promise<string>;
+/**
+ * Get latest version of a package
+ */
+export declare function getLatestVersion(packageName: string): Promise<string>;
+/**
+ * Check if a package needs updating and get update information
+ *
+ * Update behavior:
+ * - Gets latest version from registry (not just semver-compatible)
+ * - Exact versions (1.0.0): Always allow updates to latest
+ * - Prefixed versions (^1.0.0, ~1.0.0): Updates to latest if allowMajor=true (default)
+ * - When allowMajor=false: Only allows updates within semver range
+ */
+export declare function checkPackageUpdate(packageName: string, versionSpec: string, locations: Set<string>, options: PackageCheckOptions): Promise<UpdateResult>;
+/**
+ * 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, fieldsToIgnore?: string[]): Promise<number>;
+/**
+ * Display update results in a structured, file-by-file format
+ */
+export declare function displayStructuredUpdateResults(results: UpdateResult[], packageJsonFiles: string[], fileDepsMap: Map<string, Record<string, any>>, showDetails?: boolean): void;
+/**
+ * Run Bun install command
+ */
+export declare function runInstallCommand(): Promise<void>;

package/dist/cmds/update/utils.js

@@ -0,0 +1,438 @@
+import fs from "fs/promises";
+import { logger } from "@reliverse/dler-logger";
+import { $ } from "bun";
+import path from "path";
+import semver from "semver";
+import zeptomatch from "@reliverse/dler-matcher";
+export function isNpmAlias(versionSpec) {
+  return versionSpec.startsWith("npm:");
+}
+export function isWorkspaceDependency(versionSpec) {
+  return versionSpec.startsWith("workspace:");
+}
+export function isCatalogReference(versionSpec) {
+  return versionSpec.startsWith("catalog:");
+}
+export function isNonSemverSpecifier(versionSpec) {
+  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
+}
+export function isSemverCompatible(currentVersionRange, latestVersion) {
+  try {
+    if (isNpmAlias(currentVersionRange)) {
+      return false;
+    }
+    if (isWorkspaceDependency(currentVersionRange)) {
+      return false;
+    }
+    if (!currentVersionRange.startsWith("^") && !currentVersionRange.startsWith("~")) {
+      return false;
+    }
+    return semver.satisfies(latestVersion, currentVersionRange);
+  } catch {
+    return false;
+  }
+}
+export function collectTargetDependencies(pkg) {
+  const map = {};
+  const dependencies = pkg.dependencies || {};
+  const devDependencies = pkg.devDependencies || {};
+  const peerDependencies = pkg.peerDependencies || {};
+  const optionalDependencies = pkg.optionalDependencies || {};
+  for (const dep of Object.keys(dependencies)) {
+    const version = dependencies[dep];
+    if (!version) continue;
+    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    map[dep].versionSpec = version;
+    map[dep].locations.add("dependencies");
+  }
+  for (const dep of Object.keys(devDependencies)) {
+    const version = devDependencies[dep];
+    if (!version) continue;
+    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    map[dep].versionSpec = version;
+    map[dep].locations.add("devDependencies");
+  }
+  for (const dep of Object.keys(peerDependencies)) {
+    const version = peerDependencies[dep];
+    if (!version) continue;
+    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    map[dep].versionSpec = version;
+    map[dep].locations.add("peerDependencies");
+  }
+  for (const dep of Object.keys(optionalDependencies)) {
+    const version = optionalDependencies[dep];
+    if (!version) continue;
+    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    map[dep].versionSpec = version;
+    map[dep].locations.add("optionalDependencies");
+  }
+  const workspacesCatalog = pkg.workspaces?.catalog || {};
+  for (const dep of Object.keys(workspacesCatalog)) {
+    const version = workspacesCatalog[dep];
+    if (!version) continue;
+    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    map[dep].versionSpec = version;
+    map[dep].locations.add("catalog");
+  }
+  const workspacesCatalogs = pkg.workspaces?.catalogs || {};
+  for (const catalogName of Object.keys(workspacesCatalogs)) {
+    const catalog = workspacesCatalogs[catalogName] || {};
+    for (const dep of Object.keys(catalog)) {
+      const version = catalog[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add(`catalogs.${catalogName}`);
+    }
+  }
+  const topLevelCatalog = pkg.catalog || {};
+  for (const dep of Object.keys(topLevelCatalog)) {
+    const version = topLevelCatalog[dep];
+    if (!version) continue;
+    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    map[dep].versionSpec = version;
+    map[dep].locations.add("catalog");
+  }
+  const topLevelCatalogs = pkg.catalogs || {};
+  for (const catalogName of Object.keys(topLevelCatalogs)) {
+    const catalog = topLevelCatalogs[catalogName] || {};
+    for (const dep of Object.keys(catalog)) {
+      const version = catalog[dep];
+      if (!version) continue;
+      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      map[dep].versionSpec = version;
+      map[dep].locations.add(`catalogs.${catalogName}`);
+    }
+  }
+  return { map };
+}
+export function applyVersionUpdate(pkg, depName, newVersion, locations) {
+  if (locations.has("dependencies")) {
+    if (!pkg.dependencies) pkg.dependencies = {};
+    pkg.dependencies[depName] = newVersion;
+  }
+  if (locations.has("devDependencies")) {
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    pkg.devDependencies[depName] = newVersion;
+  }
+  if (locations.has("peerDependencies")) {
+    if (!pkg.peerDependencies) pkg.peerDependencies = {};
+    pkg.peerDependencies[depName] = newVersion;
+  }
+  if (locations.has("optionalDependencies")) {
+    if (!pkg.optionalDependencies) pkg.optionalDependencies = {};
+    pkg.optionalDependencies[depName] = newVersion;
+  }
+  const ensureWorkspaces = () => {
+    if (!pkg.workspaces) pkg.workspaces = {};
+  };
+  if (locations.has("catalog")) {
+    ensureWorkspaces();
+    if (!pkg.workspaces.catalog) pkg.workspaces.catalog = {};
+    pkg.workspaces.catalog[depName] = newVersion;
+    if (pkg.catalog) pkg.catalog[depName] = newVersion;
+  }
+  for (const loc of locations) {
+    const match = /^catalogs\.(.+)$/.exec(loc);
+    if (match) {
+      const catalogName = match[1] ?? "";
+      if (!catalogName) continue;
+      ensureWorkspaces();
+      if (!pkg.workspaces.catalogs)
+        pkg.workspaces.catalogs = {};
+      if (!pkg.workspaces.catalogs[catalogName])
+        pkg.workspaces.catalogs[catalogName] = {};
+      pkg.workspaces.catalogs[catalogName][depName] = newVersion;
+      if (pkg.catalogs && pkg.catalogs[catalogName]) {
+        pkg.catalogs[catalogName][depName] = newVersion;
+      }
+    }
+  }
+}
+export async function fetchVersionFromRegistry(packageName) {
+  const response = await fetch(
+    `https://registry.npmjs.org/${packageName}/latest`
+  );
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.version;
+}
+export async function getLatestVersion(packageName) {
+  try {
+    return await fetchVersionFromRegistry(packageName);
+  } catch (error) {
+    throw new Error(
+      `Failed to get latest version for ${packageName}: ${error}`
+    );
+  }
+}
+export async function checkPackageUpdate(packageName, versionSpec, locations, options) {
+  try {
+    const latest = await getLatestVersion(packageName);
+    const cleanCurrent = versionSpec.replace(/^[\^~]/, "");
+    let isCompatible = isSemverCompatible(versionSpec, latest);
+    const isExact = !versionSpec.startsWith("^") && !versionSpec.startsWith("~");
+    if (isExact || !isCompatible && options.allowMajor) {
+      isCompatible = true;
+    }
+    return {
+      package: packageName,
+      currentVersion: cleanCurrent,
+      latestVersion: latest,
+      updated: latest !== cleanCurrent && isCompatible,
+      semverCompatible: isCompatible,
+      location: Array.from(locations).join(", ")
+    };
+  } catch (error) {
+    return {
+      package: packageName,
+      currentVersion: versionSpec,
+      latestVersion: versionSpec,
+      updated: false,
+      error: error instanceof Error ? error.message : String(error),
+      semverCompatible: false,
+      location: Array.from(locations).join(", ")
+    };
+  }
+}
+export function prepareDependenciesForUpdate(allDepsMap, args) {
+  const depsToUpdate = Object.keys(allDepsMap);
+  let filteredDeps = [];
+  if (args.name && args.name.length > 0) {
+    const namePatterns = args.name;
+    filteredDeps = depsToUpdate.filter((dep) => {
+      return namePatterns.some((pattern) => {
+        if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[") || pattern.includes("{")) {
+          return zeptomatch.isMatch(pattern, dep);
+        }
+        return dep === pattern;
+      });
+    });
+    const exactMatches = filteredDeps.filter(
+      (dep) => namePatterns.includes(dep)
+    );
+    const patternMatches = filteredDeps.length - exactMatches.length;
+    if (patternMatches > 0) {
+      logger.debug(
+        `Found ${exactMatches.length} exact matches and ${patternMatches} pattern matches`
+      );
+    }
+    if (filteredDeps.length === 0) {
+      logger.warn(
+        `No dependencies found matching patterns: ${namePatterns.join(", ")}`
+      );
+    }
+  } else {
+    const ignoreList = args.ignore || [];
+    filteredDeps = depsToUpdate.filter((dep) => {
+      return !ignoreList.some((ignorePattern) => {
+        if (ignorePattern.includes("*") || ignorePattern.includes("?") || ignorePattern.includes("[") || ignorePattern.includes("{")) {
+          return zeptomatch.isMatch(ignorePattern, dep);
+        }
+        return dep === ignorePattern;
+      });
+    });
+    const ignoredCount = depsToUpdate.length - filteredDeps.length;
+    if (ignoredCount > 0 && ignoreList.length > 0) {
+      logger.debug(
+        `Ignored ${ignoredCount} dependencies matching ignore patterns`
+      );
+    }
+  }
+  const ignoreFields = args.ignoreFields || [];
+  if (ignoreFields.length > 0) {
+    filteredDeps = filteredDeps.filter((dep) => {
+      const locations = allDepsMap[dep]?.locations || /* @__PURE__ */ new Set();
+      return !Array.from(locations).some(
+        (location) => ignoreFields.includes(location)
+      );
+    });
+    const ignoredFieldsCount = depsToUpdate.length - filteredDeps.length;
+    if (ignoredFieldsCount > 0) {
+      logger.debug(
+        `Ignored ${ignoredFieldsCount} dependencies in ignored fields: ${ignoreFields.join(", ")}`
+      );
+    }
+  }
+  return filteredDeps.filter((dep) => {
+    const versionSpec = allDepsMap[dep]?.versionSpec ?? "";
+    if (!versionSpec) return false;
+    if (isNonSemverSpecifier(versionSpec)) return false;
+    return true;
+  });
+}
+export async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix, fieldsToIgnore = []) {
+  if (updatesToApply.length === 0) return 0;
+  try {
+    const packageJson = JSON.parse(
+      await fs.readFile(packageJsonPath, "utf8")
+    );
+    const updatedPackageJson = { ...packageJson };
+    for (const update of updatesToApply) {
+      const depInfo = dependencies[update.package];
+      if (!depInfo) continue;
+      const locations = depInfo.locations || /* @__PURE__ */ new Set();
+      const shouldIgnore = Array.from(locations).some(
+        (location) => fieldsToIgnore.includes(location)
+      );
+      if (shouldIgnore) {
+        continue;
+      }
+      let newVersion;
+      if (locations.has("peerDependencies")) {
+        const currentVersion = dependencies[update.package]?.versionSpec || "";
+        if (currentVersion.startsWith(">=")) {
+          newVersion = `>=${update.latestVersion}`;
+        } else {
+          newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
+        }
+      } else {
+        newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
+      }
+      applyVersionUpdate(
+        updatedPackageJson,
+        update.package,
+        newVersion,
+        locations
+      );
+    }
+    await fs.writeFile(
+      packageJsonPath,
+      JSON.stringify(updatedPackageJson, null, 2) + "\n",
+      "utf8"
+    );
+    return updatesToApply.length;
+  } catch (error) {
+    logger.warn(
+      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+export function displayStructuredUpdateResults(results, packageJsonFiles, fileDepsMap, showDetails = false) {
+  const toUpdate = results.filter((r) => r.updated && !r.error);
+  const errors = results.filter((r) => r.error);
+  const upToDate = results.filter(
+    (r) => !r.updated && !r.error && r.semverCompatible
+  );
+  if (errors.length > 0) {
+    logger.warn(`Failed to check ${errors.length} dependencies:`);
+    for (const error of errors) {
+      logger.warn(`  ${error.package} (${error.location}): ${error.error}`);
+    }
+    logger.log("");
+  }
+  if (!showDetails) {
+    if (toUpdate.length === 0) {
+      logger.log(
+        `All ${upToDate.length} dependencies are already up to date`
+      );
+    } else {
+      logger.log(
+        `${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
+      );
+    }
+    return;
+  }
+  const resultsByFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    let filePath = "unknown";
+    for (const [pkgPath, deps] of fileDepsMap.entries()) {
+      if (deps[result.package]) {
+        filePath = pkgPath;
+        break;
+      }
+    }
+    if (!resultsByFile.has(filePath)) {
+      resultsByFile.set(filePath, []);
+    }
+    const fileResults = resultsByFile.get(filePath);
+    if (fileResults) {
+      fileResults.push(result);
+    }
+  }
+  for (const [filePath, fileResults] of resultsByFile.entries()) {
+    const relativePath = filePath !== "unknown" ? path.relative(process.cwd(), filePath) : "unknown";
+    logger.info(`${relativePath}`);
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const result of fileResults) {
+      const category = result.location || "unknown";
+      if (!byCategory.has(category)) {
+        byCategory.set(category, []);
+      }
+      byCategory.get(category).push(result);
+    }
+    const upToDateInFile = fileResults.filter(
+      (r) => !r.updated && !r.error && r.semverCompatible
+    );
+    if (upToDateInFile.length > 0) {
+      logger.log(
+        `  * ${upToDateInFile.length} deps are already up to date`
+      );
+    }
+    const toUpdateInFile = fileResults.filter((r) => r.updated && !r.error);
+    if (toUpdateInFile.length > 0) {
+      logger.log(`  * ${toUpdateInFile.length} deps can be updated:`);
+      const sortedCategories = Array.from(byCategory.entries()).sort(
+        ([a], [b]) => {
+          const order = {
+            catalog: 0,
+            dependencies: 1,
+            devDependencies: 2,
+            peerDependencies: 3,
+            optionalDependencies: 4
+          };
+          const aOrder = order[a] ?? 999;
+          const bOrder = order[b] ?? 999;
+          return aOrder - bOrder;
+        }
+      );
+      for (const [category, updates] of sortedCategories) {
+        const categoryUpdates = updates.filter((r) => r.updated && !r.error);
+        if (categoryUpdates.length > 0) {
+          let displayCategory = category;
+          if (category.startsWith("catalogs.")) {
+            displayCategory = `workspaces.${category}`;
+          } else if (category === "catalog") {
+            displayCategory = "workspaces.catalog";
+          }
+          logger.log(`    - ${displayCategory}:`);
+          for (const update of categoryUpdates) {
+            logger.log(
+              `      ${update.package}: ${update.currentVersion} \u2192 ${update.latestVersion}`
+            );
+          }
+        }
+      }
+    }
+    const errorsInFile = fileResults.filter((r) => r.error);
+    if (errorsInFile.length > 0) {
+      logger.warn(`  * ${errorsInFile.length} deps failed to check:`);
+      for (const error of errorsInFile) {
+        logger.warn(`    ${error.package}: ${error.error}`);
+      }
+    }
+    logger.log("");
+  }
+  if (toUpdate.length === 0) {
+    logger.log(
+      `All ${upToDate.length} dependencies are already up to date`
+    );
+  } else {
+    logger.success(
+      `Summary: ${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
+    );
+  }
+}
+export async function runInstallCommand() {
+  try {
+    await $`bun install`.quiet();
+  } catch (error) {
+    logger.warn(
+      `Failed to run install command: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw error;
+  }
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@reliverse/dler",
   "description": "@reliverse/dler is a framework which helps TypeScript and JavaScript developers create their libraries and CLI tools. It provides ready-to-use primitives, so you don't have to write them from scratch.",
   "author": "reliverse",
-  "version": "2.0.9",
+  "version": "2.0.12",
   "private": false,
   "type": "module",
   "bin": {
@@ -10,17 +10,18 @@
   },
   "dependencies": {
     "c12": "^3.3.0",
+    "semver": "^7.7.3",
     "clipboardy": "^5.0.0",
-    "@reliverse/dler-publish": "2.0.10",
-    "@reliverse/dler-bump": "2.0.10",
-    "@reliverse/dler-build": "2.0.10",
-    "@reliverse/dler-logger": "2.0.10",
-    "@reliverse/dler-matcher": "2.0.10",
-    "@reliverse/dler-launcher": "2.0.10",
-    "@reliverse/dler-prompt": "2.0.10",
-    "@reliverse/dler-helpers": "2.0.10",
-    "@reliverse/dler-pkg-tsc": "2.0.10",
-    "@reliverse/dler-mapper": "2.0.10"
+    "@reliverse/dler-publish": "2.0.12",
+    "@reliverse/dler-bump": "2.0.12",
+    "@reliverse/dler-build": "2.0.12",
+    "@reliverse/dler-logger": "2.0.12",
+    "@reliverse/dler-matcher": "2.0.12",
+    "@reliverse/dler-launcher": "2.0.12",
+    "@reliverse/dler-prompt": "2.0.12",
+    "@reliverse/dler-helpers": "2.0.12",
+    "@reliverse/dler-pkg-tsc": "2.0.12",
+    "@reliverse/dler-mapper": "2.0.12"
   },
   "keywords": [
     "dler",