@reliverse/dler 1.7.67 → 1.7.69

package/bin/app/update/cmd.js

@@ -6,6 +6,7 @@ import { $ } from "bun";
 import pMap from "p-map";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
+import { getConfigBunfig } from "../../libs/sdk/sdk-impl/config/load.js";
 import { latestVersion } from "../../libs/sdk/sdk-impl/utils/pm/pm-meta.js";
 function isNpmAlias(versionSpec) {
   return versionSpec.startsWith("npm:");
@@ -104,6 +105,18 @@ export default defineCommand({
       type: "boolean",
       description: "Run `bun check` after updating (exclusive for bun environment at the moment)",
       default: false
+    },
+    linker: {
+      type: "string",
+      description: "Linker strategy (pro tip: use 'isolated' in a monorepo project, 'hoisted' (default) in a project where you have only one package.json). When this option is explicitly set, it takes precedence over bunfig.toml install.linker setting.",
+      allowed: ["isolated", "hoisted"],
+      default: "hoisted"
+    },
+    "no-install": {
+      type: "boolean",
+      description: "Skip the install step after updating dependencies",
+      default: false,
+      alias: "no-i"
     }
   }),
   async run({ args }) {
@@ -113,7 +126,19 @@ export default defineCommand({
         relinka("error", "No package.json found in current directory");
         return process.exit(1);
       }
-      relinka("info", "Reading package.json...");
+      let effectiveLinker = args.linker;
+      if (typeof Bun !== "undefined") {
+        const bunfigConfig = await getConfigBunfig();
+        if (bunfigConfig?.install?.linker) {
+          const bunfigLinker = bunfigConfig.install.linker;
+          if ((bunfigLinker === "isolated" || bunfigLinker === "hoisted") && args.linker === "hoisted") {
+            effectiveLinker = bunfigLinker;
+          }
+        }
+      }
+      if (args.linker !== "hoisted") {
+        effectiveLinker = args.linker;
+      }
       const packageJson = await readPackageJSON();
       const dependencies = packageJson.dependencies || {};
       const devDependencies = packageJson.devDependencies || {};
@@ -222,7 +247,6 @@ export default defineCommand({
         );
         return;
       }
-      relinka("info", `Checking ${semverDeps.length} dependencies for updates...`);
       const results = await pMap(
         semverDeps,
         async (dep) => {
@@ -273,11 +297,15 @@ export default defineCommand({
           relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
         }
       }
+      if (toUpdate.length === 0) {
+        relinka("success", `All ${upToDate.length} deps are already up to date`);
+        return;
+      }
       if (upToDate.length > 0) {
         relinka("success", `${upToDate.length} dependencies are up to date`);
       }
       if (toUpdate.length === 0) {
-        relinka("info", "All dependencies are up to date");
+        relinka("success", `All ${upToDate.length} deps are already up to date`);
         return;
       }
       relinka("info", `${toUpdate.length} dependencies can be updated:`);
@@ -291,7 +319,6 @@ export default defineCommand({
         relinka("info", "Dry run mode - no changes were made");
         return;
       }
-      relinka("info", "Updating package.json...");
       const updatedPackageJson = { ...packageJson };
       for (const update of toUpdate) {
         const dep = update.package;
@@ -341,8 +368,8 @@ export default defineCommand({
         "utf8"
       );
       relinka("success", `Updated ${toUpdate.length} dependencies in package.json`);
-      if (typeof Bun !== "undefined") {
-        await $`bun install`;
+      if (typeof Bun !== "undefined" && !args["no-install"]) {
+        await $`bun install --linker ${effectiveLinker}`;
         if (packageJson.scripts?.check && args["with-check-script"]) {
           await $`bun check`;
         }

package/bin/app/x/cmd.d.ts

@@ -1,11 +1,12 @@
 /**
  * USAGE EXAMPLES:
- * - dler x install package-name - installs a package
- * - dler x remove package-name - removes a package
  * - dler x detect - detects the package manager
- * - dler x dedupe - deduplicates dependencies
  * - dler x run script-name - runs a script
  * - dler x exec --target 'bun run build' - executes a command
+ * - dler x package-name - runs a package directly (like bunx/npx)
+ * - dler x package-name --args arg1 arg2 - runs a package with arguments
+ * - dler x package-name --bun - force using bunx even if different PM detected
+ * - dler x prettier --npm --yes - force using npx with auto-confirm
  */
 declare const _default: import("@reliverse/rempts").Command<{
     action: {
@@ -18,31 +19,14 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         required: false;
     };
-    global: {
-        type: "boolean";
-        alias: string;
-        description: string;
-    };
-    "frozen-lockfile": {
-        type: "boolean";
-        description: string;
-    };
     cwd: {
         type: "string";
         description: string;
     };
-    workspace: {
-        type: "boolean";
-        description: string;
-    };
     silent: {
         type: "boolean";
         description: string;
     };
-    recreateLockFile: {
-        type: "boolean";
-        description: string;
-    };
     target: {
         type: "string";
         description: string;
@@ -56,32 +40,35 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: true;
     };
-    fileType: {
+    args: {
         type: "string";
         description: string;
     };
-    destDir: {
-        type: "string";
+    global: {
+        type: "boolean";
+        alias: string;
         description: string;
-        default: string;
     };
-    multiple: {
+    yes: {
         type: "boolean";
+        alias: string;
         description: string;
     };
-    parallel: {
+    bun: {
         type: "boolean";
         description: string;
     };
-    concurrency: {
-        type: "string";
+    npm: {
+        type: "boolean";
+        description: string;
+    };
+    pnpm: {
+        type: "boolean";
         description: string;
-        default: string;
     };
-    linter: {
+    yarn: {
         type: "boolean";
         description: string;
-        default: false;
     };
 }>;
 export default _default;

package/bin/app/x/cmd.js

@@ -1,143 +1,110 @@
 import path from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import {
-  defineArgs,
-  defineCommand,
-  multiselectPrompt,
-  runCmd,
-  selectPrompt
-} from "@reliverse/rempts";
-import { getCheckCmd } from "../cmds.js";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { x } from "../../libs/sdk/sdk-impl/utils/exec/exec-mod.js";
-import { FILE_TYPES } from "../../libs/sdk/sdk-impl/utils/init/init-const.js";
-import { initFile, initFiles } from "../../libs/sdk/sdk-impl/utils/init/init-impl.js";
-import {
-  addDependency,
-  dedupeDependencies,
-  updateDependencies,
-  installDependencies,
-  removeDependency,
-  runScript
-} from "../../libs/sdk/sdk-impl/utils/pm/pm-api.js";
+import { runScript } from "../../libs/sdk/sdk-impl/utils/pm/pm-api.js";
 import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
 export default defineCommand({
   meta: {
     name: "x",
     version: "1.1.0",
-    description: "Unified package manager and command executor. Usage example: `dler x install` or `dler x exec --target 'bun run build'`"
+    description: "Utility command executor and package runner. Usage example: `dler x detect` or `dler x package-name` (like bunx/npx)"
   },
   args: defineArgs({
     action: {
       type: "string",
-      description: "Action to perform: install, remove, detect, dedupe, run, exec, latest",
+      description: "Action to perform: detect, run, exec, or package name to run directly",
       required: true
     },
     name: {
       type: "positional",
-      description: "Package name or script name",
+      description: "Script name (for run action) or additional arguments",
       required: false
     },
-    global: {
-      type: "boolean",
-      alias: "g",
-      description: "Add globally"
-    },
-    "frozen-lockfile": {
-      type: "boolean",
-      description: "Install dependencies with frozen lock file"
-    },
     cwd: {
       type: "string",
       description: "Current working directory"
     },
-    workspace: {
-      type: "boolean",
-      description: "Add to workspace"
-    },
     silent: {
       type: "boolean",
       description: "Run in silent mode"
     },
-    recreateLockFile: {
-      type: "boolean",
-      description: "Recreate lock file (for dedupe)"
-    },
     target: {
       type: "string",
       description: "Command to execute (for exec action)"
     },
     timeout: {
       type: "number",
-      description: "Timeout in milliseconds (for exec action)"
+      description: "Timeout in milliseconds"
     },
     throwOnError: {
       type: "boolean",
       description: "Throw error if command fails",
       default: true
     },
-    fileType: {
+    args: {
       type: "string",
-      description: "File type to initialize (e.g. 'md:README')"
+      description: "Additional arguments to pass to the package (space-separated)"
     },
-    destDir: {
-      type: "string",
-      description: "Destination directory",
-      default: "."
+    global: {
+      type: "boolean",
+      alias: "g",
+      description: "Use global package manager execution"
     },
-    multiple: {
+    yes: {
       type: "boolean",
-      description: "Whether to select multiple file types from the library"
+      alias: "y",
+      description: "Automatically confirm package installation if needed"
     },
-    parallel: {
+    bun: {
       type: "boolean",
-      description: "Run tasks in parallel"
+      description: "Force using bunx (overrides package manager detection)"
     },
-    concurrency: {
-      type: "string",
-      description: "Concurrency limit if parallel is true",
-      default: "4"
+    npm: {
+      type: "boolean",
+      description: "Force using npx (overrides package manager detection)"
+    },
+    pnpm: {
+      type: "boolean",
+      description: "Force using pnpx (overrides package manager detection)"
     },
-    linter: {
+    yarn: {
       type: "boolean",
-      description: "Run linter checks after updating dependencies",
-      default: false
+      description: "Force using yarn dlx (overrides package manager detection)"
     }
   }),
   async run({ args }) {
-    console.log("DEBUG: x command starting with args:", args);
     const {
       action,
       name,
       target,
       timeout,
       throwOnError,
-      fileType,
-      destDir,
-      multiple,
-      parallel,
-      concurrency,
-      linter,
+      args: packageArgs,
+      global,
+      yes,
+      bun,
+      npm,
+      pnpm,
+      yarn,
       ...options
     } = args;
+    const builtInActions = ["detect", "run", "exec"];
+    const isBuiltInAction = builtInActions.includes(action);
+    if (!isBuiltInAction) {
+      await runPackage({
+        packageName: action,
+        packageArgs: name ? [name, ...packageArgs?.split(/\s+/) || []] : packageArgs?.split(/\s+/) || [],
+        cwd: options.cwd,
+        timeout,
+        throwOnError,
+        global,
+        yes,
+        forcePm: { bun, npm, pnpm, yarn }
+      });
+      return;
+    }
     switch (action) {
-      case "install":
-      case "i":
-      case "add":
-        console.log("DEBUG: install case, name:", name, "options:", options);
-        await (name ? addDependency(name, options) : installDependencies(options));
-        break;
-      case "remove":
-      case "rm":
-      case "uninstall":
-      case "un":
-      case "delete":
-      case "del":
-        if (!name) {
-          relinka.error("Package name is required for remove action");
-          return process.exit(1);
-        }
-        await removeDependency(name, options);
-        break;
       case "detect": {
         const cwd = path.resolve(options.cwd || ".");
         const packageManager = await detectPackageManager(cwd);
@@ -155,10 +122,6 @@ export default defineCommand({
         );
         break;
       }
-      case "dedupe": {
-        await dedupeDependencies(options);
-        break;
-      }
       case "run": {
         if (!name) {
           relinka.error("Script name is required for run action");
@@ -207,62 +170,95 @@ export default defineCommand({
         }
         break;
       }
-      case "init": {
-        const concurrencyNum = Number(concurrency);
-        if (fileType && !FILE_TYPES.find((ft) => ft.type === fileType)) {
-          throw new Error(`Invalid file type: ${fileType}`);
-        }
-        const effectiveFileType = fileType;
-        if (multiple) {
-          const possibleTypes = FILE_TYPES.map((ft) => ft.type);
-          const chosen = await multiselectPrompt({
-            title: "Select file types to initialize",
-            options: possibleTypes.map((pt) => ({ label: pt, value: pt }))
-          });
-          if (chosen.length === 0) {
-            relinka("log", "No file types selected. Exiting...");
-            return;
-          }
-          const requests = chosen.map((ct) => ({
-            fileType: ct,
-            destDir
-          }));
-          const results = await initFiles(requests, {
-            parallel,
-            concurrency: concurrencyNum
-          });
-          relinka("verbose", `Multiple files result: ${JSON.stringify(results)}`);
-        } else {
-          let finalFileType = effectiveFileType;
-          if (!finalFileType) {
-            const possibleTypes = FILE_TYPES.map((ft) => ft.type);
-            const picked = await selectPrompt({
-              title: "Pick a file type to initialize",
-              options: possibleTypes.map((pt) => ({ label: pt, value: pt }))
-            });
-            finalFileType = picked;
-          }
-          const result = await initFile({
-            fileType: finalFileType,
-            destDir
-          });
-          relinka("verbose", `Single file result: ${JSON.stringify(result)}`);
-        }
-        break;
-      }
-      case "latest": {
-        await updateDependencies(true, options);
-        if (linter) {
-          const checkCmd = await getCheckCmd();
-          await runCmd(checkCmd, ["--no-exit", "--no-progress"]);
-        }
-        break;
-      }
       default: {
         relinka.error(`Unknown action: ${action}`);
-        relinka.log("Available actions: install, remove, detect, dedupe, run, exec");
+        relinka.log("Available actions: detect, run, exec, or package name to run directly");
         return process.exit(1);
       }
     }
   }
 });
+async function runPackage({
+  packageName,
+  packageArgs,
+  cwd,
+  timeout,
+  throwOnError,
+  global,
+  yes,
+  forcePm
+}) {
+  try {
+    const workingDir = cwd ? path.resolve(cwd) : process.cwd();
+    let pmName;
+    const forcedPmFlags = Object.entries(forcePm).filter(([_, isForced]) => isForced);
+    if (forcedPmFlags.length > 1) {
+      relinka.error(
+        "Multiple package manager flags specified. Use only one: --bun, --npm, --pnpm, or --yarn"
+      );
+      return process.exit(1);
+    }
+    if (forcedPmFlags.length === 1) {
+      pmName = forcedPmFlags[0][0];
+      relinka.log(`Forcing package manager: ${pmName}`);
+    } else {
+      const packageManager = await detectPackageManager(workingDir);
+      if (!packageManager) {
+        relinka.warn("Cannot detect package manager. Defaulting to npm.");
+        pmName = "npm";
+      } else {
+        pmName = packageManager.name;
+      }
+    }
+    let runCommand;
+    switch (pmName) {
+      case "bun":
+        runCommand = ["bunx"];
+        break;
+      case "pnpm":
+        runCommand = ["pnpx", "dlx"];
+        break;
+      case "yarn":
+        runCommand = ["yarn", "dlx"];
+        break;
+      case "npm":
+        runCommand = ["npx"];
+        break;
+      default:
+        runCommand = ["npx"];
+        break;
+    }
+    if (global && pmName !== "yarn") {
+      runCommand.push("--global");
+    }
+    if (yes && (pmName === "npm" || pmName === "pnpm")) {
+      runCommand.push("--yes");
+    }
+    runCommand.push(packageName);
+    runCommand.push(...packageArgs);
+    relinka.log(`Running package: ${packageName}`);
+    relinka.log(`Using command: ${runCommand.join(" ")}`);
+    const result = x(runCommand[0], runCommand.slice(1), {
+      nodeOptions: {
+        cwd: workingDir,
+        stdio: "inherit"
+      },
+      timeout,
+      throwOnError
+    });
+    const output = await result;
+    if (output.exitCode === 0) {
+      relinka.success(`Successfully ran package: ${packageName}`);
+    } else {
+      relinka.warn(`Package exited with code: ${output.exitCode}`);
+      if (throwOnError) {
+        return process.exit(output.exitCode || 1);
+      }
+    }
+  } catch (error) {
+    relinka.error(
+      `Failed to run package: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return process.exit(1);
+  }
+}

package/bin/libs/cfg/cfg-impl/rse-config/rse-impl/rse-define.d.ts

@@ -1,10 +1,10 @@
 import type { RseConfig } from "./rse-types";
 export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
+    version?: string | undefined;
     $schema?: "./schema.json" | "https://reliverse.org/schema.json" | undefined;
     projectName?: string | undefined;
     projectAuthor?: string | undefined;
     projectDescription?: string | undefined;
-    version?: string | undefined;
     projectLicense?: string | undefined;
     projectRepository?: string | undefined;
     projectDomain?: string | undefined;
@@ -14,11 +14,10 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
     projectState?: "creating" | "created" | undefined;
     projectCategory?: "browser" | "cli" | "unknown" | "website" | "vscode" | "library" | "mobile" | undefined;
     projectSubcategory?: "unknown" | "e-commerce" | "tool" | undefined;
-    projectFramework?: "rempts" | "npm-jsr" | "unknown" | "vscode" | "nextjs" | "vite" | "svelte" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "vue" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
+    projectFramework?: "vue" | "unknown" | "vscode" | "nextjs" | "vite" | "svelte" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "rempts" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | "npm-jsr" | undefined;
     projectTemplate?: "unknown" | "blefnk/relivator-nextjs-template" | "blefnk/relivator-docker-template" | "blefnk/next-react-ts-src-minimal" | "blefnk/all-in-one-nextjs-template" | "blefnk/create-t3-app" | "blefnk/create-next-app" | "blefnk/astro-starlight-template" | "blefnk/versator-nextjs-template" | "blefnk/relivator-lynxjs-template" | "blefnk/relivator-react-native-template" | "reliverse/template-browser-extension" | "microsoft/vscode-extension-samples" | "microsoft/vscode-extension-template" | "rsetarter-template" | "blefnk/deno-cli-tutorial" | undefined;
     projectTemplateDate?: string | undefined;
     features?: {
-        commands?: string[] | undefined;
         i18n?: boolean | undefined;
         analytics?: boolean | undefined;
         themeMode?: "light" | "dark" | "dark-light" | undefined;
@@ -28,6 +27,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         testing?: boolean | undefined;
         docker?: boolean | undefined;
         ci?: boolean | undefined;
+        commands?: string[] | undefined;
         webview?: string[] | undefined;
         language?: string[] | undefined;
         themes?: string[] | undefined;
@@ -40,7 +40,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         testing?: "bun" | "unknown" | "vitest" | "jest" | "playwright" | "cypress" | undefined;
         stateManagement?: "unknown" | "zustand" | "jotai" | "redux-toolkit" | undefined;
         formManagement?: "unknown" | "react-hook-form" | "formik" | undefined;
-        styling?: "unknown" | "tailwind" | "styled-components" | "css-modules" | "sass" | undefined;
+        styling?: "sass" | "unknown" | "tailwind" | "styled-components" | "css-modules" | undefined;
         uiComponents?: "unknown" | "shadcn-ui" | "chakra-ui" | "material-ui" | undefined;
         databaseLibrary?: "unknown" | "drizzle" | "prisma" | "supabase" | undefined;
         databaseProvider?: "unknown" | "pg" | "mysql" | "sqlite" | "mongodb" | undefined;
@@ -83,7 +83,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         dontRemoveComments?: boolean | undefined;
         shouldAddComments?: boolean | undefined;
         typeOrInterface?: "type" | "interface" | "mixed" | undefined;
-        importOrRequire?: "mixed" | "import" | "require" | undefined;
+        importOrRequire?: "import" | "require" | "mixed" | undefined;
         cjsToEsm?: boolean | undefined;
         modernize?: {
             replaceFs?: boolean | undefined;
@@ -96,7 +96,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         importSymbol?: string | undefined;
     } | undefined;
     monorepo?: {
-        type?: "none" | "bun" | "turborepo" | "nx" | "pnpm" | undefined;
+        type?: "none" | "bun" | "pnpm" | "turborepo" | "nx" | undefined;
         packages?: string[] | undefined;
         sharedPackages?: string[] | undefined;
     } | undefined;

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.67";
+const version = "1.7.69";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/config/load.d.ts

@@ -5,3 +5,11 @@ import type { DlerConfig } from "./types.js";
  * Uses jiti for seamless TypeScript and ESM support.
  */
 export declare function getConfigDler(): Promise<DlerConfig>;
+/**
+ * Searches for and loads bunfig.toml configuration files.
+ * Checks both local (project root) and global locations.
+ * Merges configurations with local overriding global.
+ *
+ * @returns The merged bunfig configuration or null if no config found
+ */
+export declare function getConfigBunfig(): Promise<Record<string, any> | null>;

package/bin/libs/sdk/sdk-impl/config/load.js

@@ -31,3 +31,57 @@ export async function getConfigDler() {
   relinka("log", `Config file not found at ${configPath}. Using default configuration.`);
   return defineConfigDler();
 }
+export async function getConfigBunfig() {
+  const cwd = process.cwd();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  const localPaths = [resolve(cwd, "bunfig.toml"), resolve(cwd, ".bunfig.toml")];
+  const globalPaths = [
+    ...homeDir ? [resolve(homeDir, ".bunfig.toml")] : [],
+    ...xdgConfigHome ? [resolve(xdgConfigHome, ".bunfig.toml")] : []
+  ];
+  let globalConfig = {};
+  let localConfig = {};
+  for (const configPath of globalPaths) {
+    if (await fs.pathExists(configPath)) {
+      try {
+        const configContent = await fs.readFile(configPath, "utf-8");
+        let config;
+        if (typeof Bun !== "undefined") {
+          config = Bun.TOML.parse(configContent);
+        } else {
+          throw new Error(
+            "TOML parsing requires Bun runtime. Please run with Bun to load bunfig.toml files."
+          );
+        }
+        globalConfig = { ...globalConfig, ...config };
+      } catch (error) {
+        relinka("error", `Error loading global bunfig from ${configPath}:`, error);
+      }
+    }
+  }
+  for (const configPath of localPaths) {
+    if (await fs.pathExists(configPath)) {
+      try {
+        const configContent = await fs.readFile(configPath, "utf-8");
+        let config;
+        if (typeof Bun !== "undefined") {
+          config = Bun.TOML.parse(configContent);
+        } else {
+          throw new Error(
+            "TOML parsing requires Bun runtime. Please run with Bun to load bunfig.toml files."
+          );
+        }
+        localConfig = { ...localConfig, ...config };
+        break;
+      } catch (error) {
+        relinka("error", `Error loading local bunfig from ${configPath}:`, error);
+      }
+    }
+  }
+  const mergedConfig = { ...globalConfig, ...localConfig };
+  if (Object.keys(mergedConfig).length === 0) {
+    return null;
+  }
+  return mergedConfig;
+}