@reliverse/dler 1.2.6 → 1.3.1

package/README.md

@@ -51,7 +51,7 @@ ensure git, node.js, and bun/pnpm/yarn/npm are installed. then:
 git clone https://github.com/reliverse/dler.git
 cd dler
 bun i
-bun dev # bun src/mod.ts --dev
+bun dev # bun src/dler.ts --dev
 ```
 
 ### installation
@@ -66,6 +66,14 @@ bun dev # bun src/mod.ts --dev
     bun update --latest
     ```
 
+    **and/or install globally**:
+
+    ```sh
+    bun add -g @reliverse/dler
+    # or update as needed:
+    bun i -g update --latest
+    ```
+
 2. **prepare your project**:
 
     a. **configure `.gitignore`**:
@@ -75,19 +83,13 @@ bun dev # bun src/mod.ts --dev
     echo "logs" >> .gitignore
     ```
 
-    b. **install config intellisense**:
-
-    ```sh
-    bun add -d @reliverse/dler-cfg
-    ```
-
-    c. **add `".config/**/*.ts"` to `include` in `tsconfig.json`**:
+    b. **add `".config/**/*.ts"` to `include` in `tsconfig.json`**:
 
     ```json
     "include": [".config/**/*.ts", ...]
     ```
 
-    d. **package.json**:
+    c. **package.json**:
 
     ```json
     "scripts": {
@@ -96,7 +98,7 @@ bun dev # bun src/mod.ts --dev
     }
     ```
 
-    e. **initialize config**:
+    d. **initialize config**:
 
     ```sh
     bun [build|pub] # if installed as dev dep
