@reliverse/dler 1.7.68 → 1.7.70

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) Nazar Kornienko (blefnk), Reliverse
+Copyright (c) Nazar Kornienko (blefnk), Bleverse, Reliverse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,147 +2,105 @@
 
 [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 (prev. relidler; `/ˈdiː.lər/`, dealer) is a unified package manager for typescript/javascript projects.
+> @reliverse/dler (formerly 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.
+> dler is your package manager’s best friend — it extends bun, deno (🔜), pnpm, yarn, and npm with powerful and modern features.
 >
-> 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.
+> at its core, dler is a flexible and fully automated bundler that also doubles as an npm/jsr publishing tool. beyond bundling, dler provides a rich codemod toolkit designed for modern typescript/javascript development.
 
 ## features
 
-- **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
-- **performance optimized** for speed with modern build pipelines and caching
-- **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
-- **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
-- **codemod toolkit** — powerful code transformation utilities built-in
-
-### 🎯 perfect for
-
-dler excels at managing both build and publish workflows, making it ideal for:
-
-- cli tool creators and maintainers
-- project bootstrappers (like [rse](https://github.com/reliverse/rse))
-- library authors seeking streamlined workflows
-- teams wanting consistent build processes
-
-### 🔜 coming soon
-
-**full monorepo system** with advanced dependency management and cross-package optimization.
-
-### supported bundlers
-
-- ✅ [mkdist](https://github.com/unjs/mkdist#readme)
-- ✅ jsr
-- 🏗️ copy
-- 🏗️ [bun](https://bun.sh/docs/bundler)
-- 🏗️ [rollup](https://rollupjs.org)
-- 🏗️ [untyped](https://untyped.unjs.io)
-- 🔜 [tsdown](https://rolldown.rs)
-- 🔜 copy (prev. jsr)
-
-**legend**:
-
-- ✅ well tested with big projects
-- 🏗️ not well tested yet
-- 🔜 coming soon
+- **drop-in `unjs/unbuild` support** with extended capabilities like publishing
+- **automated publishing** to npm and jsr with smart workflow orchestration
+- **reliable builds** with robust typescript/javascript support and error handling
+- **smart versioning** with semantic release and automatic version bumping
+- **zero-config setup** — forget about `package.json` maintenance
+- **built-in bun environment** when used as a standalone cli app
+- **performance-optimized** using fast build pipelines and aggressive caching
+- **17 built-in commands** — see [dler commands](#dler-commands) for everything it can do
+- **path alias resolution** — automatically rewrites tsconfig aliases to relative imports
+- **configurable by design** — dedicated config files with sane defaults
+- **dual interface** — use via cli or import as sdk for programmatic use
+- **clean dist output** — strips internal logs and debug code automatically
+- **monorepo support** with experimental `libs` mode for multi-library setups
+- **magic spells** — plugin system for custom build logic and extensions
+- **codemod toolkit** — powerful code transformation utilities out of the box
+- **full monorepo system** with optimized cross-package dependency handling
+- **esp. designed for** cli tool creators, project bootstrappers (like [rse](https://github.com/reliverse/rse))
+- **perfect for** anyone who wants their package manager to have *sweet powers*
 
 ## getting started
 
-make sure you have git, node.js, and bun/pnpm/yarn/npm (**[bun](https://bun.sh/get) is highly recommended**) are installed. then:
+before using dler, make sure you have [git](https://git-scm.com/downloads), [node.js](https://nodejs.org/en/download), and a supported package manager installed — **[bun](https://bun.sh/get) is highly recommended** for the best experience.
 
 ### 0. try the playground
 
-> **💡 tip**:
-> want to test dler before integrating it into your project?
-> clone the dler repo and build it using dler itself!
+> 💡 **tip**
+> curious to see dler in action before integrating it into your project?
+> clone the repo and try e.g. `bun dler build` to build dler using... dler itself!
 
 ```sh
 git clone https://github.com/reliverse/dler.git
 cd dler
 bun i
-bun dev # bun src/cli.ts --dev
+bun dler build # runs dler from source (cli entry: src/cli.ts)
 ```
 
 ### 1. install dler
 
-**install as dev dep (recommended)**:
-
-```sh
-bun add -D @reliverse/dler
-# or update as needed:
-bun update --latest
-```
+it is recommended to install dler both globally and as a dev dependency:
 
-**and/or install globally**:
+- **global install** — `bun add -g @reliverse/dler` — lets you use dler anywhere, like a system-level cli.
+- **dev dependency** — `bun add -D @reliverse/dler` — pins the version per project, so all contributors use the same version.
 
-```sh
-bun add -g @reliverse/dler
-# or update as needed:
-bun i -g update --latest
-```
+instead of global install, you can alternatively install dler as a standalone binary: `bunx @reliverse/dler `
 
-- **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**: ...
+> usage depends on how dler is installed:
+>
+> - `dler` → if installed globally (or as standalone binary)
+> - `bun dler` → if installed as a dev dependency
 
-### 2. prepare your project
+### 2. initialize dler config
 
-a. **configure `.gitignore`**:
+first-time dler run initializes config, repeatable runs launches dler interactive menu.
 
 ```sh
-echo "dist*" >> .gitignore
-echo "logs" >> .gitignore
+bun dler # if installed locally
+dler     # if installed globally
 ```
 
-b. **add `".config/**/*.ts"` to `include` in `tsconfig.json`**:
-
-```json
-"include": [".config/**/*.ts", ...]
-```
+this creates a starter config file: `.config/dler.ts`
 
-c. **package.json**:
+- it is recommended to tweak the config to match your project structure
+- example config: [.config/dler.ts →](https://github.com/reliverse/dler/blob/main/.config/dler.ts)
+- useful options:
 
-```json
-"scripts": {
-  "build": "dler build", // this is optional
-  "pub": "dler pub" // this does build+publish
-}
-```
+  - `buildPreExtensions`: support additional file types like `["ts", "js", "vue", "tsx", "jsx"]`
+  - `buildTemplatesDir`: exclude a directory from being built; it will be copied as-is (e.g. `src/foo/templates → dist-*/bin/foo/templates`)
 
-d. **initialize config**:
+### 3. run and enjoy
 
 ```sh
-bun dler # if installed as dev dep
-dler # if installed globally
+bun dler [build|pub|--help] # if local
+dler [build|pub|--help]     # if global
 ```
 
-- the `.config/dler.ts` file is automatically created on first run.
+> 💡 run `dler` for an interactive menu, or `dler --help` for full command list.
 
-e. **optionally, customize `.config/dler.ts`**:
+### 4. upgrade your dev tools
 
-- it's recommended to customize this file according to your needs.
-- you can check an example config here: [.config/dler.ts](https://github.com/reliverse/dler/blob/main/.config/dler.ts)
-- if you want to build files which have extensions other than `.ts` and `.js`, you can customize `buildPreExtensions` array (example: `["ts", "js", "vue", "tsx", "jsx"]`).
-- if you want to exclude some files from being built, you can customize `buildTemplatesDir` string (example: `"templates"`). by placing them in this directory, they will not be built, whole directory will be copied from e.g. `src/foo/templates` to `dist-*/bin/foo/templates` as-is.
+keeping your tools fresh is always a good practice.
 
-### 3. run and enjoy
+the command below **upgrades not just dler**, but also your local setup — including `git`, `node.js`, `bun`, `npm`, `yarn`, `pnpm`, and more.
+
+just run:
 
 ```sh
-bun dler [build|pub|--help] # if installed as dev dep
-dler [build|pub|--help] # if installed globally
+bun dler upgrade
 ```
 
-(_run just `dler` to see an interactive list of commands_)
+> ⚠️ don’t confuse this with `dler update`, which upgrades your **project dependencies** and **global packages**, not your system tools.
+> 👉 *note:* both `upgrade` and `update` will update **dler** itself — globally and in your `dependencies` or `devDependencies` if run inside a project with a `package.json` — depends on how dler is installed.
 
 ## dler commands
 
@@ -164,6 +122,23 @@ since dler is fully modular, build command is separated for its own build-in plu
 bun dler build ...
 ```
 
+### supported bundlers
+
+- ✅ [mkdist](https://github.com/unjs/mkdist#readme)
+- ✅ jsr
+- 🏗️ copy
+- 🏗️ [bun](https://bun.sh/docs/bundler)
+- 🏗️ [rollup](https://rollupjs.org)
+- 🏗️ [untyped](https://untyped.unjs.io)
+- 🔜 [tsdown](https://rolldown.rs)
+- 🔜 copy (prev. jsr)
+
+**legend**:
+
+- ✅ well tested with big projects
+- 🏗️ not well tested yet
+- 🔜 coming soon
+
 #### 1.1. `build binary` - Standalone Executable Builder
 
 creates standalone executables for different platforms using bun's `--compile` feature.
@@ -960,6 +935,81 @@ 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
+- [ ] fully support deno and jsr
+
+### 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/build/cmd.js

@@ -1,6 +1,5 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerBuild } from "./impl.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
 import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
 import { finalizeBuild } from "../../libs/sdk/sdk-mod.js";
 export default defineCommand({
@@ -24,7 +23,6 @@ export default defineCommand({
   }),
   async run({ args }) {
     const isDev = args.dev || process.env.DLER_DEV_MODE === "true";
-    await ensureDlerConfig(isDev);
     const config = await getConfigDler();
     const { timer } = await dlerBuild(
       isDev,

package/bin/app/cmds.d.ts

@@ -16,3 +16,4 @@ export declare const getMagicCmd: () => Promise<Command>;
 export declare const getSplitCmd: () => Promise<Command>;
 export declare const getRmCmd: () => Promise<Command>;
 export declare const getUpdateCmd: () => Promise<Command>;
+export declare const getUpgradeCmd: () => Promise<Command>;

package/bin/app/cmds.js

@@ -16,3 +16,4 @@ export const getMagicCmd = async () => loadCommand("magic");
 export const getSplitCmd = async () => loadCommand("split");
 export const getRmCmd = async () => loadCommand("rm");
 export const getUpdateCmd = async () => loadCommand("update");
+export const getUpgradeCmd = async () => loadCommand("upgrade");

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/get/cmd.d.ts

@@ -0,0 +1 @@
+export { default } from "../../libs/get/mod.js";

package/bin/app/get/cmd.js

@@ -0,0 +1 @@
+export { default } from "../../libs/get/mod.js";

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;