@reliverse/dler 2.2.5 → 2.2.10

package/dist/cmds/senv/cmd.js

@@ -1,14 +1,12 @@
-import { defineArgs, defineCommand } from "@reliverse/dler-launcher";
-import { logger } from "@reliverse/dler-logger";
-import fs from "fs/promises";
-const isWindows = () => globalThis.Bun?.platform?.() === "win32" || process.platform === "win32";
+import fs from "@reliverse/relifso";
+import { logger } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+const isWindows = () => {
+  const bun = globalThis;
+  return bun.Bun?.platform?.() === "win32" || process.platform === "win32";
+};
 const fileExists = async (path) => {
-  try {
-    await fs.access(path);
-    return true;
-  } catch {
-    return false;
-  }
+  return await fs.pathExists(path);
 };
 const normalizePathEntries = (raw) => {
   const sep = isWindows() ? ";" : ":";
@@ -44,7 +42,7 @@ const backupFile = async (path) => {
     const now = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const random = Math.random().toString(36).substring(2, 8);
     const bak = `${path}.bak.${now}.${random}`;
-    await fs.copyFile(path, bak);
+    await fs.copy(path, bak);
     logger.info(`Backup created: ${bak}`);
   } catch (error) {
     logger.warn(`Failed to create backup for ${path}: ${error}`);
@@ -105,8 +103,8 @@ export ${name}="${value}"
       return;
     }
     await backupFile(profile);
-    const content = await fs.readFile(profile, "utf8");
-    const newContent = re.test(content) ? content.replace(re, `export ${name}="${value}"`) : content + `
+    const content = await fs.readFile(profile, { encoding: "utf8" });
+    const newContent = re.test(content) ? content.replace(re, `export ${name}="${value}"`) : `${content}
 # added by dler senv
 export ${name}="${value}"
 `;
@@ -128,7 +126,7 @@ const persistPosixEditPath = async (name, entry, action) => {
   const re = new RegExp(`^\\s*export\\s+${escapedName}=["']?(.*)["']?$`, "m");
   await backupFile(profile);
   const exists = await fileExists(profile);
-  const content = exists ? await fs.readFile(profile, "utf8") : "";
+  const content = exists ? await fs.readFile(profile, { encoding: "utf8" }) : "";
   const match = content.match(re);
   const current = match ? match[1] : process.env[name] || "";
   let entries = normalizePathEntries(current || "").map(normalizeEntry);
@@ -145,7 +143,7 @@ const persistPosixEditPath = async (name, entry, action) => {
   }
   entries = uniqueByComparable(entries);
   const newVal = joinPathEntries(entries);
-  const next = re.test(content) ? content.replace(re, `export ${name}="${newVal}"`) : content + `
+  const next = re.test(content) ? content.replace(re, `export ${name}="${newVal}"`) : `${content}
 # added by dler senv
 export ${name}="${newVal}"
 `;

package/dist/cmds/tsc/cache.js

@@ -21,7 +21,7 @@ export class TscCache {
     try {
       await mkdir(this.options.cacheDir, { recursive: true });
       await this.loadMetadata();
-    } catch (error) {
+    } catch (_error) {
       this.options.enabled = false;
     }
   }

package/dist/cmds/tsc/cmd.js

@@ -1,5 +1,5 @@
-import { defineArgs, defineCommand } from "@reliverse/dler-launcher";
-import { logger } from "@reliverse/dler-logger";
+import { logger } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { runTscOnAllPackages } from "./impl.js";
 export default defineCommand({
   meta: {
@@ -7,10 +7,10 @@ export default defineCommand({
     description: "Run TypeScript type checking on all workspace packages",
     examples: [
       "dler tsc",
-      'dler tsc --filter "@reliverse/dler-prompt,@reliverse/dler-build"',
+      'dler tsc --filter "@reliverse/rempts,@reliverse/build"',
       'dler tsc --ignore "@reliverse/*"',
-      'dler tsc --ignore "@reliverse/dler-colors" --ignore "@reliverse/dler-v1"',
-      'dler tsc --ignore "@reliverse/dler-colors @reliverse/dler-v1"',
+      'dler tsc --ignore "@reliverse/relico" --ignore "@reliverse/dler-v1"',
+      'dler tsc --ignore "@reliverse/relico @reliverse/dler-v1"',
       "dler tsc --cwd /path/to/monorepo",
       "dler tsc --cwd /path/to/monorepo --ignore @reliverse/*",
       "dler tsc --concurrency 8",
@@ -32,7 +32,7 @@ export default defineCommand({
   args: defineArgs({
     filter: {
       type: "string",
-      description: "Package(s) to include (supports wildcards and comma-separated values like '@reliverse/dler-prompt,@reliverse/dler-build'). Takes precedence over --ignore when both are provided.",
+      description: "Package(s) to include (supports wildcards and comma-separated values like '@reliverse/rempts,@reliverse/build'). Takes precedence over --ignore when both are provided.",
       positional: true
     },
     ignore: {
@@ -57,7 +57,8 @@ export default defineCommand({
     },
     copyLogs: {
       type: "boolean",
-      description: "Copy failed package logs to clipboard (default: false)"
+      description: "Copy failed package logs to clipboard (default: true, skipped in CI)",
+      default: true
     },
     cache: {
       type: "boolean",
@@ -86,12 +87,14 @@ export default defineCommand({
         logger.error("\u274C This command requires Bun runtime. Sorry.");
         process.exit(1);
       }
+      const isCI = process.env.CI === "true" || !process.stdout.isTTY;
+      const shouldCopyLogs = args.copyLogs !== false && !isCI;
       const results = await runTscOnAllPackages(args.ignore, args.cwd, {
         filter: args.filter,
         concurrency: args.concurrency,
         stopOnError: args.stopOnError,
         verbose: args.verbose,
-        copyLogs: args.copyLogs,
+        copyLogs: shouldCopyLogs,
         cache: args.cache,
         incremental: args.incremental,
         autoConcurrency: args.autoConcurrency,

package/dist/cmds/tsc/impl.js

@@ -1,20 +1,21 @@
 import { existsSync } from "node:fs";
 import { cpus } from "node:os";
 import { join, relative, resolve } from "node:path";
-import { writeErrorLines } from "@reliverse/dler-helpers";
-import { logger } from "@reliverse/dler-logger";
-import pMap from "@reliverse/dler-mapper";
+import { writeErrorLines } from "@reliverse/helpers";
+import pMap from "@reliverse/mapkit";
 import {
   createIgnoreFilter,
   createIncludeFilter,
   normalizePatterns
-} from "@reliverse/dler-matcher";
+} from "@reliverse/matcha";
+import { logger } from "@reliverse/relinka";
 import {
   getWorkspacePatterns,
   hasWorkspaces,
   readPackageJSON
-} from "@reliverse/dler-pkg-tsc";
+} from "@reliverse/typerso";
 import clipboard from "clipboardy";
+import { lookpath } from "lookpath";
 import { TscCache } from "./cache.js";
 const DEFAULT_CONCURRENCY = Math.max(4, cpus().length);
 const DISCOVERY_CONCURRENCY = 10;
@@ -113,7 +114,9 @@ const getWorkspacePackages = async (cwd) => {
     },
     { concurrency: DISCOVERY_CONCURRENCY }
   );
-  const packages = packageResults.filter((result) => result.pkgInfo !== null).map((result) => result.pkgInfo);
+  const packages = packageResults.filter(
+    (result) => result.pkgInfo !== null
+  ).map((result) => result.pkgInfo);
   const filteredPackages = packages.filter((pkg) => {
     const normalizedPkgPath = resolve(pkg.path);
     const normalizedRootPath = resolve(monorepoRoot);
@@ -150,17 +153,48 @@ const hasProjectReferences = async (packagePath) => {
     return false;
   }
 };
+const findTscExecutable = async (packagePath) => {
+  const localTscPath = join(packagePath, "node_modules", ".bin", "tsc");
+  if (existsSync(localTscPath)) {
+    return localTscPath;
+  }
+  let currentDir = resolve(packagePath, "..");
+  while (currentDir !== "/") {
+    const parentLocalTscPath = join(currentDir, "node_modules", ".bin", "tsc");
+    if (existsSync(parentLocalTscPath)) {
+      return parentLocalTscPath;
+    }
+    const parentDir = resolve(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  const globalTscPath = await lookpath("tsc");
+  if (globalTscPath) {
+    return globalTscPath;
+  }
+  return null;
+};
 const runTscCommand = async (packagePath, options = {}) => {
   try {
-    const { incremental = true, buildMode = false } = options;
+    const {
+      incremental = true,
+      buildMode = false,
+      tscExecutable: providedTsc
+    } = options;
+    const tscExecutable = providedTsc ?? await findTscExecutable(packagePath);
+    if (!tscExecutable) {
+      throw new Error(
+        "TypeScript not found. Skipping package (install typescript locally or globally to enable type checking)."
+      );
+    }
     let args;
     if (buildMode && await hasProjectReferences(packagePath)) {
-      args = ["tsc", "--build"];
+      args = [tscExecutable, "--build"];
       if (incremental) {
         args.push("--incremental");
       }
     } else {
-      args = ["tsc", "--noEmit"];
+      args = [tscExecutable, "--noEmit"];
       if (incremental) {
         args.push("--incremental");
         const tsBuildInfoPath = join(
@@ -213,7 +247,7 @@ const filterOutputLines = (output, packagePath, monorepoRoot) => {
       continue;
     }
     const match = line.match(/^(.+?)\(/);
-    if (match && match[1]) {
+    if (match?.[1]) {
       const relativePath = match[1];
       const fullPath = resolve(packagePath, relativePath);
       const normalizedFilePath = resolve(fullPath);
@@ -235,6 +269,21 @@ const filterOutputLines = (output, packagePath, monorepoRoot) => {
   }
   return filtered.join("\n");
 };
+const checkRequiredDependencies = async (packagePath) => {
+  try {
+    const pkg = await readPackageJSON(packagePath);
+    if (!pkg) {
+      return { hasTypeScript: false, hasTypesBun: false };
+    }
+    const deps = pkg.dependencies && typeof pkg.dependencies === "object" ? pkg.dependencies : {};
+    const devDeps = pkg.devDependencies && typeof pkg.devDependencies === "object" ? pkg.devDependencies : {};
+    const hasTypeScript = "typescript" in deps || "typescript" in devDeps;
+    const hasTypesBun = "@types/bun" in deps || "@types/bun" in devDeps;
+    return { hasTypeScript, hasTypesBun };
+  } catch {
+    return { hasTypeScript: false, hasTypesBun: false };
+  }
+};
 const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
   const {
     verbose = false,
@@ -261,6 +310,21 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
       executionTime: Date.now() - startTime
     };
   }
+  const { hasTypeScript, hasTypesBun } = await checkRequiredDependencies(
+    pkg.path
+  );
+  if (!hasTypeScript || !hasTypesBun) {
+    const missing = [];
+    if (!hasTypeScript) {
+      missing.push("typescript");
+    }
+    if (!hasTypesBun) {
+      missing.push("@types/bun");
+    }
+    throw new Error(
+      `Package ${pkg.name} has tsconfig.json but ${missing.join(" and ")} ${missing.length === 1 ? "is" : "are"} not listed in dependencies or devDependencies. Please add ${missing.join(" and ")} to this package's package.json (then run bun install).`
+    );
+  }
   if (cache) {
     const shouldSkip = await cache.shouldSkipPackage(pkg);
     if (shouldSkip) {
@@ -287,7 +351,39 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
     logger.info(`\u{1F50D} Checking ${pkg.name}...`);
   }
   try {
-    const result = await runTscCommand(pkg.path, { incremental, buildMode });
+    const tscExecutable = await findTscExecutable(pkg.path);
+    if (!tscExecutable) {
+      throw new Error(
+        "TypeScript not found. Skipping package (install typescript locally or globally to enable type checking)."
+      );
+    }
+    if (verbose) {
+      const normalizedTscPath = resolve(tscExecutable);
+      const normalizedPackagePath = resolve(pkg.path);
+      const normalizedMonorepoRoot = resolve(monorepoRoot);
+      const relativeToPackage = relative(
+        normalizedPackagePath,
+        normalizedTscPath
+      );
+      const relativeToMonorepo = relative(
+        normalizedMonorepoRoot,
+        normalizedTscPath
+      );
+      let source;
+      if (normalizedTscPath.startsWith(normalizedPackagePath)) {
+        source = `local (${relativeToPackage})`;
+      } else if (normalizedTscPath.startsWith(normalizedMonorepoRoot)) {
+        source = `monorepo root (${relativeToMonorepo})`;
+      } else {
+        source = `global (${tscExecutable})`;
+      }
+      logger.info(`   Using tsc: ${source}`);
+    }
+    const result = await runTscCommand(pkg.path, {
+      incremental,
+      buildMode,
+      tscExecutable
+    });
     const output = result.stdout + result.stderr;
     const filteredOutput = filterOutputLines(output, pkg.path, monorepoRoot);
     const totalCounts = countErrorsAndWarnings(output);
@@ -322,9 +418,28 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
     }
     return tscResult;
   } catch (error) {
-    logger.error(
-      `\u274C ${pkg.name}: Failed to run tsc - ${error instanceof Error ? error.message : String(error)}`
-    );
+    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)`
+        );
+      }
+      return {
+        package: pkg,
+        success: true,
+        skipped: true,
+        cached: false,
+        totalErrors: 0,
+        totalWarnings: 0,
+        filteredErrors: 0,
+        filteredWarnings: 0,
+        output: "",
+        filteredOutput: "",
+        executionTime: Date.now() - startTime
+      };
+    }
+    logger.error(`\u274C ${pkg.name}: Failed to run tsc - ${errorMessage}`);
     return {
       package: pkg,
       success: false,
@@ -334,8 +449,8 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
       totalWarnings: 0,
       filteredErrors: 1,
       filteredWarnings: 0,
-      output: error instanceof Error ? error.message : String(error),
-      filteredOutput: error instanceof Error ? error.message : String(error),
+      output: errorMessage,
+      filteredOutput: errorMessage,
       executionTime: Date.now() - startTime
     };
   }
@@ -465,7 +580,7 @@ const collectFailedPackageLogs = (summary) => {
     logs.push(
       `   Errors: ${result.filteredErrors}, Warnings: ${result.filteredWarnings}`
     );
-    logs.push("   " + "\u2500".repeat(30));
+    logs.push(`   ${"\u2500".repeat(30)}`);
     if (result.filteredOutput.trim()) {
       const lines = result.filteredOutput.trim().split("\n").map((line) => `   ${line}`);
       logs.push(...lines);

package/dist/cmds/update/cmd.js

@@ -1,7 +1,7 @@
-import { getCurrentWorkingDirectory } from "@reliverse/dler-helpers";
-import { defineArgs, defineCommand } from "@reliverse/dler-launcher";
-import { logger } from "@reliverse/dler-logger";
-import path from "path";
+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 {
   checkPackageUpdatesForFile,
@@ -17,15 +17,15 @@ export default defineCommand({
     description: "Update all dependencies to their latest versions across all package.json files. Supports selective updates with glob patterns and comprehensive filtering options.",
     examples: [
       "dler update",
-      "dler update --install",
+      "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 --install",
-      "dler update --name react --name react-dom --install",
+      "dler update --dryRun --no-install",
+      "dler update --name react --name react-dom",
       "dler update --ignore @types/* --allowMajor"
     ]
   },
@@ -33,7 +33,7 @@ export default defineCommand({
     ci: {
       type: "boolean",
       description: msgs.args.ci,
-      default: !process.stdout.isTTY || !!process.env["CI"]
+      default: !process.stdout.isTTY || !!process.env.CI
     },
     cwd: {
       type: "string",
@@ -54,7 +54,8 @@ export default defineCommand({
     },
     install: {
       type: "boolean",
-      description: "Run install after updating",
+      description: "Run install after updating (default: true)",
+      default: true,
       aliases: ["i"]
     },
     allowMajor: {
@@ -151,7 +152,7 @@ export default defineCommand({
         await handleInstallation();
       } else {
         logger.log(
-          "Run 'bun install' to apply the changes (use --install to do this automatically)"
+          "Run 'bun install' to apply the changes (use --no-install to skip automatic installation)"
         );
       }
     } catch (error) {

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

@@ -1,4 +1,4 @@
-import { type UpdateResult } from "./utils.js";
+import { type DependencyInfo, type UpdateResult } from "./utils.js";
 interface UpdateArgs {
     ci?: boolean;
     cwd?: string;
@@ -13,9 +13,9 @@ interface UpdateArgs {
 export declare function validatePackageJson(): Promise<string>;
 export declare function prepareAllUpdateCandidates(): Promise<{
     packageJsonFiles: string[];
-    fileDepsMap: Map<string, Record<string, any>>;
+    fileDepsMap: Map<string, Record<string, DependencyInfo>>;
 }>;
-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 checkPackageUpdatesForFile(fileDepsMap: Record<string, DependencyInfo>, args: UpdateArgs): Promise<UpdateResult[]>;
+export declare function updatePackageJsonFileDirectly(packageJsonPath: string, fileDepsMap: Record<string, DependencyInfo>, updatesToApply: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
 export declare function handleInstallation(): Promise<void>;
 export {};

package/dist/cmds/update/impl.js

@@ -1,8 +1,8 @@
-import { logger } from "@reliverse/dler-logger";
-import pMap from "@reliverse/dler-mapper";
+import pMap from "@reliverse/mapkit";
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { logger } from "@reliverse/relinka";
 import { Glob } from "bun";
-import fs from "fs/promises";
-import path from "path";
 import {
   applyVersionUpdate,
   checkPackageUpdate,
@@ -12,9 +12,7 @@ import {
 } from "./utils.js";
 export async function validatePackageJson() {
   const packageJsonPath = path.resolve(process.cwd(), "package.json");
-  try {
-    await fs.access(packageJsonPath);
-  } catch {
+  if (!await fs.pathExists(packageJsonPath)) {
     logger.error("No package.json found in current directory");
     process.exit(1);
   }
@@ -41,7 +39,7 @@ export async function prepareAllUpdateCandidates() {
   for (const packageJsonPath of packageJsonFiles) {
     try {
       const packageJson = JSON.parse(
-        await fs.readFile(packageJsonPath, "utf8")
+        await fs.readFile(packageJsonPath, { encoding: "utf8" })
       );
       const { map } = collectTargetDependencies(packageJson);
       fileDepsMap.set(packageJsonPath, map);
@@ -94,7 +92,7 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
   if (updatesToApply.length === 0) return 0;
   try {
     const packageJson = JSON.parse(
-      await fs.readFile(packageJsonPath, "utf8")
+      await fs.readFile(packageJsonPath, { encoding: "utf8" })
     );
     const updatedPackageJson = { ...packageJson };
     for (const update of updatesToApply) {
@@ -129,8 +127,9 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
     }
     await fs.writeFile(
       packageJsonPath,
-      JSON.stringify(updatedPackageJson, null, 2) + "\n",
-      "utf8"
+      `${JSON.stringify(updatedPackageJson, null, 2)}
+`,
+      { encoding: "utf8" }
     );
     return updatesToApply.length;
   } catch (error) {

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

@@ -1,3 +1,17 @@
+import type { PackageJson } from "@reliverse/typerso";
+interface PackageJsonWithCatalogs extends PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    workspaces?: {
+        packages?: string[];
+        catalog?: Record<string, string>;
+        catalogs?: Record<string, Record<string, string>>;
+    };
+    catalog?: Record<string, string>;
+    catalogs?: Record<string, Record<string, string>>;
+}
 export interface UpdateResult {
     package: string;
     currentVersion: string;
@@ -35,13 +49,13 @@ export declare function isSemverCompatible(currentVersionRange: string, latestVe
  * 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): {
+export declare function collectTargetDependencies(pkg: PackageJsonWithCatalogs): {
     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;
+export declare function applyVersionUpdate(pkg: PackageJsonWithCatalogs, depName: string, newVersion: string, locations: Set<string>): void;
 /**
  * Fallback function to fetch package version directly from npm registry
  */
@@ -63,7 +77,11 @@ export declare function checkPackageUpdate(packageName: string, versionSpec: str
 /**
  * Filter and prepare dependencies for updating with glob pattern support
  */
-export declare function prepareDependenciesForUpdate(allDepsMap: Record<string, DependencyInfo>, args: any): string[];
+export declare function prepareDependenciesForUpdate(allDepsMap: Record<string, DependencyInfo>, args: {
+    name?: string[];
+    ignore?: string[];
+    ignoreFields?: string[];
+}): string[];
 /**
  * Update a single package.json file with new dependency versions
  */
@@ -71,8 +89,9 @@ export declare function updatePackageJsonFile(packageJsonPath: string, dependenc
 /**
  * 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;
+export declare function displayStructuredUpdateResults(results: UpdateResult[], packageJsonFiles: string[], fileDepsMap: Map<string, Record<string, DependencyInfo>>, showDetails?: boolean): void;
 /**
  * Run Bun install command
  */
 export declare function runInstallCommand(): Promise<void>;
+export {};

package/dist/cmds/update/utils.js

@@ -1,8 +1,8 @@
-import { logger } from "@reliverse/dler-logger";
-import zeptomatch from "@reliverse/dler-matcher";
+import zeptomatch from "@reliverse/matcha";
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { logger } from "@reliverse/relinka";
 import { $ } from "bun";
-import fs from "fs/promises";
-import path from "path";
 import semver from "semver";
 export function isNpmAlias(versionSpec) {
   return versionSpec.startsWith("npm:");
@@ -128,8 +128,11 @@ export function applyVersionUpdate(pkg, depName, newVersion, locations) {
   };
   if (locations.has("catalog")) {
     ensureWorkspaces();
-    if (!pkg.workspaces.catalog) pkg.workspaces.catalog = {};
-    pkg.workspaces.catalog[depName] = newVersion;
+    const workspaces = pkg.workspaces;
+    if (workspaces) {
+      if (!workspaces.catalog) workspaces.catalog = {};
+      workspaces.catalog[depName] = newVersion;
+    }
     if (pkg.catalog) pkg.catalog[depName] = newVersion;
   }
   for (const loc of locations) {
@@ -138,12 +141,14 @@ export function applyVersionUpdate(pkg, depName, newVersion, locations) {
       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]) {
+      const workspaces = pkg.workspaces;
+      if (workspaces) {
+        if (!workspaces.catalogs) workspaces.catalogs = {};
+        if (!workspaces.catalogs[catalogName])
+          workspaces.catalogs[catalogName] = {};
+        workspaces.catalogs[catalogName][depName] = newVersion;
+      }
+      if (pkg.catalogs?.[catalogName]) {
         pkg.catalogs[catalogName][depName] = newVersion;
       }
     }
@@ -267,7 +272,7 @@ export async function updatePackageJsonFile(packageJsonPath, dependencies, updat
   if (updatesToApply.length === 0) return 0;
   try {
     const packageJson = JSON.parse(
-      await fs.readFile(packageJsonPath, "utf8")
+      await fs.readFile(packageJsonPath, { encoding: "utf8" })
     );
     const updatedPackageJson = { ...packageJson };
     for (const update of updatesToApply) {
@@ -300,8 +305,9 @@ export async function updatePackageJsonFile(packageJsonPath, dependencies, updat
     }
     await fs.writeFile(
       packageJsonPath,
-      JSON.stringify(updatedPackageJson, null, 2) + "\n",
-      "utf8"
+      `${JSON.stringify(updatedPackageJson, null, 2)}
+`,
+      { encoding: "utf8" }
     );
     return updatesToApply.length;
   } catch (error) {
@@ -360,7 +366,7 @@ export function displayStructuredUpdateResults(results, packageJsonFiles, fileDe
       if (!byCategory.has(category)) {
         byCategory.set(category, []);
       }
-      byCategory.get(category).push(result);
+      byCategory.get(category)?.push(result);
     }
     const upToDateInFile = fileResults.filter(
       (r) => !r.updated && !r.error && r.semverCompatible