@reliverse/dler 2.2.17 → 2.3.1

package/dist/cmds/tsc/impl.js

@@ -3,17 +3,9 @@ import { cpus } from "node:os";
 import { join, relative, resolve } from "node:path";
 import { writeErrorLines } from "@reliverse/helpers";
 import pMap from "@reliverse/mapkit";
-import {
-  createIgnoreFilter,
-  createIncludeFilter,
-  normalizePatterns
-} from "@reliverse/matcha";
+import { createIgnoreFilter, createIncludeFilter, normalizePatterns } from "@reliverse/matcha";
 import { logger } from "@reliverse/relinka";
-import {
-  getWorkspacePatterns,
-  hasWorkspaces,
-  readPackageJSON
-} from "@reliverse/typerso";
+import { getWorkspacePatterns, hasWorkspaces, readPackageJSON } from "@reliverse/typerso";
 import clipboard from "clipboardy";
 import { lookpath } from "lookpath";
 import { TscCache } from "./cache.js";
@@ -31,7 +23,9 @@ const findMonorepoRoot = async (startDir) => {
       }
     }
     const parentDir = resolve(currentDir, "..");
-    if (parentDir === currentDir) break;
+    if (parentDir === currentDir) {
+      break;
+    }
     currentDir = parentDir;
   }
   return null;
@@ -95,13 +89,17 @@ const getWorkspacePackages = async (cwd) => {
       const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
       for (const match of matches) {
         const packagePath = resolve(monorepoRoot, match);
-        if (seenPaths.has(packagePath)) continue;
+        if (seenPaths.has(packagePath)) {
+          continue;
+        }
         seenPaths.add(packagePath);
         allPackagePaths.push(packagePath);
       }
     } else {
       const packagePath = resolve(monorepoRoot, pattern);
-      if (seenPaths.has(packagePath)) continue;
+      if (seenPaths.has(packagePath)) {
+        continue;
+      }
       seenPaths.add(packagePath);
       allPackagePaths.push(packagePath);
     }