@@ -114,18 +116,37 @@ bun dev # bun src/mod.ts --dev
     dler [build|pub] # if installed globally
     ```
 
-## 🔌 plugins
+## 🔌 addons
+
+dler ships with a flexible addon system (aka plugins) and **14 built-in addons** (from [@reliverse/addons](https://reliverse.org/addons)).
+
+feel free to create your own addons. addons can be implemented as built-in directly in `src/app/<addon>/impl/*` and then imported from `src/app/<addon>/cmd.ts`; or implemented in your own library and then imported from `src/app/<addon>/cmd.ts`.
+
+if you run just `dler` — it will display a list of addons which you can launch interactively.
 
-dler ships with a flexible plugin system and **14 built-in plugins** (from [@reliverse/addons](https://reliverse.org/addons)).
+## **available addons**
 
-feel free to create your own plugins. plugins can be implemented as built-in directly in `src/app/plugin-name/impl/*` and then imported from `src/app/plugin-name/cmd.ts`; or implemented in your own library and then imported from `src/app/plugin-name/cmd.ts`.
+[agg](#1-agg), [build](#2-build), [conv](#3-conv), [deps](#4-deps), [inject](#5-inject), [libs](#6-libs), [merge](#7-merge), [mono](#8-mono), [pub](#9-pub), [relifso](#10-relifso), [relinka](#11-relinka), [rempts](#12-rempts), [spell](#13-spell), [split](#14-split).
 
 ### 1. `agg`
 
 generates aggregator file with content like `import { getsomething } from "./utils.js"`.
 
 ```bash
-dler agg ...
+# interactively:
+dler > "agg"
+# non-interactively:
+dler agg --input <dir> --out <file> [options]
+```
+
+**usage example**: if you're exploring the example [playground](#playground), you can try the following:
+
+1. open [src/libs/sdk/sdk-mod.ts](https://github.com/reliverse/dler/blob/main/src/libs/sdk/sdk-mod.ts) in your ide.
+2. press `ctrl+a`, then `backspace`. run the command below and watch the magic happen:
+
+```bash
+bun tools:agg # shortcut for:
+bun src/dler.ts tools --dev --tool agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-mod.ts --recursive --named --strip src/libs/sdk
 ```
 
 ### 2. `build`
@@ -196,7 +217,7 @@ not yet documented.
 builds and publishes specific subdirectories of your main project as standalone packages.
 
 **usage example**:  
-using `@reliverse/dler-cfg` to package [src/libs/cfg](https://github.com/reliverse/dler/tree/main/src/libs/cfg):
+using `dler` to package [src/libs/sdk](https://github.com/reliverse/dler/tree/main/src/libs/sdk):
 
 ```ts
 // .config/dler.ts
@@ -204,11 +225,11 @@ libsactmode: "main-and-libs",
 libsdirdist: "dist-libs",
 libsdirsrc: "src/libs",
 libslist: {
-  "@reliverse/dler-cfg": {
+  "@reliverse/dler-sdk": {
     libdeclarations: true,
-    libdescription: "@reliverse/dler defineconfig",
-    libdirname: "cfg",
-    libmainfile: "cfg/cfg-mod.ts",
+    libdescription: "@reliverse/dler without cli",
+    libdirname: "sdk",
+    libmainfile: "sdk/sdk-mod.ts",
     libpkgkeepdeps: false,
     libtranspileminify: true,
   },
@@ -326,26 +347,12 @@ await dler.spell({ spells: ["rename-file"], files: [] });
 
 p.s. [see how rse cli uses hooked=true](https://github.com/reliverse/rse/blob/main/src/postbuild.ts)
 
-### 14. `tools`
-
-lets you run standalone dler features directly from the cli:
-
-```bash
-dler tools --tool <tool> --input <dir> --out <file> [options]
-```
-
-**available tools**:
-
-- `agg`: generates aggregator file with content like `export { getsomething } from "./utils.js"`. **note**: currently it replaces the file content, not appends.
-
-**usage example**: if you're exploring the example [playground](#playground), you can try the following:
+### 14. `split`
 
-1. open [src/libs/sdk/sdk-mod.ts](https://github.com/reliverse/dler/blob/main/src/libs/sdk/sdk-mod.ts) in your ide.
-2. press `ctrl+a`, then `backspace`. run the command below and watch the magic happen:
+splits your code/text file into multiple files.
 
 ```bash
-bun tools:agg # shortcut for:
-bun src/mod.ts tools --dev --tool agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-mod.ts --recursive --named --strip src/libs/sdk
+dler split ...
 ```
 
 ## api (for advanced users)

package/bin/addons.d.ts

@@ -0,0 +1 @@
+export declare function promptAggCommand(): Promise<void>;

package/bin/addons.js

@@ -0,0 +1,83 @@
+import {
+  selectPrompt,
+  runCmd,
+  confirmPrompt,
+  inputPrompt
+} from "@reliverse/rempts";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { cmdAgg } from "./app/cmds.js";
+async function loadConfig() {
+  const configPath = resolve(".config/dler.ts");
+  if (!existsSync(configPath)) return null;
+  return (await import(configPath)).default;
+}
+export async function promptAggCommand() {
+  const config = await loadConfig();
+  let selectedLibName = null;
+  if (config?.libsList && Object.keys(config.libsList).length > 0) {
+    const libs = Object.entries(config.libsList).map(([name, lib]) => ({
+      value: name,
+      label: name,
+      hint: `${config.libsDirSrc}/${lib.libDirName}/${lib.libDirName}-impl`
+    }));
+    libs.push({ value: "", label: "Skip library selection", hint: "" });
+    selectedLibName = await selectPrompt({
+      title: "Select a library to aggregate or skip",
+      options: libs
+    });
+  }
+  let imports = false;
+  let input = "";
+  let named = true;
+  let out = "";
+  let recursive = true;
+  let strip = "";
+  if (selectedLibName && selectedLibName !== "") {
+    const libConfig = config?.libsList?.[selectedLibName];
+    if (config && libConfig) {
+      input = `${config.libsDirSrc}/${libConfig.libDirName}/${libConfig.libDirName}-impl`;
+      out = `${config.libsDirSrc}/${libConfig.libMainFile}`;
+      strip = `${config.libsDirSrc}/${libConfig.libDirName}`;
+    }
+  }
+  if (!selectedLibName || !input) {
+    input = await inputPrompt({
+      title: "Enter the input directory",
+      defaultValue: input
+    });
+  }
+  imports = await confirmPrompt({
+    title: "Do you want to generate imports instead of exports?",
+    content: "(N generates exports)",
+    defaultValue: imports
+  });
+  named = await confirmPrompt({
+    title: imports ? "Do you want to generate named imports?" : "Do you want to generate named exports?",
+    defaultValue: named
+  });
+  if (!selectedLibName || !out) {
+    out = await inputPrompt({
+      title: "Enter the output file",
+      defaultValue: out
+    });
+  }
+  recursive = await confirmPrompt({
+    title: "Do you want to recursively scan subdirectories?",
+    defaultValue: recursive
+  });
+  if (!selectedLibName || !strip) {
+    strip = await inputPrompt({
+      title: "Enter the path to strip from the final imports/exports",
+      defaultValue: strip
+    });
+  }
+  await runCmd(await cmdAgg(), [
+    `--imports=${imports}`,
+    `--input=${input}`,
+    `--named=${named}`,
+    `--out=${out}`,
+    `--recursive=${recursive}`,
+    `--strip=${strip}`
+  ]);
+}

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

@@ -0,0 +1,35 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    dev: {
+        description: string;
+        type: "boolean";
+    };
+    imports: {
+        description: string;
+        type: "boolean";
+    };
+    input: {
+        description: string;
+        type: "string";
+        required: true;
+    };
+    named: {
+        description: string;
+        type: "boolean";
+        default: true;
+    };
+    out: {
+        description: string;
+        type: "string";
+        required: true;
+    };
+    recursive: {
+        description: string;
+        type: "boolean";
+        default: true;
+    };
+    strip: {
+        description: string;
+        type: "string";
+    };
+}>;
+export default _default;

package/bin/app/agg/cmd.js

@@ -0,0 +1,49 @@
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import path from "pathe";
+import { useAggregator } from "./impl.js";
+export default defineCommand({
+  args: defineArgs({
+    dev: {
+      description: "Run in development mode",
+      type: "boolean"
+    },
+    imports: {
+      description: "If true, produce import lines instead of export lines",
+      type: "boolean"
+    },
+    input: {
+      description: "Directory containing .ts/.js files (--input <directory>)",
+      type: "string",
+      required: true
+    },
+    named: {
+      description: "Parse each file for named exports (function/class/const/let)",
+      type: "boolean",
+      default: true
+    },
+    out: {
+      description: "Output aggregator file path (--out <fileName>)",
+      type: "string",
+      required: true
+    },
+    recursive: {
+      description: "Recursively scan subdirectories (default false)",
+      type: "boolean",
+      default: true
+    },
+    strip: {
+      description: "Remove specified path prefix from final imports/exports",
+      type: "string"
+    }
+  }),
+  async run({ args }) {
+    await useAggregator({
+      inputDir: path.resolve(args.input),
+      isRecursive: !!args.recursive,
+      outFile: path.resolve(args.out),
+      stripPrefix: args.strip ? path.resolve(args.strip) : "",
+      useImport: !!args.imports,
+      useNamed: !!args.named
+    });
+  }
+});

package/bin/app/agg/impl.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Aggregator supporting:
+ * - --import or default export,
+ * - star or named exports,
+ * - separate "type" vs "value" for both import and export.
+ *
+ * Options:
+ * - Option to ignore specific directories (default: node_modules, .git)
+ * - Option to sort aggregated lines alphabetically.
+ * - Option to add a header comment in the aggregator output.
+ * - Option to enable verbose logging.
+ * - Deduplicates overloaded export names.
+ * - Skips files whose basenames start with an internal marker (default: "#")
+ *   unless includeInternal is true or an alternative marker is provided.
+ * - By default, updates only the auto-generated block in the aggregator file,
+ *   leaving any other content intact. Pass `overrideFile: true` to rewrite the entire file.
+ */
+export declare function useAggregator({ inputDir, isRecursive, outFile, stripPrefix, useImport, useNamed, ignoreDirs, sortLines, headerComment, verbose, includeInternal, internalMarker, overrideFile, }: {
+    inputDir: string;
+    isRecursive: boolean;
+    outFile: string;
+    stripPrefix: string;
+    useImport: boolean;
+    useNamed: boolean;
+    ignoreDirs?: string[];
+    sortLines?: boolean;
+    headerComment?: string;
+    verbose?: boolean;
+    includeInternal?: boolean;
+    internalMarker?: string;
+    overrideFile?: boolean;
+}): Promise<void>;
+/**
+ * Prints usage examples based on whether dev mode or not.
+ */
+export declare function printUsage(isDev?: boolean): void;

