@reliverse/dler 1.7.151 → 1.7.153

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

@@ -11,13 +11,11 @@ interface UpdateArgs {
     ignoreFields?: string[];
 }
 export declare function validatePackageJson(): Promise<string>;
-export declare function prepareAllUpdateCandidates(args: UpdateArgs): Promise<{
-    candidates: string[];
-    allDepsMap: Record<string, any>;
+export declare function prepareAllUpdateCandidates(): Promise<{
     packageJsonFiles: string[];
     fileDepsMap: Map<string, Record<string, any>>;
 }>;
-export declare function checkPackageUpdates(candidates: string[], allDepsMap: Record<string, any>, args: UpdateArgs): Promise<UpdateResult[]>;
-export declare function updateAllPackageJsonFiles(packageJsonFiles: string[], toUpdate: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
+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/bin/impl/update/impl.js

@@ -5,12 +5,11 @@ import pMap from "p-map";
 import { glob } from "tinyglobby";
 import { detectPackageManager } from "../utils/pm/pm-detect.js";
 import {
+  applyVersionUpdate,
   checkPackageUpdate,
   collectTargetDependencies,
-  isNonSemverSpecifier,
   prepareDependenciesForUpdate,
-  runInstallCommand,
-  updatePackageJsonFile
+  runInstallCommand
 } from "./utils.js";
 export async function validatePackageJson() {
   const packageJsonPath = path.resolve(process.cwd(), "package.json");
@@ -20,7 +19,7 @@ export async function validatePackageJson() {
   }
   return packageJsonPath;
 }
-export async function prepareAllUpdateCandidates(args) {
+export async function prepareAllUpdateCandidates() {
   const packageJsonFiles = await glob("**/package.json", {
     cwd: process.cwd(),
     absolute: true,
@@ -39,31 +38,15 @@ export async function prepareAllUpdateCandidates(args) {
   });
   if (packageJsonFiles.length === 0) {
     relinka("warn", "No package.json files found");
-    return { candidates: [], allDepsMap: {}, packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
+    return { packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
   }
   relinka("verbose", `Found ${packageJsonFiles.length} package.json files`);
-  const allDepsMap = {};
-  const allCandidates = /* @__PURE__ */ new Set();
   const fileDepsMap = /* @__PURE__ */ new Map();
   for (const packageJsonPath of packageJsonFiles) {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
       const { map } = collectTargetDependencies(packageJson);
-      const candidates2 = prepareDependenciesForUpdate(map, args);
       fileDepsMap.set(packageJsonPath, map);
-      for (const [dep, info] of Object.entries(map)) {
-        if (!allDepsMap[dep]) {
-          allDepsMap[dep] = { ...info, locations: new Set(info.locations) };
-        } else {
-          for (const location of info.locations) {
-            allDepsMap[dep].locations.add(location);
-          }
-          allDepsMap[dep].versionSpec = info.versionSpec;
-        }
-      }
-      for (const candidate of candidates2) {
-        allCandidates.add(candidate);
-      }
     } catch (error) {
       relinka(
         "warn",
@@ -71,25 +54,24 @@ export async function prepareAllUpdateCandidates(args) {
       );
     }
   }
-  const candidates = Array.from(allCandidates);
-  if (candidates.length === 0) {
-    relinka("warn", "No dependencies to update");
-    return { candidates: [], allDepsMap: {}, packageJsonFiles, fileDepsMap };
-  }
   relinka("verbose", `Processing ${packageJsonFiles.length} package.json files`);
-  return { candidates, allDepsMap, packageJsonFiles, fileDepsMap };
+  return { packageJsonFiles, fileDepsMap };
 }
-export async function checkPackageUpdates(candidates, allDepsMap, args) {
+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 = allDepsMap[dep];
+      const depInfo = fileDepsMap[dep];
       if (!depInfo?.versionSpec) {
         return {
           package: dep,
@@ -106,45 +88,43 @@ export async function checkPackageUpdates(candidates, allDepsMap, args) {
     { concurrency: args.concurrency || 5 }
   );
 }
-export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, savePrefix, fieldsToIgnore = []) {
-  if (packageJsonFiles.length === 0 || toUpdate.length === 0) {
-    return 0;
-  }
-  let totalUpdated = 0;
-  for (const packageJsonPath of packageJsonFiles) {
-    try {
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-      const { map: fileDepsMap } = collectTargetDependencies(packageJson);
-      const fileSpecificUpdates = toUpdate.filter((update) => {
-        const depInfo = fileDepsMap[update.package];
-        if (!depInfo) return false;
-        if (isNonSemverSpecifier(depInfo.versionSpec)) {
-          return false;
-        }
-        return true;
-      });
-      if (fileSpecificUpdates.length > 0) {
-        const updated = await updatePackageJsonFile(
-          packageJsonPath,
-          fileDepsMap,
-          fileSpecificUpdates,
-          savePrefix,
-          fieldsToIgnore
-        );
-        totalUpdated += updated;
-        if (updated > 0) {
-          const relativePath = path.relative(process.cwd(), packageJsonPath);
-          relinka("verbose", `Updated ${updated} dependencies in ${relativePath}`);
+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}`;
       }
-    } catch (error) {
-      relinka(
-        "warn",
-        `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
+      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;
   }
-  return totalUpdated;
 }
 export async function handleInstallation() {
   const packageManager = await detectPackageManager(process.cwd());

package/bin/impl/utils/workspace-prompt.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspacePackage } from "./workspace-utils";
+/**
+ * Prompts user to select workspace packages for build or publish operations
+ */
+export declare function promptWorkspacePackages(packages: WorkspacePackage[], command: "build" | "publish", skipPrompt?: boolean): Promise<WorkspacePackage[]>;
+/**
+ * Shows a summary of selected packages and their dependency order
+ */
+export declare function showPackageSummary(packages: WorkspacePackage[], command: "build" | "publish"): void;

package/bin/impl/utils/workspace-prompt.js

@@ -0,0 +1,46 @@
+import { re } from "@reliverse/relico";
+import { cancel, isCancel, multiselectPrompt } from "@reliverse/rempts";
+export async function promptWorkspacePackages(packages, command, skipPrompt = false) {
+  if (packages.length === 0) {
+    return [];
+  }
+  const sortedPackages = packages.sort((a, b) => {
+    if (a.workspaceDependencies.includes(b.name)) return 1;
+    if (b.workspaceDependencies.includes(a.name)) return -1;
+    return a.name.localeCompare(b.name);
+  });
+  if (skipPrompt) {
+    return sortedPackages;
+  }
+  const options = sortedPackages.map((pkg) => ({
+    label: `${pkg.name} ${re.dim(`(${pkg.version})`)}`,
+    value: pkg.name,
+    hint: pkg.workspaceDependencies.length > 0 ? `Depends on: ${pkg.workspaceDependencies.join(", ")}` : "No workspace dependencies"
+  }));
+  const title = command === "build" ? "Select packages to build" : "Select packages to publish";
+  const content = command === "build" ? "Choose which workspace packages to build. Packages will be built in dependency order." : "Choose which workspace packages to publish. Packages will be built and published in dependency order.";
+  const selectedPackageNames = await multiselectPrompt({
+    title,
+    content,
+    options,
+    defaultValue: packages.map((pkg) => pkg.name),
+    // Select all by default
+    displayInstructions: true
+  });
+  if (isCancel(selectedPackageNames)) {
+    cancel(re.red("Operation cancelled"));
+    process.exit(0);
+  }
+  const selectedPackages = selectedPackageNames.map((name) => packages.find((pkg) => pkg.name === name)).filter((pkg) => pkg !== void 0);
+  return selectedPackages;
+}
+export function showPackageSummary(packages, command) {
+  const action = command === "build" ? "Building" : "Publishing";
+  console.log(`
+${re.cyan(`${action} ${packages.length} package(s) in dependency order:`)}`);
+  packages.forEach((pkg, index) => {
+    const deps = pkg.workspaceDependencies.length > 0 ? ` ${re.dim(`(depends on: ${pkg.workspaceDependencies.join(", ")})`)}` : "";
+    console.log(`  ${index + 1}. ${re.green(pkg.name)} ${re.dim(`v${pkg.version}`)}${deps}`);
+  });
+  console.log();
+}

package/bin/impl/utils/workspace-utils.d.ts

@@ -0,0 +1,28 @@
+export interface WorkspacePackage {
+    name: string;
+    path: string;
+    packageJsonPath: string;
+    version: string;
+    private: boolean;
+    dependencies: string[];
+    workspaceDependencies: string[];
+}
+export interface WorkspaceConfig {
+    enabled: boolean;
+    autoDiscoverPackages: boolean;
+    buildOrder: "dependency" | "parallel";
+    includePatterns: string[];
+    excludePatterns: string[];
+}
+/**
+ * Detects if the current directory has workspace configuration and returns publishable packages
+ */
+export declare function detectWorkspaces(cwd: string): Promise<WorkspacePackage[] | null>;
+/**
+ * Sorts packages by their dependencies to ensure correct build/publish order
+ */
+export declare function sortPackagesByDependencies(packages: WorkspacePackage[]): WorkspacePackage[];
+/**
+ * Filters packages based on include/exclude patterns
+ */
+export declare function filterPackagesByPatterns(packages: WorkspacePackage[], includePatterns: string[], excludePatterns: string[]): WorkspacePackage[];

package/bin/impl/utils/workspace-utils.js

@@ -0,0 +1,127 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "glob";
+import { readPackageJson } from "../monorepo/monorepo-mod.js";
+export async function detectWorkspaces(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!await fs.pathExists(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    let workspaceGlobs = [];
+    if (packageJson.workspaces) {
+      if (Array.isArray(packageJson.workspaces)) {
+        workspaceGlobs = packageJson.workspaces;
+      } else if (typeof packageJson.workspaces === "object" && packageJson.workspaces.packages) {
+        workspaceGlobs = Array.isArray(packageJson.workspaces.packages) ? packageJson.workspaces.packages : [];
+      }
+    }
+    if (workspaceGlobs.length === 0) {
+      return null;
+    }
+    relinka("verbose", `Found workspace configuration with patterns: ${workspaceGlobs.join(", ")}`);
+    const packageJsonPaths = [];
+    for (const pattern of workspaceGlobs) {
+      const searchPattern = path.join(cwd, pattern, "package.json");
+      const matches = await glob(searchPattern, { cwd });
+      packageJsonPaths.push(...matches.map((match) => path.resolve(cwd, match)));
+    }
+    const uniquePackageJsonPaths = [...new Set(packageJsonPaths)];
+    relinka("verbose", `Found ${uniquePackageJsonPaths.length} package.json files in workspace`);
+    const packages = [];
+    for (const packageJsonPath2 of uniquePackageJsonPaths) {
+      const pkg = await readPackageJson(packageJsonPath2);
+      if (!pkg) {
+        relinka("verbose", `Skipping invalid package.json at ${packageJsonPath2}`);
+        continue;
+      }
+      try {
+        const rawContent = await fs.readFile(packageJsonPath2, "utf-8");
+        const rawPkg = JSON.parse(rawContent);
+        if (!rawPkg.name || rawPkg.private === true) {
+          relinka(
+            "verbose",
+            `Skipping package ${rawPkg.name || "unnamed"} (${rawPkg.private ? "private" : "no name"})`
+          );
+          continue;
+        }
+        const workspaceDependencies = [];
+        const allDeps = { ...rawPkg.dependencies, ...rawPkg.devDependencies };
+        for (const [depName, version] of Object.entries(allDeps)) {
+          if (typeof version === "string" && version.startsWith("workspace:")) {
+            workspaceDependencies.push(depName);
+          }
+        }
+        packages.push({
+          name: rawPkg.name,
+          path: path.dirname(packageJsonPath2),
+          packageJsonPath: packageJsonPath2,
+          version: rawPkg.version || "0.0.0",
+          private: rawPkg.private === true,
+          dependencies: Object.keys(allDeps),
+          workspaceDependencies
+        });
+        relinka("verbose", `Added package: ${rawPkg.name} (${rawPkg.version})`);
+      } catch (error) {
+        relinka("warn", `Failed to read package.json at ${packageJsonPath2}: ${error}`);
+      }
+    }
+    relinka("verbose", `Found ${packages.length} publishable packages in workspace`);
+    return packages.length > 0 ? packages : null;
+  } catch (error) {
+    relinka("warn", `Failed to detect workspaces: ${error}`);
+    return null;
+  }
+}
+export function sortPackagesByDependencies(packages) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(pkg) {
+    if (visiting.has(pkg.name)) {
+      relinka("warn", `Circular dependency detected involving package: ${pkg.name}`);
+      return;
+    }
+    if (visited.has(pkg.name)) {
+      return;
+    }
+    visiting.add(pkg.name);
+    for (const depName of pkg.workspaceDependencies) {
+      const depPkg = packages.find((p) => p.name === depName);
+      if (depPkg) {
+        visit(depPkg);
+      }
+    }
+    visiting.delete(pkg.name);
+    visited.add(pkg.name);
+    sorted.push(pkg);
+  }
+  for (const pkg of packages) {
+    visit(pkg);
+  }
+  relinka("verbose", `Sorted packages by dependencies: ${sorted.map((p) => p.name).join(" -> ")}`);
+  return sorted;
+}
+export function filterPackagesByPatterns(packages, includePatterns, excludePatterns) {
+  let filtered = packages;
+  if (includePatterns.length > 0) {
+    filtered = filtered.filter(
+      (pkg) => includePatterns.some((pattern) => {
+        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+        return regex.test(pkg.name) || regex.test(pkg.path);
+      })
+    );
+  }
+  if (excludePatterns.length > 0) {
+    filtered = filtered.filter(
+      (pkg) => !excludePatterns.some((pattern) => {
+        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+        return regex.test(pkg.name) || regex.test(pkg.path);
+      })
+    );
+  }
+  return filtered;
+}

package/bin/mod.d.ts

@@ -191,15 +191,6 @@ export { applyMagicSpells, getAllAvailableRegistries, getFilesWithMagicSpells, p
 export type { SpellDirective, SpellEvaluationContext, SpellInfo, SpellOutcome, } from "./impl/magic/magic-spells";
 export { evaluateMagicDirective, getAvailableSpells } from "./impl/magic/magic-spells";
 export { DEFAULT_IGNORES, DEFAULT_SEPARATOR_RAW, normalizeGlobPattern, parseCSV, processSection, unescape, writeFilesPreserveStructure, writeResult, } from "./impl/merge/mod";
-export { migrateAnythingToBun } from "./impl/migrate/codemods/anything-bun";
-export { commanderToRempts } from "./impl/migrate/codemods/commander-rempts";
-export { consoleToRelinka } from "./impl/migrate/codemods/console-relinka";
-export { migrateFsToRelifso } from "./impl/migrate/codemods/fs-relifso";
-export type { CatalogMergeResult, DependencyEntry, MigrationResult, } from "./impl/migrate/codemods/monorepo-catalog";
-export { displayMigrationResults, extractDependencies, mergeToCatalog, migrateFromCatalog, migrateToCatalog, removeCatalogFromRoot, replaceDependenciesWithCatalogRefs, restoreCatalogReferences, shouldSkipDependency, updateRootWithCatalog, } from "./impl/migrate/codemods/monorepo-catalog";
-export { migrateModuleResolution, migrateToBundler, migrateToNodeNext, } from "./impl/migrate/codemods/nodenext-bundler";
-export { migratePathToPathkit } from "./impl/migrate/codemods/path-pathkit";
-export { migrateReaddirToGlob } from "./impl/migrate/codemods/readdir-glob";
 export { type CacheResult, cachePackageOutput, cleanCache, hashPackage, isPackageCached, restorePackageCache, } from "./impl/monorepo/cache-mod";
 export { allCommand, buildCommand, cleanCommand, depsCommand, graphCommand, type MonorepoContext, } from "./impl/monorepo/commands-mod";
 export { DependencyGraph } from "./impl/monorepo/graph-mod";
@@ -312,7 +303,7 @@ export { openVercelTools } from "./impl/toolbox/toolbox-vercel";
 export type { BundleSource, IndentOptions, MagicStringOptions, OverwriteOptions, StringTransformer, TransformResult, UpdateOptions, } from "./impl/transform/transform-impl-mod";
 export { append, compose, createBundle, createTransformer, createTransformerFromMagicString, indent, insertAt, overwrite, pipe, prepend, readAndTransform, remove, replace, replaceAll, slice, template, transformAndWrite, transformMultiple, trim, update, wrapWith, } from "./impl/transform/transform-impl-mod";
 export type { AppParams, ArgTypeShared, BaseBuildEntry, BaseConfig, Behavior, BiomeConfig, BiomeConfigResult, BuildContext, BuildEntry, BuildHooks, BuildOptions, BuildPreset, CamelCase, CheckIssue, CheckResult, ColumnType, CommonCliArgs, CopyBuildEntry, CopyHooks, CreateLoaderOptions, DatabasePostgresProvider, DatabaseProvider, DeploymentService, DetectedProject, DirectoryType, DistDirs, DistDirsAll, EsbuildOptions, GitModParams, HyphenatedStringToCamelCase, IconName, InputFile, IntegrationCategory, IntegrationConfig, IntegrationOption, IntegrationOptions, IterableError, Loader, LoaderContext, LoaderResult, LoadFile, MkdistBuildEntry, MkdistHooks, MkdistOptions, ModernReplacement, MonorepoType, NavItem, NavItemWithChildren, NavigationEntry, OutputFile, ParamsOmitReli, ParamsOmitSkipPN, PerfTimer, PrismaField, PrismaModel, ProjectConfigReturn, ProjectSelectionResult, RemovalConfig, RollupBuildEntry, RollupBuildOptions, RollupHooks, RollupOptions, RulesCheckOptions, ShadcnConfig, SubOption, TableSchema, Theme, UnifiedBuildConfig, UntypedBuildEntry, UntypedHooks, UntypedOutput, UntypedOutputs, VSCodeSettings, } from "./impl/types/mod";
-export { checkPackageUpdates, handleInstallation, prepareAllUpdateCandidates, updateAllPackageJsonFiles, validatePackageJson, } from "./impl/update/impl";
+export { checkPackageUpdatesForFile, handleInstallation, prepareAllUpdateCandidates, updatePackageJsonFileDirectly, validatePackageJson, } from "./impl/update/impl";
 export type { DependencyInfo, PackageCheckOptions, UpdateResult, } from "./impl/update/utils";
 export { applyVersionUpdate, checkPackageUpdate, collectTargetDependencies, displayStructuredUpdateResults, fetchVersionFromRegistry, getLatestVersion, getPmOptions, isCatalogReference, isNonSemverSpecifier, isNpmAlias, isSemverCompatible, isWorkspaceDependency, prepareDependenciesForUpdate, runInstallCommand, updatePackageJsonFile, } from "./impl/update/utils";
 export type { UploadFile, UploadResult } from "./impl/upload/providers/providers-mod";
@@ -435,3 +426,5 @@ export { regular_createPackageJSON } from "./impl/utils/utils-package-json-regul
 export { createPerfTimer, getElapsedPerfTime, pausePerfTimer, resumePerfTimer, } from "./impl/utils/utils-perf";
 export { ALLOWED_FILE_TYPES, checkFileSize, checkPermissions, handleCtxError, sanitizeInput, setFileSizeLimits, validateContent, validateFileExists, validateFileType, validateMergeOperation, validatePath, validateTemplate, } from "./impl/utils/utils-security";
 export { createProjectTSConfig, createTSConfig } from "./impl/utils/utils-tsconfig";
+export { promptWorkspacePackages, showPackageSummary, } from "./impl/utils/workspace-prompt";
+export { detectWorkspaces, filterPackagesByPatterns, sortPackagesByDependencies, type WorkspaceConfig, type WorkspacePackage, } from "./impl/utils/workspace-utils";

package/bin/mod.js

@@ -476,29 +476,6 @@ export {
   writeFilesPreserveStructure,
   writeResult
 } from "./impl/merge/mod.js";
-export { migrateAnythingToBun } from "./impl/migrate/codemods/anything-bun.js";
-export { commanderToRempts } from "./impl/migrate/codemods/commander-rempts.js";
-export { consoleToRelinka } from "./impl/migrate/codemods/console-relinka.js";
-export { migrateFsToRelifso } from "./impl/migrate/codemods/fs-relifso.js";
-export {
-  displayMigrationResults,
-  extractDependencies,
-  mergeToCatalog,
-  migrateFromCatalog,
-  migrateToCatalog,
-  removeCatalogFromRoot,
-  replaceDependenciesWithCatalogRefs,
-  restoreCatalogReferences,
-  shouldSkipDependency,
-  updateRootWithCatalog
-} from "./impl/migrate/codemods/monorepo-catalog.js";
-export {
-  migrateModuleResolution,
-  migrateToBundler,
-  migrateToNodeNext
-} from "./impl/migrate/codemods/nodenext-bundler.js";
-export { migratePathToPathkit } from "./impl/migrate/codemods/path-pathkit.js";
-export { migrateReaddirToGlob } from "./impl/migrate/codemods/readdir-glob.js";
 export {
   cachePackageOutput,
   cleanCache,
@@ -767,10 +744,10 @@ export {
   wrapWith
 } from "./impl/transform/transform-impl-mod.js";
 export {
-  checkPackageUpdates,
+  checkPackageUpdatesForFile,
   handleInstallation,
   prepareAllUpdateCandidates,
-  updateAllPackageJsonFiles,
+  updatePackageJsonFileDirectly,
   validatePackageJson
 } from "./impl/update/impl.js";
 export {
@@ -1037,3 +1014,12 @@ export {
   validateTemplate
 } from "./impl/utils/utils-security.js";
 export { createProjectTSConfig, createTSConfig } from "./impl/utils/utils-tsconfig.js";
+export {
+  promptWorkspacePackages,
+  showPackageSummary
+} from "./impl/utils/workspace-prompt.js";
+export {
+  detectWorkspaces,
+  filterPackagesByPatterns,
+  sortPackagesByDependencies
+} from "./impl/utils/workspace-utils.js";

package/package.json

@@ -55,6 +55,7 @@
     "execa": "^9.6.0",
     "file-type": "^21.0.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
+    "glob": "^11.0.3",
     "globby": "^15.0.0",
     "gpt-tokenizer": "^3.2.0",
     "gradient-string": "^3.0.0",
@@ -123,7 +124,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.151",
+  "version": "1.7.153",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",

package/bin/impl/migrate/codemods/anything-bun.d.ts

@@ -1,5 +0,0 @@
-export declare function migrateAnythingToBun({ project, dryRun, noBackup, }: {
-    project?: string;
-    dryRun?: boolean;
-    noBackup?: boolean;
-}): Promise<void>;