@reliverse/dler 1.7.119 → 1.7.121

package/bin/{app/remdn/cmd.js → impl/remdn/mod.js}

@@ -1,9 +1,8 @@
 import { readdir, writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
-import { defineArgs, defineCommand, selectPrompt } from "@reliverse/rempts";
 import { createJiti } from "jiti";
 import pMap from "p-map";
-const DEFAULT_CONFIG = {
+export const DEFAULT_CONFIG = {
   output: "table.html",
   dirs: {
     src: {},
@@ -16,11 +15,11 @@ const DEFAULT_CONFIG = {
     // [<main>, <dist-npm/bin | dist-libs's * npm/bin>, <dist-jsr | dist-libs's * jsr/bin>]
   }
 };
-const DEFAULT_CONFIG_PATH = "remdn.ts";
-const resolvePath = (path) => {
+export const DEFAULT_CONFIG_PATH = "remdn.ts";
+export const resolvePath = (path) => {
   return resolve(process.cwd(), path);
 };
-const validateConfigPath = (filePath) => {
+export const validateConfigPath = (filePath) => {
   const parts = filePath.split(".");
   if (parts.length <= 1 || parts.length === 2 && parts[1] === "") {
     throw new Error(
@@ -34,7 +33,7 @@ const validateConfigPath = (filePath) => {
     );
   }
 };
-const validateOutputPath = (filePath) => {
+export const validateOutputPath = (filePath) => {
   const parts = filePath.split(".");
   if (parts.length <= 1 || parts.length === 2 && parts[1] === "") {
     throw new Error(
@@ -48,7 +47,7 @@ const validateOutputPath = (filePath) => {
     );
   }
 };
-const evaluateTsConfig = async (filePath) => {
+export const evaluateTsConfig = async (filePath) => {
   try {
     const jiti = createJiti(import.meta.url, {
       fsCache: true,
@@ -70,7 +69,7 @@ const evaluateTsConfig = async (filePath) => {
     );
   }
 };
-const expandDistLibs = async (dirs) => {
+export const expandDistLibs = async (dirs) => {
   const expanded = {};
   for (const [dir, opts] of Object.entries(dirs)) {
     if (dir === "dist-libs" || dir.endsWith("/dist-libs")) {
@@ -106,7 +105,7 @@ const expandDistLibs = async (dirs) => {
   }
   return expanded;
 };
-const readConfig = async (path) => {
+export const readConfig = async (path) => {
   if (!path) {
     try {
       const defaultConfigPath = resolvePath(DEFAULT_CONFIG_PATH);
@@ -191,7 +190,7 @@ const readConfig = async (path) => {
     );
   }
 };
-const validateFilters = ({ includeExt, excludeExt }) => {
+export const validateFilters = ({ includeExt, excludeExt }) => {
   if (includeExt && excludeExt) {
     for (const ex of excludeExt) {
       if (!includeExt.includes(ex)) {
@@ -202,14 +201,14 @@ const validateFilters = ({ includeExt, excludeExt }) => {
     }
   }
 };
-const shouldInclude = (file, opts) => {
+export const shouldInclude = (file, opts) => {
   const ext = `.${file.split(".").pop()}`;
   if (!opts.includeExt && !opts.excludeExt) return true;
   if (opts.includeExt && !opts.includeExt.includes(ext)) return false;
   if (opts.excludeExt?.includes(ext)) return false;
   return true;
 };
-const getCanonicalFilename = (filename, extMap, dirPath) => {
+export const getCanonicalFilename = (filename, extMap, dirPath) => {
   if (!extMap) return filename;
   let name = filename;
   if (typeof dirPath === "string" && dirPath.includes("dist-libs")) {
@@ -238,7 +237,7 @@ const getCanonicalFilename = (filename, extMap, dirPath) => {
   }
   return name;
 };
-const getExpectedFilenames = (canonicalFilename, dirPath, extMap) => {
+export const getExpectedFilenames = (canonicalFilename, dirPath, extMap) => {
   if (!extMap) return [canonicalFilename];
   let baseName = canonicalFilename.split(".").slice(0, -1).join(".");
   const ext = canonicalFilename.split(".").pop();
@@ -280,7 +279,7 @@ const getExpectedFilenames = (canonicalFilename, dirPath, extMap) => {
   }
   return [canonicalFilename];
 };
-const scanDir = async (base, opts) => {
+export const scanDir = async (base, opts) => {
   validateFilters(opts);
   const folders = /* @__PURE__ */ new Map();
   const walk = async (rel = "") => {
@@ -300,19 +299,19 @@ const scanDir = async (base, opts) => {
   await walk();
   return { folders };
 };
-const normalizePath = (path) => {
+export const normalizePath = (path) => {
   return path.replace(/[\\/]+/g, "/");
 };
-const generateAnchor = (path) => {
+export const generateAnchor = (path) => {
   return path.toLowerCase().replace(/[^a-z0-9-]+/g, "");
 };
-const buildTableHeader = (paths) => {
+export const buildTableHeader = (paths) => {
   return [
     "| " + paths.map(normalizePath).join(" | ") + " |",
     "| " + paths.map(() => "---").join(" | ") + " |"
   ];
 };
-function mapDistLibsFolderToLibs(folder, colPath, allPaths) {
+export function mapDistLibsFolderToLibs(folder, colPath, allPaths) {
   const distLibsMatch = colPath.match(/dist-libs\/(.*?)\/(npm|jsr)\/bin/);
   if (distLibsMatch) {
     const [, libName, type] = distLibsMatch;
@@ -330,8 +329,8 @@ function mapDistLibsFolderToLibs(folder, colPath, allPaths) {
   }
   return folder;
 }
-const isDistLibsPath = (p) => p.includes("dist-libs");
-const buildTableRow = (canonicalFilename, paths, trees, folder, extMap) => {
+export const isDistLibsPath = (p) => p.includes("dist-libs");
+export const buildTableRow = (canonicalFilename, paths, trees, folder, extMap) => {
   const row = paths.map((path, i) => {
     const tree = trees[i];
     if (!tree) return "";
@@ -348,7 +347,7 @@ const buildTableRow = (canonicalFilename, paths, trees, folder, extMap) => {
   }).join(" | ");
   return "| " + row + " |";
 };
-const buildMarkdown = (title, paths, trees, extMap) => {
+export const buildMarkdown = (title, paths, trees, extMap) => {
   const lines = ["# " + title, ""];
   lines.push("**Table of Contents**:");
   lines.push("");
@@ -392,7 +391,7 @@ const buildMarkdown = (title, paths, trees, extMap) => {
   }
   return lines.join("\n");
 };
-const findMissingFiles = (mainTree, otherTrees, paths, extMap) => {
+export const findMissingFiles = (mainTree, otherTrees, paths, extMap) => {
   if (!extMap) return [];
   const notifications = [];
   const mainFolders = mainTree.folders;
@@ -430,7 +429,7 @@ const findMissingFiles = (mainTree, otherTrees, paths, extMap) => {
   }
   return notifications;
 };
-const ensureOutputPath = (path) => {
+export const ensureOutputPath = (path) => {
   if (!path.includes("/") && !path.includes("\\")) {
     return path;
   }
@@ -442,7 +441,7 @@ const ensureOutputPath = (path) => {
   }
   return path;
 };
-const ensureConfigPath = async (path) => {
+export const ensureConfigPath = async (path) => {
   if (!await Bun.file(path).exists()) {
     throw new Error(
       `Configuration file "${path}" does not exist. Please provide a valid path to a JSON configuration file.`
@@ -450,7 +449,7 @@ const ensureConfigPath = async (path) => {
   }
   return path;
 };
-const buildHtml = (title, paths, trees, extMap) => {
+export const buildHtml = (title, paths, trees, extMap) => {
   const lines = [
     "<!DOCTYPE html>",
     "<html lang='en'>",
@@ -575,7 +574,7 @@ const buildHtml = (title, paths, trees, extMap) => {
   lines.push("</html>");
   return lines.join("\n");
 };
-const getFormatFromExtension = (filePath) => {
+export const getFormatFromExtension = (filePath) => {
   const parts = filePath.split(".");
   if (parts.length <= 1 || parts.length === 2 && parts[1] === "") {
     throw new Error(
@@ -589,7 +588,7 @@ const getFormatFromExtension = (filePath) => {
     `Invalid output file extension: "${ext}". Only .md and .html extensions are supported.`
   );
 };
-const createDefaultConfig = async (path) => {
+export const createDefaultConfig = async (path) => {
   const ext = path.split(".").pop()?.toLowerCase();
   const isTs = ext === "ts";
   const config = {
@@ -655,76 +654,3 @@ export async function scanDirectories(config, configPath, outputPath) {
   await writeFile(outFile, content, { flag: "w" });
   console.log("\u2705 Generated " + outFile);
 }
-export default defineCommand({
-  meta: {
-    name: "remdn",
-    description: "Run remdn (undocs alternative)"
-  },
-  args: defineArgs({
-    mode: {
-      type: "string",
-      // - dirs-scan-only: scan directories and generate a table of files
-      // - dirs-scan-compare: compare directories and generate a table of files with extension checks
-      allowed: ["dirs-scan-only", "dirs-scan-compare"],
-      description: "Operation mode"
-    },
-    configPath: {
-      type: "string",
-      description: `Path to the configuration file. Can be:
-- Just filename with .json or .ts extension (e.g. 'config.json', 'config.ts') - will look in current directory
-- Full path with .json or .ts extension (e.g. '/path/to/config.json', '/path/to/config.ts') - must exist
-If not provided, will use default configuration at ${DEFAULT_CONFIG_PATH}`
-    },
-    outputFilePath: {
-      type: "string",
-      description: "Path to the output file. Can be:\n- Just filename with .md or .html extension (e.g. 'output.md', 'output.html') - will be created in current directory\n- Full path with .md or .html extension (e.g. '/path/to/output.md', '/path/to/output.html') - directory must exist\nIf not provided, will use default: table.html"
-    },
-    initConfig: {
-      type: "string",
-      description: `Initialize a new configuration file. Can be:
-- Just filename with .json or .ts extension (e.g. 'config.json', 'config.ts') - will be created in current directory
-- Full path with .json or .ts extension (e.g. '/path/to/config.json', '/path/to/config.ts') - directory must exist
-If not provided, will create at ${DEFAULT_CONFIG_PATH}`
-    }
-  }),
-  async run({ args }) {
-    let { configPath, outputFilePath, mode, initConfig } = args;
-    if (initConfig) {
-      initConfig = ensureOutputPath(initConfig);
-      validateConfigPath(initConfig);
-      await createDefaultConfig(initConfig);
-      return;
-    }
-    const config = configPath ? await readConfig(configPath) : await readConfig();
-    if (!outputFilePath) {
-      outputFilePath = config.output ?? "table.html";
-    } else {
-      outputFilePath = ensureOutputPath(outputFilePath);
-      validateOutputPath(outputFilePath);
-    }
-    if (configPath) {
-      configPath = await ensureConfigPath(configPath);
-      validateConfigPath(configPath);
-    }
-    if (!mode) {
-      mode = await selectPrompt({
-        title: "Select operation mode",
-        options: [
-          {
-            label: "Only scan directories and generate a table of files (recommended for most cases)",
-            value: "dirs-scan-only"
-          },
-          {
-            label: "Scan directories and generate a table of files + do extension checks",
-            value: "dirs-scan-compare"
-          }
-        ]
-      });
-    }
-    const finalConfig = mode === "dirs-scan-compare" ? config : {
-      ...config,
-      "ext-map": void 0
-    };
-    await scanDirectories(finalConfig, configPath, outputFilePath);
-  }
-});

package/bin/impl/rempts/cmd.d.ts

@@ -0,0 +1,18 @@
+export declare function handleReliverseConfig(): Promise<{
+    cmdsRoot: string;
+    cliFile: string;
+}>;
+export declare function ensureCliFile(filePath: string): Promise<string>;
+export declare function findCommandDirs(root: string): Promise<string[]>;
+export declare function generateCommandArgsMap(cmdDirs: string[]): Promise<string>;
+interface ArgDefinition {
+    name: string;
+    type: string;
+    required?: boolean;
+    default?: unknown;
+    allowed?: string[];
+}
+export declare function extractArgsFromContent(content: string): ArgDefinition[];
+export declare function generateExports(cmdDirs: string[]): Promise<string>;
+export declare function generateCommandTemplate(cmdName: string): string;
+export {};

package/bin/{app → impl}/rempts/cmd.js

@@ -1,168 +1,8 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { createJiti } from "jiti";
-export default defineCommand({
-  meta: {
-    name: "rempts",
-    version: "1.0.0",
-    description: "Scaffold new CLI commands and generate a command exports file (this file allows you to run your commands programmatically)."
-  },
-  args: defineArgs({
-    init: {
-      type: "string",
-      description: "Names of commands to initialize (space-separated or quoted)"
-    },
-    overwrite: {
-      type: "boolean",
-      description: "Overwrite existing commands and exports file",
-      default: true
-    },
-    customCmdsRoot: {
-      type: "string",
-      description: "Root directory for custom commands"
-    },
-    outFile: {
-      type: "string",
-      description: "Output file path for exports (relative to workspace root)",
-      default: "src-ts/app/cmds.ts"
-    },
-    cmdDirs: {
-      type: "array",
-      description: "Command directories to scan (relative to src-ts/app)"
-    }
-  }),
-  async run({ args }) {
-    let cmdsRoot = args.customCmdsRoot;
-    let cliFilePath = "";
-    let didInit = false;
-    if (args.init) {
-      let cmdNames = [];
-      if (Array.isArray(args.init)) {
-        cmdNames = args.init;
-      } else if (typeof args.init === "string") {
-        cmdNames = args.init.split(/\s+/).filter(Boolean);
-      }
-      if (cmdNames.length === 1) {
-        const argv = process.argv;
-        const initIndex = argv.indexOf("--init");
-        if (initIndex !== -1 && initIndex + 1 < argv.length) {
-          const additionalArgs = [];
-          for (let i = initIndex + 2; i < argv.length; i++) {
-            const arg = argv[i];
-            if (arg?.startsWith("--")) break;
-            if (arg && !arg.startsWith("-")) {
-              additionalArgs.push(arg);
-            } else {
-              break;
-            }
-          }
-          if (additionalArgs.length > 0 && cmdNames[0]) {
-            cmdNames = [cmdNames[0], ...additionalArgs];
-          }
-        }
-      }
-      if (cmdNames.length === 0) {
-        relinka("error", "No command names provided");
-        return;
-      }
-      if (!cmdsRoot) {
-        const defaultCmdsRoot = path.resolve("src-ts/app");
-        if (await fs.pathExists(defaultCmdsRoot)) {
-          cmdsRoot = defaultCmdsRoot;
-        } else {
-          const { cmdsRoot: configCmdsRoot, cliFile } = await handleReliverseConfig();
-          cmdsRoot = configCmdsRoot;
-          cliFilePath = cliFile;
-        }
-      } else {
-        cmdsRoot = path.resolve(cmdsRoot);
-      }
-      relinka("info", `\u{1F680} Creating ${cmdNames.length} command(s): ${cmdNames.join(", ")}`);
-      for (const cmdName of cmdNames) {
-        const dirPath = path.join(cmdsRoot, cmdName);
-        const filePath = path.join(dirPath, "cmd.ts");
-        if (await fs.pathExists(filePath) && !args.overwrite) {
-          relinka("warn", `Command "${cmdName}" already exists. Use --overwrite to overwrite.`);
-          continue;
-        }
-        await fs.ensureDir(dirPath);
-        const content = generateCommandTemplate(cmdName);
-        await fs.writeFile(filePath, content, "utf8");
-        relinka("verbose", `\u2705 Created new command: ${filePath}`);
-      }
-      if (cliFilePath) {
-        relinka(
-          "info",
-          "\u{1F4E6} Make sure you have @reliverse/rempts installed: bun add @reliverse/rempts"
-        );
-      }
-      didInit = true;
-    }
-    if (!args.init) {
-      const root2 = path.resolve("src-ts/app");
-      const outPath2 = path.resolve(args.outFile ?? "src-ts/app/cmds.ts");
-      const cmdDirs2 = (args.cmdDirs ?? []).length > 0 ? args.cmdDirs ?? [] : await findCommandDirs(root2);
-      if (cmdDirs2.length === 0) {
-        relinka(
-          "warn",
-          "No command directories found with cmd.ts or cmd.js files. Nothing to generate."
-        );
-        return;
-      }
-      if (await fs.pathExists(outPath2) && !args.overwrite) {
-        relinka("warn", `\u274C File "${outPath2}" already exists. Use --overwrite to overwrite.`);
-        return;
-      }
-      const exports2 = await generateExports(cmdDirs2);
-      await fs.ensureDir(path.dirname(outPath2));
-      await fs.writeFile(outPath2, exports2, "utf8");
-      relinka("success", `\u2705 Generated command exports at: ${outPath2}`);
-      relinka("verbose", `Found ${cmdDirs2.length} command(s): ${cmdDirs2.join(", ")}`);
-      return;
-    }
-    const root = path.resolve("src-ts/app");
-    const outPath = path.resolve(args.outFile ?? "src-ts/app/cmds.ts");
-    if (await fs.pathExists(outPath) && !args.overwrite) {
-      relinka("warn", `\u274C File "${outPath}" already exists. Use --overwrite to overwrite.`);
-      return;
-    }
-    const cmdDirs = (args.cmdDirs ?? []).length > 0 ? args.cmdDirs ?? [] : await findCommandDirs(root);
-    if (cmdDirs.length === 0) {
-      relinka("warn", "No command directories found with cmd.ts or cmd.js files.");
-      return;
-    }
-    const exports = await generateExports(cmdDirs);
-    await fs.ensureDir(path.dirname(outPath));
-    await fs.writeFile(outPath, exports, "utf8");
-    relinka("success", `\u2705 Generated command exports at: ${outPath}`);
-    relinka("verbose", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
-    if (didInit) {
-      relinka(
-        "log",
-        `Usage example:
-import { getCmdName } from "../cmds";
-const cmd = await getCmdName();
-await callCmd(cmd, [
-  // String arguments
-  "--name=my-project",
-  "--path=./src",
-  // Boolean flags
-  "--force",
-  "--no-cache",
-  // Number values
-  "--port=3000",
-  // Array values
-  "--files=file1.ts,file2.ts",
-  // Positional arguments (must come last)
-  "--build=src/1.ts src/2.ts",
-]);`
-      );
-    }
-  }
-});
-async function handleReliverseConfig() {
+export async function handleReliverseConfig() {
   const dlerConfigPath = path.resolve("reliverse.ts");
   let cmdsRoot = "src-ts/app";
   let cliFilePath = "";
@@ -202,7 +42,7 @@ async function handleReliverseConfig() {
   }
   return { cmdsRoot: path.resolve(cmdsRoot), cliFile: cliFilePath };
 }
-async function ensureCliFile(filePath) {
+export async function ensureCliFile(filePath) {
   const resolvedPath = path.resolve(filePath);
   if (!await fs.pathExists(resolvedPath)) {
     await fs.ensureDir(path.dirname(resolvedPath));
@@ -212,7 +52,7 @@ async function ensureCliFile(filePath) {
   }
   return "";
 }
-async function findCommandDirs(root) {
+export async function findCommandDirs(root) {
   const cmdDirs = [];
   async function scan(dir) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -232,7 +72,7 @@ async function findCommandDirs(root) {
   await scan(root);
   return cmdDirs;
 }
-async function generateCommandArgsMap(cmdDirs) {
+export async function generateCommandArgsMap(cmdDirs) {
   let interfaceContent = "// Argument types for each command based on their defineArgs\ninterface CommandArgsMap {\n";
   for (const dir of cmdDirs) {
     const cmdPath = path.join("src-ts/app", dir, "cmd.ts");
@@ -289,7 +129,7 @@ async function generateCommandArgsMap(cmdDirs) {
   interfaceContent += "}";
   return interfaceContent;
 }
-function extractArgsFromContent(content) {
+export function extractArgsFromContent(content) {
   const args = [];
   const defineArgsMatch = content.match(/defineArgs\(\s*\{([\s\S]*?)\}\s*\)/);
   if (!defineArgsMatch?.[1]) return args;
@@ -328,7 +168,7 @@ function extractArgsFromContent(content) {
   }
   return args;
 }
-async function generateExports(cmdDirs) {
+export async function generateExports(cmdDirs) {
   const lines = [
     "// autogenerated by `dler rempts`",
     "// don't edit this file manually",
@@ -388,7 +228,7 @@ async function generateExports(cmdDirs) {
   );
   return lines.join("\n");
 }
-function generateCommandTemplate(cmdName) {
+export function generateCommandTemplate(cmdName) {
   return `import { defineCommand, defineArgs } from "@reliverse/rempts";
 export default defineCommand({
   meta: {

package/bin/{app → impl}/update/impl.d.ts

@@ -2,24 +2,24 @@ import { type PackageCheckOptions, type UpdateResult } from "./utils";
 interface UpdateArgs {
     name?: string[];
     ignore?: string[];
-    "dev-only"?: boolean;
-    "prod-only"?: boolean;
-    "peer-only"?: boolean;
-    "optional-only"?: boolean;
-    "catalogs-only"?: boolean;
-    "dry-run"?: boolean;
+    devOnly?: boolean;
+    prodOnly?: boolean;
+    peerOnly?: boolean;
+    optionalOnly?: boolean;
+    catalogsOnly?: boolean;
+    dryRun?: boolean;
     concurrency?: number;
-    "with-check-script"?: boolean;
+    withCheckScript?: boolean;
     linker?: string;
-    "with-install"?: boolean;
+    withInstall?: boolean;
     global?: boolean;
     interactive?: boolean;
     filter?: string[];
-    "all-workspaces"?: boolean;
-    "root-only"?: boolean;
+    allWorkspaces?: boolean;
+    rootOnly?: boolean;
     recursive?: boolean;
-    "save-prefix"?: string;
-    "allow-major"?: boolean;
+    savePrefix?: string;
+    allowMajor?: boolean;
 }
 export declare function validateUpdateArgs(args: UpdateArgs): Promise<void>;
 export declare function handleCatalogOnlyUpdate(args: UpdateArgs): Promise<boolean>;

package/bin/{app → impl}/update/impl.js

@@ -31,11 +31,11 @@ import {
 } from "./utils.js";
 export async function validateUpdateArgs(args) {
   const exclusiveFlags = [
-    args["dev-only"],
-    args["prod-only"],
-    args["peer-only"],
-    args["optional-only"],
-    args["catalogs-only"]
+    args["devOnly"],
+    args["prodOnly"],
+    args["peerOnly"],
+    args["optionalOnly"],
+    args["catalogsOnly"]
   ];
   if (exclusiveFlags.filter(Boolean).length > 1) {
     relinka(
@@ -44,11 +44,11 @@ export async function validateUpdateArgs(args) {
     );
     process.exit(1);
   }
-  if (args["all-workspaces"] && args["root-only"]) {
+  if (args["allWorkspaces"] && args["rootOnly"]) {
     relinka("error", "Cannot specify both --all-workspaces and --root-only flags");
     process.exit(1);
   }
-  if (args.recursive && (args["all-workspaces"] || args["root-only"])) {
+  if (args.recursive && (args["allWorkspaces"] || args["rootOnly"])) {
     relinka(
       "error",
       "Cannot use --recursive with --all-workspaces or --root-only flags. Use --no-recursive to disable recursive mode."
@@ -57,7 +57,7 @@ export async function validateUpdateArgs(args) {
   }
 }
 export async function handleCatalogOnlyUpdate(args) {
-  if (!args["catalogs-only"]) {
+  if (!args["catalogsOnly"]) {
     return false;
   }
   const packageManager = await detectPackageManager(process.cwd());
@@ -113,8 +113,8 @@ export async function prepareUpdateCandidates(args) {
 }
 export async function checkPackageUpdates(candidates, allDepsMap, args) {
   const options = {
-    allowMajor: !!args["allow-major"],
-    savePrefix: args["save-prefix"],
+    allowMajor: !!args["allowMajor"],
+    savePrefix: args["savePrefix"],
     concurrency: args.concurrency || 5
   };
   return await pMap(
@@ -207,12 +207,12 @@ export async function handleRecursiveUpdates(args, options) {
 }
 export async function handleWorkspaceUpdates(args, options) {
   const isMonorepoProject = await isMonorepo(process.cwd());
-  const shouldUpdateWorkspaces = args["all-workspaces"] || !args["root-only"] && isMonorepoProject;
+  const shouldUpdateWorkspaces = args["allWorkspaces"] || !args["rootOnly"] && isMonorepoProject;
   if (shouldUpdateWorkspaces) {
     const workspacePkgJsons = await findWorkspacePackageJsons(process.cwd());
     if (workspacePkgJsons.length > 0) {
       return await updateWorkspacePackages(workspacePkgJsons, args, options);
-    } else if (args["all-workspaces"]) {
+    } else if (args["allWorkspaces"]) {
       relinka("warn", "No workspace packages found but --all-workspaces flag was provided");
     }
   } else if (isMonorepoProject) {
@@ -234,7 +234,7 @@ export function displayUpdateSummary(totalUpdated, args, isMonorepoProject, shou
   }
 }
 export async function handleInstallation(args, effectiveLinker, packageJson) {
-  if (!args["with-install"]) {
+  if (!args["withInstall"]) {
     const packageManager2 = await detectPackageManager(process.cwd());
     const installCommand = packageManager2?.command || "your package manager";
     relinka(
@@ -243,7 +243,7 @@ export async function handleInstallation(args, effectiveLinker, packageJson) {
     );
     relinka(
       "log",
-      `(experimental) Next time you can try --with-install flag to run it automatically.`
+      `(experimental) Next time you can try --withInstall flag to run it automatically.`
     );
     return;
   }
@@ -259,7 +259,7 @@ export async function handleInstallation(args, effectiveLinker, packageJson) {
     } else {
       await runInstallCommand(packageManager, effectiveLinker);
     }
-    if (packageManager.name === "bun" && packageJson.scripts?.check && args["with-check-script"]) {
+    if (packageManager.name === "bun" && packageJson.scripts?.check && args["withCheckScript"]) {
       await $`bun check`;
     }
   } catch (error) {

package/bin/{app → impl}/update/utils.js

@@ -8,7 +8,9 @@ import pMap from "p-map";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
 import { glob } from "tinyglobby";
-import { getAllPkgManagers } from "../utils/dependencies/getUserPkgManager.js";
+import {
+  getAllPkgManagers
+} from "../utils/dependencies/getUserPkgManager.js";
 import { x } from "../utils/exec/exec-mod.js";
 import { detectPackageManager } from "../utils/pm/pm-detect.js";
 import { latestVersion } from "../utils/pm/pm-meta.js";