package/bin/app/{tools → agg}/impl.js

@@ -124,8 +124,7 @@ ${aggregatorBlock}`;
     await fs.writeFile(outFile, finalText, "utf8");
     relinka(
       "success",
-      `Aggregator done: processed ${allLines.length} lines in:
-  ${outFile}`
+      `Aggregator done: processed ${allLines.length} lines in: ${outFile}`
     );
   } catch (error) {
     relinka("error", `Aggregator failed: ${error}`);

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

@@ -0,0 +1,7 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/build/cmd.js

@@ -1,5 +1,6 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { dlerBuild } from "../../cli.js";
+import { dlerBuild } from "../../impl.js";
+import { ensureDlerConfig } from "../../init.js";
 export default defineCommand({
   meta: {
     name: "build",
@@ -12,6 +13,7 @@ export default defineCommand({
     }
   }),
   async run({ args }) {
+    await ensureDlerConfig(args.dev);
     await dlerBuild(args.dev);
   }
 });

package/bin/app/cmds.d.ts

@@ -0,0 +1,100 @@
+export declare function cmdRelifsoInit(): Promise<import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+    fileType: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+    destDir: {
+        type: "string";
+        description: string;
+        default: string;
+        required: false;
+    };
+    multiple: {
+        type: "boolean";
+        description: string;
+        required: false;
+        default: false;
+    };
+    parallel: {
+        type: "boolean";
+        description: string;
+        required: false;
+        default: false;
+    };
+    concurrency: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+}>>;
+export declare function cmdInjectExpect(): Promise<import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+    files: {
+        type: "positional";
+        description: string;
+        default: string;
+    };
+    comment: {
+        type: "string";
+        description: string;
+    };
+    tscPaths: {
+        type: "string";
+        description: string;
+    };
+}>>;
+export declare function cmdAgg(): Promise<import("@reliverse/rempts").Command<{
+    dev: {
+        description: string;
+        type: "boolean";
+    };
+    imports: {
+        description: string;
+        type: "boolean";
+    };
+    input: {
+        description: string;
+        type: "string";
+        required: true;
+    };
+    named: {
+        description: string;
+        type: "boolean";
+        default: true;
+    };
+    out: {
+        description: string;
+        type: "string";
+        required: true;
+    };
+    recursive: {
+        description: string;
+        type: "boolean";
+        default: true;
+    };
+    strip: {
+        description: string;
+        type: "string";
+    };
+}>>;
+export declare function cmdBuild(): Promise<import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+}>>;
+export declare function cmdPub(): Promise<import("@reliverse/rempts").Command<{
+    dev: {
+        type: "boolean";
+        description: string;
+    };
+}>>;

package/bin/app/cmds.js

@@ -1,6 +1,15 @@
-export async function getCmdRelifsoInit() {
+export async function cmdRelifsoInit() {
   return (await import("./relifso/init/cmd.js")).default;
 }
-export async function getCmdInjectTsExpectError() {
+export async function cmdInjectExpect() {
   return (await import("./inject/expect/cmd.js")).default;
 }
+export async function cmdAgg() {
+  return (await import("./agg/cmd.js")).default;
+}
+export async function cmdBuild() {
+  return (await import("./build/cmd.js")).default;
+}
+export async function cmdPub() {
+  return (await import("./pub/cmd.js")).default;
+}

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

@@ -0,0 +1,28 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    directory: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    all: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    ignore: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    builtins: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/deps/cmd.js

@@ -0,0 +1,62 @@
+import { re } from "@reliverse/relico";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import path from "pathe";
+import { analyzeDependencies } from "./impl/analyzer.js";
+import { formatOutput } from "./impl/formatter.js";
+export default defineCommand({
+  meta: {
+    name: "deps",
+    version: "1.0.0",
+    description: "Find dependencies used but not listed in package.json"
+  },
+  args: defineArgs({
+    directory: {
+      type: "string",
+      description: "directory to scan (defaults to current directory)",
+      default: "."
+    },
+    all: {
+      type: "boolean",
+      description: "show all dependencies (both listed and not listed)",
+      default: false
+    },
+    ignore: {
+      type: "string",
+      description: "comma-separated patterns to ignore",
+      default: ""
+    },
+    json: {
+      type: "boolean",
+      description: "output in JSON format",
+      default: false
+    },
+    builtins: {
+      type: "boolean",
+      description: "include Node.js built-in modules in the output",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    try {
+      const directory = path.resolve(args.directory);
+      const ignorePatterns = args.ignore ? args.ignore.split(",") : [];
+      const options = {
+        directory,
+        showAll: args.all,
+        ignorePatterns,
+        json: args.json,
+        builtins: args.builtins
+      };
+      console.log(re.gray(`Scanning directory: ${directory}`));
+      const result = await analyzeDependencies(options);
+      const output = formatOutput(result, options);
+      console.log(output);
+      if (result.missingDependencies.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error("Error:", error);
+      process.exit(1);
+    }
+  }
+});

package/bin/app/deps/impl/analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyResult, FinderOptions } from "./types.js";
+export declare const analyzeDependencies: (options: FinderOptions) => Promise<DependencyResult>;

package/bin/app/deps/impl/analyzer.js

@@ -25,7 +25,7 @@ export const analyzeDependencies = async (options) => {
   for (const dependency of allDependencies) {
     if (!listedDependencies.has(dependency)) {
       if (builtinModules.has(dependency)) {
-        if (options.includeBuiltins) {
+        if (options.builtins) {
           builtinModulesList.push(dependency);
         }
       } else {

package/bin/app/deps/impl/filesystem.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson } from "./types.js";
+export declare const findSourceFiles: (directory: string, ignorePatterns: string[]) => Promise<string[]>;
+export declare const readFile: (filePath: string) => Promise<string>;
+export declare const readPackageJson: (directory: string) => Promise<PackageJson>;

package/bin/app/deps/impl/filesystem.js

@@ -1,8 +1,6 @@
+import fs from "fs-extra";
 import { glob } from "glob";
-import fs from "node:fs";
 import path from "node:path";
-import util from "node:util";
-const readFileAsync = util.promisify(fs.readFile);
 export const findSourceFiles = async (directory, ignorePatterns) => {
   const pattern = `${directory}/**/*.{js,jsx,ts,tsx}`;
   const defaultIgnores = [
@@ -24,7 +22,7 @@ export const findSourceFiles = async (directory, ignorePatterns) => {
 };
 export const readFile = async (filePath) => {
   try {
-    return await readFileAsync(filePath, "utf8");
+    return await fs.readFile(filePath, "utf8");
   } catch (error) {
     console.error(`Error reading file ${filePath}:`, error);
     return "";

package/bin/app/deps/impl/formatter.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyResult, FinderOptions } from "./types.js";
+export declare const formatOutput: (result: DependencyResult, options: FinderOptions) => string;

package/bin/app/deps/impl/formatter.js

@@ -13,7 +13,7 @@ export const formatOutput = (result, options) => {
 `;
   output += `${chalk.gray("\u2022 ")}Missing from package.json: ${result.missingDependencies.length}
 `;
-  if (options.includeBuiltins) {
+  if (options.builtins) {
     output += `${chalk.gray("\u2022 ")}Node.js built-in modules: ${result.builtinModules.length}
 `;
   }
@@ -34,7 +34,7 @@ export const formatOutput = (result, options) => {
   } else {
     output += chalk.bold.green("No missing dependencies found! \u{1F389}\n\n");
   }
-  if (options.includeBuiltins && result.builtinModules.length > 0) {
+  if (options.builtins && result.builtinModules.length > 0) {
     output += chalk.bold.blue("Node.js Built-in Modules Used:\n");
     for (const dep of result.builtinModules) {
       output += `${chalk.gray("\u2022 ")}${chalk.blue(dep)}

package/bin/app/deps/impl/parser.d.ts

@@ -0,0 +1,5 @@
+import type { PackageJson } from "./types.js";
+export declare const extractPackageNames: (fileContent: string) => Set<string>;
+export declare const normalizePackageName: (importPath: string) => string | null;
+export declare const getListedDependencies: (packageJson: PackageJson) => Set<string>;
+export declare const getBuiltinModules: () => Set<string>;