@@ -145,7 +143,9 @@ const filterPackages = (packages, ignore, filter) => {
 const hasProjectReferences = async (packagePath) => {
   try {
     const tsConfigPath = join(packagePath, "tsconfig.json");
-    if (!existsSync(tsConfigPath)) return false;
+    if (!existsSync(tsConfigPath)) {
+      return false;
+    }
     const content = await Bun.file(tsConfigPath).text();
     const config = JSON.parse(content);
     return !!(config.references && Array.isArray(config.references) && config.references.length > 0);
@@ -165,7 +165,9 @@ const findTscExecutable = async (packagePath) => {
       return parentLocalTscPath;
     }
     const parentDir = resolve(currentDir, "..");
-    if (parentDir === currentDir) break;
+    if (parentDir === currentDir) {
+      break;
+    }
     currentDir = parentDir;
   }
   const globalTscPath = await lookpath("tsc");
@@ -176,11 +178,7 @@ const findTscExecutable = async (packagePath) => {
 };
 const runTscCommand = async (packagePath, options = {}) => {
   try {
-    const {
-      incremental = true,
-      buildMode = false,
-      tscExecutable: providedTsc
-    } = options;
+    const { incremental = true, buildMode = false, tscExecutable: providedTsc } = options;
     const tscExecutable = providedTsc ?? await findTscExecutable(packagePath);
     if (!tscExecutable) {
       throw new Error(
@@ -285,12 +283,7 @@ const checkRequiredDependencies = async (packagePath) => {
   }
 };
 const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
-  const {
-    verbose = false,
-    cache,
-    incremental = true,
-    buildMode = false
-  } = options;
+  const { verbose = false, cache, incremental = true, buildMode = false } = options;
   const startTime = Date.now();
   if (!pkg.hasTsConfig) {
     if (verbose) {
@@ -310,10 +303,8 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
       executionTime: Date.now() - startTime
     };
   }
-  const { hasTypeScript, hasTypesBun } = await checkRequiredDependencies(
-    pkg.path
-  );
-  if (!hasTypeScript || !hasTypesBun) {
+  const { hasTypeScript, hasTypesBun } = await checkRequiredDependencies(pkg.path);
+  if (!(hasTypeScript && hasTypesBun)) {
     const missing = [];
     if (!hasTypeScript) {
       missing.push("typescript");
@@ -361,14 +352,8 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
       const normalizedTscPath = resolve(tscExecutable);
       const normalizedPackagePath = resolve(pkg.path);
       const normalizedMonorepoRoot = resolve(monorepoRoot);
-      const relativeToPackage = relative(
-        normalizedPackagePath,
-        normalizedTscPath
-      );
-      const relativeToMonorepo = relative(
-        normalizedMonorepoRoot,
-        normalizedTscPath
-      );
+      const relativeToPackage = relative(normalizedPackagePath, normalizedTscPath);
+      const relativeToMonorepo = relative(normalizedMonorepoRoot, normalizedTscPath);
       let source;
       if (normalizedTscPath.startsWith(normalizedPackagePath)) {
         source = `local (${relativeToPackage})`;
@@ -421,9 +406,7 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
     const errorMessage = error instanceof Error ? error.message : String(error);
     if (errorMessage.includes("TypeScript not found") || errorMessage.includes("Executable not found")) {
       if (verbose) {
-        logger.info(
-          `\u23ED\uFE0F  Skipping ${pkg.name} (TypeScript not installed in this package)`
-        );
+        logger.info(`\u23ED\uFE0F  Skipping ${pkg.name} (TypeScript not installed in this package)`);
       }
       return {
         package: pkg,
@@ -471,15 +454,13 @@ const collectAllResults = async (packages, monorepoRoot, options = {}, cache) =>
       packages,
       async (pkg, index) => {
         if (!verbose) {
-          logger.info(
-            `Processing ${pkg.name} (${index + 1}/${packages.length})...`
-          );
+          logger.info(`Processing ${pkg.name} (${index + 1}/${packages.length})...`);
         }
         return runTscOnPackage(pkg, monorepoRoot, {
           verbose,
-          cache,
           incremental,
-          buildMode
+          buildMode,
+          ...cache && { cache }
         });
       },
       {
@@ -487,19 +468,11 @@ const collectAllResults = async (packages, monorepoRoot, options = {}, cache) =>
         stopOnError
       }
     );
-    const failedPackages = tscResults.filter(
-      (r) => !r.success && !r.skipped
-    ).length;
+    const failedPackages = tscResults.filter((r) => !(r.success || r.skipped)).length;
     const successfulPackages = tscResults.filter((r) => r.success).length;
     const skippedPackages = tscResults.filter((r) => r.skipped).length;
-    const totalErrors = tscResults.reduce(
-      (sum, r) => sum + r.filteredErrors,
-      0
-    );
-    const totalWarnings = tscResults.reduce(
-      (sum, r) => sum + r.filteredWarnings,
-      0
-    );
+    const totalErrors = tscResults.reduce((sum, r) => sum + r.filteredErrors, 0);
+    const totalWarnings = tscResults.reduce((sum, r) => sum + r.filteredWarnings, 0);
     return {
       totalPackages: packages.length,
       failedPackages,
@@ -536,19 +509,11 @@ const collectAllResults = async (packages, monorepoRoot, options = {}, cache) =>
           executionTime: 0
         };
       });
-      const failedPackages = tscResults.filter(
-        (r) => !r.success && !r.skipped
-      ).length;
+      const failedPackages = tscResults.filter((r) => !(r.success || r.skipped)).length;
       const successfulPackages = tscResults.filter((r) => r.success).length;
       const skippedPackages = tscResults.filter((r) => r.skipped).length;
-      const totalErrors = tscResults.reduce(
-        (sum, r) => sum + r.filteredErrors,
-        0
-      );
-      const totalWarnings = tscResults.reduce(
-        (sum, r) => sum + r.filteredWarnings,
-        0
-      );
+      const totalErrors = tscResults.reduce((sum, r) => sum + r.filteredErrors, 0);
+      const totalWarnings = tscResults.reduce((sum, r) => sum + r.filteredWarnings, 0);
       return {
         totalPackages: packages.length,
         failedPackages,
@@ -564,7 +529,7 @@ const collectAllResults = async (packages, monorepoRoot, options = {}, cache) =>
   }
 };
 const collectFailedPackageLogs = (summary) => {
-  const failed = summary.results.filter((r) => !r.success && !r.skipped);
+  const failed = summary.results.filter((r) => !(r.success || r.skipped));
   if (failed.length === 0) {
     return "";
   }
@@ -577,9 +542,7 @@ const collectFailedPackageLogs = (summary) => {
   logs.push("");
   for (const result of failed) {
     logs.push(`\u{1F4E6} ${result.package.name}`);
-    logs.push(
-      `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`
-    );
+    logs.push(`   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`);
     logs.push(`   ${"\u2500".repeat(30)}`);
     if (result.filteredOutput.trim()) {
       const lines = result.filteredOutput.trim().split("\n").map((line) => `   ${line}`);
@@ -612,7 +575,7 @@ const copyLogsToClipboard = async (summary) => {
 const formatOutput = (summary, verbose) => {
   const { totalPackages, failedPackages, successfulPackages, skippedPackages } = summary;
   logger.log("\u2501".repeat(60));
-  logger.log(`\u{1F4CA} TypeScript Check Summary:`);
+  logger.log("\u{1F4CA} TypeScript Check Summary:");
   logger.log(`   Total packages: ${totalPackages}`);
   logger.log(`   \u2705 Passed: ${successfulPackages}`);
   logger.log(`   \u274C Failed: ${failedPackages}`);
@@ -620,14 +583,12 @@ const formatOutput = (summary, verbose) => {
   logger.log(`   \u{1F41B} Total errors: ${summary.totalErrors}`);
   logger.log(`   \u26A0\uFE0F  Total warnings: ${summary.totalWarnings}`);
   logger.log("\u2501".repeat(60));
-  const failed = summary.results.filter((r) => !r.success && !r.skipped);
+  const failed = summary.results.filter((r) => !(r.success || r.skipped));
   if (failed.length > 0) {
     logger.error("\n\u274C Failed Packages:\n");
     for (const result of failed) {
       logger.error(`\u{1F4E6} ${result.package.name}`);
-      logger.error(
-        `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`
-      );
+      logger.error(`   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`);
       if (result.filteredOutput.trim()) {
         logger.error("   \u2500".repeat(30));
         const lines = result.filteredOutput.trim().split("\n").map((line) => `   ${line}`);
@@ -669,9 +630,7 @@ export const runTscOnAllPackages = async (ignore, cwd, options = {}) => {
     const discoveryResult = await getWorkspacePackages(cwd);
     const { packages: allPackages, discoveryTime } = discoveryResult;
     if (verbose) {
-      logger.info(
-        `   Found ${allPackages.length} packages (${discoveryTime}ms)`
-      );
+      logger.info(`   Found ${allPackages.length} packages (${discoveryTime}ms)`);
       logger.info("   Packages found:");
       for (const pkg of allPackages) {
         const configStatus = pkg.hasTsConfig ? "\u2705" : "\u23ED\uFE0F";
@@ -683,16 +642,12 @@ export const runTscOnAllPackages = async (ignore, cwd, options = {}) => {
     const filteredCount = allPackages.length - packages.length;
     if (options.filter) {
       const patterns = normalizePatterns(options.filter);
-      logger.info(
-        `   Filtering to ${packages.length} packages matching: ${patterns.join(", ")}`
-      );
+      logger.info(`   Filtering to ${packages.length} packages matching: ${patterns.join(", ")}`);
     } else if (filteredCount > 0) {
       const alwaysIgnored = ["@reliverse/dler-v1"];
       const combinedIgnore = ignore ? Array.isArray(ignore) ? [...alwaysIgnored, ...ignore] : [...alwaysIgnored, ignore] : alwaysIgnored;
       const patterns = normalizePatterns(combinedIgnore);
-      logger.info(
-        `   Ignoring ${filteredCount} packages matching: ${patterns.join(", ")}`
-      );
+      logger.info(`   Ignoring ${filteredCount} packages matching: ${patterns.join(", ")}`);
     }
     let concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     if (autoConcurrency) {
@@ -706,12 +661,7 @@ export const runTscOnAllPackages = async (ignore, cwd, options = {}) => {
     if (verbose) {
       logger.info("\u{1F680} Starting TypeScript checks...\n");
     }
-    const summary = await collectAllResults(
-      packages,
-      discoveryResult.monorepoRoot,
-      options,
-      cache
-    );
+    const summary = await collectAllResults(packages, discoveryResult.monorepoRoot, options, cache);
     formatOutput(summary, verbose);
     if (copyLogs && summary.hasErrors) {
       await copyLogsToClipboard(summary);

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

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

package/dist/cmds/update/cmd.js

@@ -1,8 +1,8 @@
-import { getCurrentWorkingDirectory } from "@reliverse/helpers";
 import path from "@reliverse/pathkit";
 import { logger } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { msgs } from "../const.js";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { msgs } from "../../const.js";
 import {
   checkPackageUpdatesForFile,
   handleInstallation,
@@ -12,77 +12,53 @@ import {
 } from "./impl.js";
 import { displayStructuredUpdateResults } from "./utils.js";
 export default defineCommand({
-  meta: {
-    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 --no-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 --no-install",
-      "dler update --name react --name react-dom",
-      "dler update --ignore @types/* --allowMajor"
-    ]
-  },
-  args: defineArgs({
-    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: "Update all dependencies to their latest versions across all package.json files. Supports selective updates with glob patterns and comprehensive filtering options.",
+  options: {
+    ci: option(type("boolean | undefined"), {
+      description: msgs.args.ci
+    }),
+    cwd: option(type("string | undefined"), {
+      description: msgs.args.cwd
+    }),
+    name: option(type("string | undefined"), {
       description: "Specific dependencies to update, supports glob patterns (e.g. '@types/*', 'react*'). Can be specified multiple times or comma-separated."
-    },
-    ignore: {
-      type: "string",
+    }),
+    ignore: option(type("string | undefined"), {
       description: "Dependencies to exclude from updates, supports glob patterns (e.g. 'eslint-*', '@types/*')"
-    },
-    dryRun: {
-      type: "boolean",
+    }),
+    dryRun: option(type("boolean | undefined"), {
       description: "Preview updates without making changes"
-    },
-    install: {
-      type: "boolean",
+    }),
+    install: option(type("boolean | undefined"), {
       description: "Run install after updating (default: true)",
-      default: true,
-      aliases: ["i"]
-    },
-    allowMajor: {
-      type: "boolean",
-      description: "Allow major version updates (default: true)",
-      default: true
-    },
-    details: {
-      type: "boolean",
+      short: "i"
+    }),
+    allowMajor: option(type("boolean | undefined"), {
+      description: "Allow major version updates (default: true)"
+    }),
+    details: option(type("boolean | undefined"), {
       description: "Show detailed dependency information (default: false)",
-      aliases: ["d"]
-    },
-    ignoreFields: {
-      type: "string",
+      short: "d"
+    }),
+    ignoreFields: option(type("string | undefined"), {
       description: "Dependency fields to ignore (e.g., 'peerDependencies,catalog')"
-    }
-  }),
-  run: async ({ args }) => {
+    })
+  },
+  handler: async ({ flags }) => {
     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 : [];
+      const ci = flags.ci ?? (!process.stdout.isTTY || !!process.env.CI);
+      const dryRun = flags.dryRun ?? false;
+      const install = flags.install ?? true;
+      const allowMajor = flags.allowMajor ?? true;
+      const details = flags.details ?? false;
+      const isDryRun = dryRun;
+      const shouldInstall = install;
+      const showDetails = details;
+      const fieldsToIgnore = flags.ignoreFields ? typeof flags.ignoreFields === "string" ? flags.ignoreFields.split(",").map((s) => s.trim()) : [] : [];
       await validatePackageJson();
       const { packageJsonFiles, fileDepsMap } = await prepareAllUpdateCandidates();
       if (packageJsonFiles.length === 0) {
@@ -93,24 +69,29 @@ export default defineCommand({
       const allResults = [];
       for (const packageJsonPath of packageJsonFiles) {
         const fileDeps = fileDepsMap.get(packageJsonPath);
-        if (!fileDeps) continue;
+        if (!fileDeps) {
+          continue;
+        }
         const updateArgs = {
-          ...args,
-          name: args.name ? Array.isArray(args.name) ? args.name : [args.name] : void 0,
-          ignore: args.ignore ? Array.isArray(args.ignore) ? args.ignore : [args.ignore] : void 0,
-          ignoreFields: args.ignoreFields ? Array.isArray(args.ignoreFields) ? args.ignoreFields : args.ignoreFields.split(",").map((s) => s.trim()) : void 0
+          ci,
+          ...flags.name && {
+            name: typeof flags.name === "string" ? [flags.name] : flags.name
+          },
+          ...flags.ignore && {
+            ignore: typeof flags.ignore === "string" ? [flags.ignore] : flags.ignore
+          },
+          allowMajor,
+          dryRun: isDryRun,
+          install: shouldInstall,
+          ignoreFields: fieldsToIgnore
         };
         const results = await checkPackageUpdatesForFile(fileDeps, updateArgs);
         allResults.push(...results);
-        const toUpdate = results.filter(
-          (r) => r.updated && !r.error
-        );
+        const 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}`
-            );
+            logger.debug(`Would update ${toUpdate.length} dependencies in ${relativePath}`);
             continue;
           }
           const updated = await updatePackageJsonFileDirectly(
@@ -127,12 +108,7 @@ export default defineCommand({
           }
         }
       }
-      displayStructuredUpdateResults(
-        allResults,
-        packageJsonFiles,
-        fileDepsMap,
-        showDetails
-      );
+      displayStructuredUpdateResults(allResults, packageJsonFiles, fileDepsMap, showDetails);
       if (totalUpdated === 0) {
         if (isDryRun) {
           logger.log("Dry run mode - no changes would be made");
@@ -148,7 +124,7 @@ export default defineCommand({
       } else {
         logger.log(`Updated ${totalUpdated} dependencies`);
       }
-      if (install) {
+      if (shouldInstall) {
         await handleInstallation();
       } else {
         logger.log(

package/dist/cmds/update/impl.js

@@ -26,7 +26,7 @@ export async function prepareAllUpdateCandidates() {
     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("out") && !file.includes("target") && !file.includes(".turbo")) {
+    if (!(file.includes("node_modules") || file.includes("dist") || file.includes("build") || file.includes(".git") || file.includes("coverage") || file.includes(".next") || file.includes("out") || file.includes("target") || file.includes(".turbo"))) {
       packageJsonFiles.push(fullPath);
     }
   }
@@ -38,9 +38,7 @@ export async function prepareAllUpdateCandidates() {
   const fileDepsMap = /* @__PURE__ */ new Map();
   for (const packageJsonPath of packageJsonFiles) {
     try {
-      const packageJson = JSON.parse(
-        await fs.readFile(packageJsonPath, { encoding: "utf8" })
-      );
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: "utf8" }));
       const { map } = collectTargetDependencies(packageJson);
       fileDepsMap.set(packageJsonPath, map);
     } catch (error) {
@@ -78,18 +76,15 @@ export async function checkPackageUpdatesForFile(fileDepsMap, args) {
           location: "unknown"
         };
       }
-      return checkPackageUpdate(
-        dep,
-        depInfo.versionSpec,
-        depInfo.locations,
-        options
-      );
+      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;
+  if (updatesToApply.length === 0) {
+    return 0;
+  }
   try {
     const packageJson = JSON.parse(
       await fs.readFile(packageJsonPath, { encoding: "utf8" })
@@ -97,7 +92,9 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
     const updatedPackageJson = { ...packageJson };
     for (const update of updatesToApply) {
       const depInfo = fileDepsMap[update.package];
-      if (!depInfo) continue;
+      if (!depInfo) {
+        continue;
+      }
       const locations = depInfo.locations || /* @__PURE__ */ new Set();
       const shouldIgnore = Array.from(locations).some(
         (location) => fieldsToIgnore.includes(String(location))
@@ -107,9 +104,7 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
       }
       let newVersion;
       if (locations.has("peerDependencies")) {
-        const currentVersion = String(
-          fileDepsMap[update.package]?.versionSpec || ""
-        );
+        const currentVersion = String(fileDepsMap[update.package]?.versionSpec || "");
         if (currentVersion.startsWith(">=")) {
           newVersion = `>=${update.latestVersion}`;
         } else {
@@ -118,19 +113,12 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
       } else {
         newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
       }
-      applyVersionUpdate(
-        updatedPackageJson,
-        update.package,
-        newVersion,
-        locations
-      );
+      applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
     }
-    await fs.writeFile(
-      packageJsonPath,
-      `${JSON.stringify(updatedPackageJson, null, 2)}
-`,
-      { encoding: "utf8" }
-    );
+    await fs.writeFile(packageJsonPath, `${JSON.stringify(updatedPackageJson, null, 2)}
+`, {
+      encoding: "utf8"
+    });
     return updatesToApply.length;
   } catch (error) {
     logger.warn(
@@ -144,9 +132,7 @@ export async function handleInstallation() {
     await runInstallCommand();
     logger.log("Installation completed successfully");
   } catch (error) {
-    logger.warn(
-      `Install failed: ${error instanceof Error ? error.message : String(error)}`
-    );
+    logger.warn(`Install failed: ${error instanceof Error ? error.message : String(error)}`);
     logger.log("Run 'bun install' manually to apply the changes");
   }
 }