@reliverse/dler 1.7.67 → 1.7.69

package/README.md

@@ -1,31 +1,26 @@
-# 🧬 dler (prev. relidler) • build/publish/improve ts/js libs/cli/apps
+# 🧬 dler • unified package manager with sweet powers
 
 [sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/pb8ukbwpsj) — [github](https://github.com/reliverse/dler) — [npm](https://npmjs.com/@reliverse/dler)
 
-> @reliverse/dler (`/ˈdiː.lər/`, dealer) is your package manager's best friend. dler extends bun, pnpm, yarn, and npm core functionality and goes far beyond.
+> @reliverse/dler (prev. relidler; `/ˈdiː.lər/`, dealer) is a unified package manager for typescript/javascript projects.
+>
+> dler is your package manager's best friend. dler extends bun, pnpm, yarn, and npm core functionalities by going far beyond.
 >
 > at its core, dler is a flexible, unified, and fully automated bundler for typescript/javascript projects that doubles as an npm/jsr publishing tool. beyond bundling, dler serves as a comprehensive codemod toolkit for modern typescript/javascript development.
 
 ## features
 
-### 🚀 core power
-
+- **built-in bun environment** when dler is installed as a standalone application
 - **`unjs/unbuild` drop-in** with different powerful capabilities like publishing
 - **automated publishing** to npm/jsr registries with intelligent workflow management
 - **reliable builds** with comprehensive typescript/javascript support and error handling
 - **smart versioning** with automatic version bumps and semantic release integration
 - **zero configuration** eliminates `package.json` maintenance headaches forever
-
-### ⚡ developer experience
-
 - **performance optimized** for speed with modern build pipelines and caching
-- **16 built-in commands** — comprehensive [dler commands](#dler-commands) for every workflow
+- **17 built-in commands** — comprehensive [dler commands](#dler-commands) for every workflow
 - **path resolution magic** converts typescript aliases to relative imports automatically
 - **highly configurable** via dedicated configuration files with sensible defaults
 - **dual interface** — cli for everyday use, sdk for advanced programmatic control
-
-### 🔧 advanced capabilities
-
 - **clean distribution builds** automatically removes internal logs and debug code
 - **monorepo ready** with experimental `libs` feature for multi-library projects
 - **magic spells** — extensible plugin system for custom build transformations
@@ -98,6 +93,7 @@ bun i -g update --latest
 
 - **when installed globally**: use `dler` anywhere.
 - **when installed as dev dep**: use with package manager name prefix, e.g. `bun dler`, inside your project directory.
+- **when installed as standalone**: ...
 
 ### 2. prepare your project
 
@@ -150,7 +146,7 @@ dler [build|pub|--help] # if installed globally
 
 ## dler commands
 
-dler ships with a flexible command system (prev. plugins) and **16 built-in commands** (from [reliverse addons](https://reliverse.org/addons) collection).
+dler ships with a flexible command system (prev. plugins) and **17 built-in commands** (from [reliverse addons](https://reliverse.org/addons) collection).
 
 feel free to create your own commands. commands can be implemented as built-in directly in `src/app/<command>/impl/*` and then imported from `src/app/<command>/cmd.ts`; or implemented in your own library and then imported from `src/app/<command>/cmd.ts`.
 
@@ -929,6 +925,10 @@ bun dler update
 }
 ```
 
+**coming soon:**
+
+- recursive lookup for deps in multiple package.json files (e.g. monorepo; or case when you have `C:/foo/bar1/package.json` and `C:/foo/bar2/package.json` and using `dler update` in `C:/foo`).
+
 ## related
 
 special thanks to the project that inspired `@reliverse/dler`:
@@ -960,6 +960,80 @@ special thanks to the project that inspired `@reliverse/dler`:
 - [x] allow plugins to extend dler's `defineconfig` (`hooksBeforeBuild` and `hooksAfterBuild` are now available, plugin's options can be passed directly to plugin's params, e.g. `hooksBeforeBuild: [ async () => { await myCoolPlugin({ /* plugin's options */ }); } ],`)
 - [ ] at the moment any bundler like `mkdist` can be called using `bun`, but bun's own bundler is not yet fully supported
 - [ ] support all well-known package managers (currently only bun is fully supported)
+- [ ] `dler <command> [...flags] [...args]` usage should support both `bun` and `dler` own commands and flags
+
+### todo: commands
+
+- [ ]  run       ./my-script.ts       Execute a file with Bun
+- [ ]            lint                 Run a package.json script
+- [ ]  test                           Run unit tests with Bun
+- [ ]  x         nuxi                 Execute a package binary (CLI), installing if needed (dler x)
+- [ ]  repl                           Start a REPL session with Bun
+- [ ]  exec                           Run a shell script directly with Bun
+- [ ]  install                        Install dependencies for a package.json (dler i)
+- [ ]  add       elysia               Add a dependency to package.json (dler a)
+- [ ]  remove    backbone             Remove a dependency from package.json (dler rm)
+- [ ]  update    @shumai/shumai       Update outdated dependencies
+- [ ]  audit                          Check installed packages for vulnerabilities
+- [ ]  outdated                       Display latest versions of outdated dependencies
+- [ ]  link      [<package>]          Register or link a local npm package
+- [ ]  unlink                         Unregister a local npm package
+- [ ]  publish                        Publish a package(s) to the npm/jsr registry
+- [ ]  patch <pkg>                    Prepare a package for patching
+- [ ]  pm <subcommand>                Additional package management utilities
+- [ ]  info      hono                 Display package metadata from the registry
+- [ ]  build     ./a.ts ./b.jsx       Bundle TypeScript & JavaScript into a single file
+- [ ]  init                           Start an empty project from a built-in template
+- [ ]  create    next-app             Create a new project from a template (bun c)
+- [ ]  upgrade                        Upgrade to latest version both of dler and your package manager.
+- [x]  <command> --help               Print help text for command.
+
+### todo: flag
+
+- [ ]      --watch                         Automatically restart the process on file change
+- [ ]      --hot                           Enable auto reload in the Bun runtime, test runner, or bundler
+- [ ]      --no-clear-screen               Disable clearing the terminal screen on reload when --hot or --watch is enabled
+- [ ]      --smol                          Use less memory, but run garbage collection more often
+- [ ]  -r, --preload=<val>                 Import a module before other modules are loaded
+- [ ]      --require=<val>                 Alias of --preload, for Node.js compatibility
+- [ ]      --import=<val>                  Alias of --preload, for Node.js compatibility
+- [ ]      --inspect=<val>                 Activate Bun's debugger
+- [ ]      --inspect-wait=<val>            Activate Bun's debugger, wait for a connection before executing
+- [ ]      --inspect-brk=<val>             Activate Bun's debugger, set breakpoint on first line of code and wait
+- [ ]      --if-present                    Exit without an error if the entrypoint does not exist
+- [ ]      --no-install                    Disable auto install in the Bun runtime
+- [ ]      --install=<val>                 Configure auto-install behavior. One of "auto" (default, auto-installs when no node_modules), "fallback" (missing packages only), "force" (always).
+- [ ]  -i                                  Auto-install dependencies during execution. Equivalent to --install=fallback.
+- [ ]  -e, --eval=<val>                    Evaluate argument as a script
+- [ ]  -p, --print=<val>                   Evaluate argument as a script and print the result
+- [ ]      --prefer-offline                Skip staleness checks for packages in the Bun runtime and resolve from disk
+- [ ]      --prefer-latest                 Use the latest matching versions of packages in the Bun runtime, always checking npm
+- [ ]      --port=<val>                    Set the default port for Bun.serve
+- [ ]      --conditions=<val>              Pass custom conditions to resolve
+- [ ]      --fetch-preconnect=<val>        Preconnect to a URL while code is loading
+- [ ]      --max-http-header-size=<val>    Set the maximum size of HTTP headers in bytes. Default is 16KiB
+- [ ]      --dns-result-order=<val>        Set the default order of DNS lookup results. Valid orders: verbatim (default), ipv4first, ipv6first
+- [ ]      --expose-gc                     Expose gc() on the global object. Has no effect on Bun.gc().
+- [ ]      --no-deprecation                Suppress all reporting of the custom deprecation.
+- [ ]      --throw-deprecation             Determine whether or not deprecation warnings result in errors.
+- [ ]      --title=<val>                   Set the process title
+- [ ]      --zero-fill-buffers             Boolean to force Buffer.allocUnsafe(size) to be zero-filled.
+- [ ]      --redis-preconnect              Preconnect to $REDIS_URL at startup
+- [ ]      --sql-preconnect                Preconnect to PostgreSQL at startup
+- [ ]      --no-addons                     Throw an error if process.dlopen is called, and disable export condition "node-addons"
+- [ ]      --unhandled-rejections=<val>    One of "strict", "throw", "warn", "none", or "warn-with-error-code"
+- [ ]      --console-depth=<val>           Set the default depth for console.log object inspection (default: 2)
+- [ ]      --silent                        Don't print the script command
+- [ ]      --elide-lines=<val>             Number of lines of script output shown when using --filter (default: 10). Set to 0 to show all lines.
+- [ ]  -v, --version                       Print version and exit
+- [ ]      --revision                      Print version with revision and exit
+- [ ]  -F, --filter=<val>                  Run a script in all workspace packages matching the pattern
+- [ ]  -b, --bun                           Force a script or package to use Bun's runtime instead of Node.js (via symlinking node)
+- [ ]      --shell=<val>                   Control the shell used for package.json scripts. Supports either 'bun' or 'system'
+- [ ]      --env-file=<val>                Load environment variables from the specified file(s)
+- [ ]      --cwd=<val>                     Absolute path to resolve files & entry points from. This just changes the process' cwd.
+- [ ]  -c, --config=<val>                  Specify path to Bun config file. Default $cwd/bunfig.toml
+- [ ]  -h, --help                          Display this menu and exit
 
 ## support
 

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

@@ -0,0 +1,47 @@
+/**
+ * USAGE EXAMPLES:
+ * - dler create react-app - creates a project from template (like bun create, pnpm create)
+ * - dler create --mode files - creates files from templates
+ * - dler create --mode files --fileType md:README - creates specific file type
+ * - dler create --mode files --multiple - creates multiple file types
+ */
+declare const _default: import("@reliverse/rempts").Command<{
+    template: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    mode: {
+        type: "string";
+        description: string;
+        allowed: string[];
+        default: string;
+    };
+    fileType: {
+        type: "string";
+        description: string;
+    };
+    destDir: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    multiple: {
+        type: "boolean";
+        description: string;
+    };
+    parallel: {
+        type: "boolean";
+        description: string;
+    };
+    concurrency: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    cwd: {
+        type: "string";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/create/cmd.js

@@ -0,0 +1,170 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand, multiselectPrompt, selectPrompt } 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 { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+export default defineCommand({
+  meta: {
+    name: "create",
+    version: "1.1.0",
+    description: "Create projects from templates or create files. Usage example: `dler create react-app` or `dler create --mode files`"
+  },
+  args: defineArgs({
+    template: {
+      type: "positional",
+      description: "Template name for project creation (e.g., react-app, next-app)",
+      required: false
+    },
+    mode: {
+      type: "string",
+      description: "Mode to use: template (default), files",
+      allowed: ["template", "files"],
+      default: "template"
+    },
+    fileType: {
+      type: "string",
+      description: "File type to create (e.g. 'md:README') - only for files mode"
+    },
+    destDir: {
+      type: "string",
+      description: "Destination directory",
+      default: "."
+    },
+    multiple: {
+      type: "boolean",
+      description: "Whether to select multiple file types from the library - only for files mode"
+    },
+    parallel: {
+      type: "boolean",
+      description: "Run tasks in parallel - only for files mode"
+    },
+    concurrency: {
+      type: "string",
+      description: "Concurrency limit if parallel is true - only for files mode",
+      default: "4"
+    },
+    cwd: {
+      type: "string",
+      description: "Current working directory"
+    }
+  }),
+  async run({ args }) {
+    const { template, mode, fileType, destDir, multiple, parallel, concurrency, cwd } = args;
+    if (mode === "files") {
+      await handleFileCreation({ fileType, destDir, multiple, parallel, concurrency });
+    } else {
+      await handleTemplateCreation({ template, destDir, cwd });
+    }
+  }
+});
+async function handleFileCreation({
+  fileType,
+  destDir,
+  multiple,
+  parallel,
+  concurrency
+}) {
+  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 create",
+      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 create",
+        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)}`);
+  }
+}
+async function handleTemplateCreation({
+  template,
+  destDir,
+  cwd
+}) {
+  if (!template) {
+    relinka.error("Template name is required for template creation");
+    relinka.log("Usage: dler create <template-name>");
+    relinka.log("Example: dler create react-app");
+    return process.exit(1);
+  }
+  try {
+    const workingDir = cwd || process.cwd();
+    const packageManager = await detectPackageManager(workingDir);
+    if (!packageManager) {
+      relinka.error("Cannot detect package manager. Defaulting to bun create.");
+    }
+    const pmName = packageManager?.name || "bun";
+    let createCommand;
+    switch (pmName) {
+      case "bun":
+        createCommand = ["bun", "create", template];
+        break;
+      case "pnpm":
+        createCommand = ["pnpm", "create", template];
+        break;
+      case "yarn":
+        createCommand = ["yarn", "create", template];
+        break;
+      case "npm":
+        createCommand = ["npm", "create", template];
+        break;
+      default:
+        createCommand = ["bun", "create", template];
+        break;
+    }
+    if (destDir !== ".") {
+      createCommand.push(destDir);
+    }
+    relinka.log(`Creating project from template: ${template}`);
+    relinka.log(`Using command: ${createCommand.join(" ")}`);
+    const result = x(createCommand[0], createCommand.slice(1), {
+      nodeOptions: {
+        cwd: workingDir,
+        stdio: "inherit"
+      },
+      throwOnError: true
+    });
+    const output = await result;
+    if (output.exitCode === 0) {
+      relinka.success(`Successfully created project from template: ${template}`);
+    } else {
+      relinka.error(`Failed to create project. Exit code: ${output.exitCode}`);
+      return process.exit(output.exitCode || 1);
+    }
+  } catch (error) {
+    relinka.error(
+      `Failed to create project from template: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return process.exit(1);
+  }
+}

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

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;

package/bin/app/init/cmd.js

@@ -0,0 +1,14 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+export default defineCommand({
+  meta: {
+    name: "init",
+    version: "1.0.0",
+    description: "Initialize a new project"
+  },
+  async run() {
+    relinka.info(
+      "Command not implemented yet. For now, please install `@reliverse/rse` and run `rse cli`."
+    );
+  }
+});

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

@@ -0,0 +1,50 @@
+/**
+ * USAGE EXAMPLES:
+ * - dler install package-name - installs a package
+ * - dler install - installs all dependencies
+ * - dler dedupe - deduplicates dependencies
+ */
+declare const _default: import("@reliverse/rempts").Command<{
+    action: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    name: {
+        type: "positional";
+        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;
+    };
+    linter: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/install/cmd.js

@@ -0,0 +1,83 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import {
+  addDependency,
+  dedupeDependencies,
+  installDependencies
+} from "../../libs/sdk/sdk-impl/utils/pm/pm-api.js";
+export default defineCommand({
+  meta: {
+    name: "install",
+    version: "1.1.0",
+    description: "Install dependencies or deduplicate existing ones. Usage example: `dler install package-name` or `dler install` or `dler dedupe`"
+  },
+  args: defineArgs({
+    action: {
+      type: "string",
+      description: "Action to perform: install, add, i, dedupe",
+      required: false,
+      default: "install"
+    },
+    name: {
+      type: "positional",
+      description: "Package name",
+      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)"
+    },
+    linter: {
+      type: "boolean",
+      description: "Run linter checks after updating dependencies",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    console.log("DEBUG: install command starting with args:", args);
+    const { action, name, linter, ...options } = args;
+    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 "dedupe": {
+        await dedupeDependencies(options);
+        break;
+      }
+      default: {
+        if (!action || action === "install") {
+          console.log("DEBUG: default install case, name:", name, "options:", options);
+          await (name ? addDependency(name, options) : installDependencies(options));
+        } else {
+          relinka.error(`Unknown action: ${action}`);
+          relinka.log("Available actions: install, add, i, dedupe");
+          return process.exit(1);
+        }
+      }
+    }
+  }
+});

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

@@ -0,0 +1,42 @@
+/**
+ * USAGE EXAMPLES:
+ * - dler remove package-name - removes a package
+ * - dler rm package-name - removes a package (alias)
+ * - dler uninstall package-name - removes a package (alias)
+ */
+declare const _default: import("@reliverse/rempts").Command<{
+    action: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    name: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    global: {
+        type: "boolean";
+        alias: string;
+        description: string;
+    };
+    cwd: {
+        type: "string";
+        description: string;
+    };
+    workspace: {
+        type: "boolean";
+        description: string;
+    };
+    silent: {
+        type: "boolean";
+        description: string;
+    };
+    linter: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/remove/cmd.js

@@ -0,0 +1,71 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { removeDependency } from "../../libs/sdk/sdk-impl/utils/pm/pm-api.js";
+export default defineCommand({
+  meta: {
+    name: "remove",
+    version: "1.1.0",
+    description: "Remove dependencies. Usage example: `dler remove package-name`"
+  },
+  args: defineArgs({
+    action: {
+      type: "string",
+      description: "Action to perform: remove, rm, uninstall, un, delete, del",
+      required: false,
+      default: "remove"
+    },
+    name: {
+      type: "positional",
+      description: "Package name",
+      required: true
+    },
+    global: {
+      type: "boolean",
+      alias: "g",
+      description: "Remove globally"
+    },
+    cwd: {
+      type: "string",
+      description: "Current working directory"
+    },
+    workspace: {
+      type: "boolean",
+      description: "Remove from workspace"
+    },
+    silent: {
+      type: "boolean",
+      description: "Run in silent mode"
+    },
+    linter: {
+      type: "boolean",
+      description: "Run linter checks after removing dependencies",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    const { action, name, linter, ...options } = args;
+    if (!name) {
+      relinka.error("Package name is required for remove action");
+      return process.exit(1);
+    }
+    switch (action) {
+      case "remove":
+      case "rm":
+      case "uninstall":
+      case "un":
+      case "delete":
+      case "del":
+        await removeDependency(name, options);
+        break;
+      default: {
+        if (!action || action === "remove") {
+          await removeDependency(name, options);
+        } else {
+          relinka.error(`Unknown action: ${action}`);
+          relinka.log("Available actions: remove, rm, uninstall, un, delete, del");
+          return process.exit(1);
+        }
+      }
+    }
+  }
+});

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

@@ -47,5 +47,17 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: false;
     };
+    linker: {
+        type: "string";
+        description: string;
+        allowed: string[];
+        default: string;
+    };
+    "no-install": {
+        type: "boolean";
+        description: string;
+        default: false;
+        alias: string;
+    };
 }>;
 export default _default;