@reliverse/dler 1.2.0

package/bin/cli/args/merger/README.md

@@ -0,0 +1,125 @@
+# @reliverse/remege
+
+[📦 NPM](https://npmjs.com/package/@reliverse/remege) • [🌌 GitHub](https://github.com/reliverse/remege)
+
+> @reliverse/remege is a tool to merge multiple text/code files into a single file or output stream. Skips binaries, adds optional path footers, supports CI & interactive mode. Built with love for developers who like clean structure.
+
+## Features
+
+- 🧠 Smart filtering: skips binary/media files automatically
+- 🧩 Flexible output: write to file or stream to `stdout`
+- 💬 Optional footer: add a comment with the relative path after each file
+- 🛠️ CI-friendly: use `--batch` to disable all prompts
+- 📜 Comment-aware: supports language-specific footer prefixes
+- 🪄 Interactive prompts if args are missing
+- 🔁 Custom separators between sections (e.g. `\n`, `\t`, blank lines, etc.)
+
+## Installation
+
+- You can run it via `bunx`: `bunx @reliverse/remege` (usage: `bunx @reliverse/remege --help`)
+- Or by installing globally: `bun i -g @reliverse/remege` (usage: `remege --help`)
+- Or install locally: `bun add -D @reliverse/remege` (usage: `bun remege --help`)
+
+## Tip
+
+You can automate the process by adding a script to your `package.json`:
+
+```json
+"scripts": {
+  // remege | bunx @reliverse/remege
+  "merge": "remege --in src/**/*.ts --out dist/combined.ts"
+}
+```
+
+## Usage
+
+Use it interactively:
+
+```bash
+remege
+```
+
+Or via command line flags:
+
+```bash
+remege \
+  --in "src/**/*.ts" \
+  --ignore "**/*.test.ts" \
+  --out dist/merged.txt \
+  --separator "\n\n" \
+  --comment "// "
+```
+
+## Options
+
+| Flag              | Type      | Description |
+|------------------|-----------|-------------|
+| `--in`            | `string[]` | Input glob patterns (comma-separated or repeated) |
+| `--ignore`        | `string[]` | Extra ignore patterns |
+| `--out`           | `string`   | Output file path |
+| `--stdout`        | `boolean`  | Print merged result to stdout |
+| `--separator`     | `string`   | Custom separator between sections (default: `\n\n`) |
+| `--comment`       | `string`   | Custom comment prefix (e.g. `#`, `//`) |
+| `--forceComment`  | `boolean`  | Use your custom comment for **all** file types |
+| `--noPath`        | `boolean`  | Skip path footer (don't show file path after each section) |
+| `--format`        | `string`   | Fallback extension for autogenerated file (default: `txt`) |
+| `--batch`         | `boolean`  | Disable prompts (non-interactive mode) |
+
+## How It Works
+
+- You provide `--in` globs like `src/**/*.ts`
+- Optionally ignore files via `--ignore`
+- All matching files are collected (except binaries)
+- Each section is appended into the final output, optionally with a path footer like:
+
+```ts
+// relative/path/to/file.ts
+```
+
+## Example
+
+```bash
+bunx @reliverse/remege --in "src/**/*.js" --stdout --noPath
+```
+
+Will print all JS files in `src` to the terminal, separated by blank lines, without paths.
+
+## Custom Separator Examples
+
+```bash
+--separator "\n\n"    # double newline
+--separator "\n---\n" # markdown-style break
+--separator "\n// -----\n" # JS-style
+```
+
+> Use escaped characters like `\n`, `\t`. These will be converted to newlines, tabs, etc.
+
+## Binary Files That Are Skipped
+
+File types like images, videos, fonts, compressed archives, and executables are skipped by default:
+
+- `.png`, `.jpg`, `.gif`, `.mp4`, `.mp3`, `.pdf`, `.zip`, `.exe`, `.woff`, `.jar`, etc.
+
+## Language-Specific Comment Prefixes
+
+These are automatically selected based on file extensions:
+
+| Ext   | Comment |
+|-------|---------|
+| `ts`  | `//`   |
+| `py`  | `#`    |
+| `html`| `<!--` |
+| `sql` | `--`   |
+| `css` | `/*`   |
+
+You can override using `--comment`.
+
+## Use Cases Examples
+
+- You want to send the contents of several files to AI
+- Collecting code snippets into a teaching demo
+- Merging many markdown files into a single file
+
+## License
+
+💖 2025 MIT [blefnk Nazar Kornienko](https://github.com/blefnk)

package/bin/cli/args/merger/main.txt

@@ -0,0 +1,306 @@
+import { glob } from "@reliverse/reglob";
+import { readFile, writeFile, ensureDir } from "@reliverse/relifso";
+import {
+  defineCommand,
+  runMain,
+  inputPrompt,
+  confirmPrompt,
+} from "@reliverse/rempts";
+import path from "@reliverse/repath";
+
+// ---------- constants ----------
+
+// always-ignored directories
+const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"] as const;
+
+// binary / media extensions (stored in a Set for O(1) lookups)
+const BINARY_EXTS = [
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "bmp",
+  "webp",
+  "svg",
+  "ico",
+  "mp4",
+  "mov",
+  "avi",
+  "mkv",
+  "mp3",
+  "wav",
+  "flac",
+  "ogg",
+  "pdf",
+  "zip",
+  "gz",
+  "tar",
+  "rar",
+  "7z",
+  "exe",
+  "dll",
+  "bin",
+  "woff",
+  "woff2",
+  "ttf",
+  "eot",
+  "class",
+  "jar",
+] as const;
+const BINARY_SET = new Set<string>(BINARY_EXTS);
+
+// known comment prefixes per extension
+const COMMENT_MAP: Record<string, string> = {
+  js: "// ",
+  jsx: "// ",
+  ts: "// ",
+  tsx: "// ",
+  c: "// ",
+  cpp: "// ",
+  h: "// ",
+  java: "// ",
+  go: "// ",
+  kt: "// ",
+  swift: "// ",
+  rs: "// ",
+  cs: "// ",
+  json: "// ",
+  proto: "// ",
+  dart: "// ",
+  py: "# ",
+  rb: "# ",
+  sh: "# ",
+  pl: "# ",
+  r: "# ",
+  yml: "# ",
+  yaml: "# ",
+  sql: "-- ",
+  lua: "-- ",
+  css: "/* ",
+  scss: "/* ",
+  less: "/* ",
+  html: "<!-- ",
+  htm: "<!-- ",
+  xml: "<!-- ",
+  md: "<!-- ",
+};
+
+const DEFAULT_COMMENT = "// ";
+const DEFAULT_SEPARATOR_RAW = "\\n\\n"; // two newlines (escaped form)
+
+// ---------- helpers ----------
+
+const isBinaryExt = (file: string) => {
+  const ext = path.extname(file).slice(1).toLowerCase();
+  return BINARY_SET.has(ext);
+};
+
+const ensureTrailingNL = (s: string) => (s.endsWith("\n") ? s : `${s}\n`);
+
+const parseCSV = (s: string) =>
+  s
+    .split(",")
+    .map((t) => t.trim())
+    .filter(Boolean);
+
+const unescape = (s: string) => s.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+
+// prompt wrappers that honour batch mode
+const maybePrompt = async <T>(
+  batch: boolean,
+  value: T | undefined,
+  promptFn: () => Promise<T>,
+): Promise<T | undefined> => {
+  if (batch || value !== undefined) return value;
+  return promptFn();
+};
+
+// collect and pre-filter files (dedup + binary skip early)
+const collectFiles = async (include: string[], extraIgnore: string[]) => {
+  const files = await glob(include, {
+    ignore: [...DEFAULT_IGNORES, ...extraIgnore],
+    absolute: true,
+  });
+  return [...new Set(files)].filter((f) => !isBinaryExt(f)).sort();
+};
+
+const readSections = async (
+  files: string[],
+  injectPath: boolean,
+  getPrefix: (f: string) => string,
+) => {
+  const cwd = process.cwd();
+  const reads = files.map(async (f) => {
+    const raw = (await readFile(f, "utf8")) as string;
+    if (!injectPath) return raw;
+    const rel = path.relative(cwd, f);
+    return `${ensureTrailingNL(raw)}${getPrefix(f)}${rel}`;
+  });
+  return Promise.all(reads);
+};
+
+const writeResult = async (
+  sections: string[],
+  separator: string,
+  toFile: string | undefined,
+  toStdout: boolean,
+) => {
+  const content = `${sections.join(separator)}\n`;
+  if (toStdout || !toFile) {
+    process.stdout.write(content);
+    return;
+  }
+  const dir = path.dirname(toFile);
+  if (dir && dir !== ".") await ensureDir(dir);
+  await writeFile(toFile, content, "utf8");
+};
+
+// ---------- command ----------
+
+const cmd = defineCommand({
+  meta: {
+    name: "remege",
+    version: "1.0.0",
+    description:
+      "Merge text files with optional commented path footer, skips binaries/media, built for CI & interactive use.",
+  },
+  args: {
+    in: { type: "array", description: "Input glob patterns" },
+    ignore: { type: "array", description: "Extra ignore patterns" },
+    out: { type: "string", description: "Output file path" },
+    format: {
+      type: "string",
+      default: "txt",
+      description: "Fallback extension when output path is omitted",
+    },
+    stdout: { type: "boolean", description: "Print to stdout" },
+    noPath: {
+      type: "boolean",
+      description: "Don't inject relative path below each file",
+    },
+    separator: {
+      type: "string",
+      description: `Custom separator (default ${DEFAULT_SEPARATOR_RAW})`,
+    },
+    comment: {
+      type: "string",
+      description: "Custom comment prefix (e.g. '# ')",
+    },
+    forceComment: {
+      type: "boolean",
+      description: "Force custom comment prefix for all file types",
+    },
+    batch: {
+      type: "boolean",
+      description: "Disable interactive prompts (CI/non-interactive mode)",
+    },
+  },
+  async run({ args }) {
+    const batch = Boolean(args.batch);
+
+    // ----- include patterns -----
+    let include = args.in ?? [];
+    if (include.length === 0) {
+      const raw = await maybePrompt(batch, undefined, () =>
+        inputPrompt({
+          title: "Input glob patterns (comma separated)",
+          placeholder: "src/**/*.ts, !**/*.test.ts",
+        }),
+      );
+      if (raw) include = parseCSV(raw as string);
+    }
+    if (include.length === 0)
+      throw new Error("No input patterns supplied and prompts disabled");
+
+    // ----- ignore patterns -----
+    let ignore = args.ignore ?? [];
+    if (ignore.length === 0) {
+      const raw = await maybePrompt(batch, undefined, () =>
+        inputPrompt({
+          title: "Ignore patterns (comma separated, blank for none)",
+          placeholder: "**/*.d.ts",
+        }),
+      );
+      if (raw) ignore = parseCSV(raw as string);
+    }
+
+    // ----- comment settings -----
+    let customComment = args.comment;
+    if (customComment === undefined) {
+      const want = await maybePrompt(batch, undefined, () =>
+        confirmPrompt({
+          title: "Provide custom comment prefix?",
+          defaultValue: false,
+        }),
+      );
+      if (want) {
+        customComment = (await inputPrompt({
+          title: "Custom comment prefix (include trailing space if needed)",
+          placeholder: "# ",
+        })) as string;
+      }
+    }
+    const forceComment = args.forceComment ?? false;
+
+    // ----- path footer toggle -----
+    const injectPath = args.noPath ? false : true;
+
+    // ----- separator -----
+    const sepRaw =
+      args.separator ??
+      ((await maybePrompt(batch, undefined, () =>
+        inputPrompt({
+          title:
+            "Separator between files (\\n for newline, blank → blank line)",
+          placeholder: DEFAULT_SEPARATOR_RAW,
+        }),
+      )) as string | undefined) ??
+      DEFAULT_SEPARATOR_RAW;
+    const separator = unescape(sepRaw);
+
+    // ----- output location / stdout -----
+    let stdoutFlag = args.stdout ?? false;
+    let outFile = args.out;
+
+    if (!stdoutFlag && !outFile && !batch) {
+      stdoutFlag = await confirmPrompt({
+        title: "Print result to stdout?",
+        defaultValue: false,
+      });
+      if (!stdoutFlag) {
+        outFile = (await inputPrompt({
+          title: "Output file path (blank → merged.<ext>)",
+          placeholder: "",
+        })) as string;
+        if (!outFile) {
+          const ext = (await inputPrompt({
+            title: "File extension",
+            placeholder: args.format,
+          })) as string;
+          outFile = `merged.${(ext || args.format).replace(/^\./, "")}`;
+        }
+      }
+    }
+
+    // ----- gather files -----
+    const files = await collectFiles(include, ignore);
+    if (files.length === 0) {
+      throw new Error(
+        "No text files matched given patterns (binary/media files are skipped)",
+      );
+    }
+
+    // ----- comment prefix resolver -----
+    const getPrefix = (filePath: string): string => {
+      if (forceComment && customComment) return customComment;
+      const ext = path.extname(filePath).slice(1).toLowerCase();
+      return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
+    };
+
+    // ----- read, merge, write -----
+    const sections = await readSections(files, injectPath, getPrefix);
+    await writeResult(sections, separator, outFile, stdoutFlag);
+  },
+});
+
+await runMain(cmd);

package/bin/cli/args/spells/mod.js

@@ -0,0 +1,44 @@
+import { Command } from "commander";
+import { spells } from "../../../libs/sdk/sdk-impl/spells/spells-main.js";
+export const createCli = () => {
+  const program = new Command();
+  program.name("dler-spells").description("Execute magic spells in your codebase").version("1.0.0");
+  program.command("trigger").description("Trigger magic spells").option(
+    "--spells <spells>",
+    'Comma-separated list of spells to execute (or "all")',
+    "all"
+  ).option(
+    "--files <files>",
+    "Comma-separated list of files to process (or all if not specified)"
+  ).option("--dry-run", "Preview changes without applying them", false).action(async (options) => {
+    const requestedSpells = options.spells ? options.spells.split(",") : ["all"];
+    const files = options.files ? options.files.split(",") : [];
+    console.log(`Triggering spells: ${requestedSpells.join(", ")}`);
+    if (files.length) {
+      console.log(`On files: ${files.join(", ")}`);
+    } else {
+      console.log("On all files");
+    }
+    if (options.dryRun) {
+      console.log("DRY RUN - No changes will be applied");
+    }
+    const results = await spells({
+      spells: requestedSpells,
+      files,
+      dryRun: options.dryRun
+    });
+    console.log("\nResults:");
+    for (const result of results) {
+      const status = result.success ? "\u2713" : "\u2717";
+      console.log(
+        `${status} ${result.file}: ${result.spell.type} - ${result.message}`
+      );
+    }
+  });
+  return program;
+};
+const cli = createCli();
+async function main() {
+  cli.parse(process.argv);
+}
+await main();

package/bin/cli/args/split/README.md

@@ -0,0 +1,13 @@
+# Splitter: dler Plugin (Tool)
+
+**`splitter-dler-plugin`**: Splits large source files into smaller ones and large functions into smaller helper functions.
+
+## Project Status
+
+🏗️ **Work In Progress**: This project is currently in development and is not yet ready for use.
+
+You can try current implementation by cloning the repo and running `bun src/split-large-files.ts --dir ./example --file-threshold 30 --func-threshold 20`.
+
+## License
+
+🩷 [MIT](./LICENSE) © [blefnk Nazar Kornienko](https://github.com/blefnk)

package/bin/cli/args/split/split-main.js

@@ -0,0 +1,26 @@
+import fs from "fs-extra";
+import {
+  getAllSourceFiles,
+  parseCommandLineArgs,
+  splitLargeFileByLines,
+  splitLargeFunctions
+} from "./split-mod.js";
+async function main() {
+  const { directory, fileLineThreshold, funcLineThreshold } = parseCommandLineArgs();
+  const allFiles = getAllSourceFiles(directory);
+  for (const filePath of allFiles) {
+    const lineCount = fs.readFileSync(filePath, "utf8").split("\n").length;
+    if (lineCount > fileLineThreshold) {
+      const newSplits = splitLargeFileByLines(filePath, fileLineThreshold);
+      newSplits.forEach((splitFilePath) => {
+        splitLargeFunctions(splitFilePath, funcLineThreshold);
+      });
+    } else {
+      splitLargeFunctions(filePath, funcLineThreshold);
+    }
+  }
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/bin/cli/args/split/split-mod.js

@@ -0,0 +1,117 @@
+import fs from "fs-extra";
+import path from "pathe";
+import ts from "typescript";
+export function parseCommandLineArgs() {
+  const args = process.argv.slice(2);
+  let directory = ".";
+  let fileLineThreshold = 300;
+  let funcLineThreshold = 50;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dir" && args[i + 1]) {
+      directory = args[i + 1] ?? ".";
+      i++;
+    } else if (arg === "--file-threshold" && args[i + 1]) {
+      fileLineThreshold = Number(args[i + 1]);
+      i++;
+    } else if (arg === "--func-threshold" && args[i + 1]) {
+      funcLineThreshold = Number(args[i + 1]);
+      i++;
+    }
+  }
+  return { directory, fileLineThreshold, funcLineThreshold };
+}
+export function getAllSourceFiles(dir) {
+  const results = [];
+  function searchDirectory(directory) {
+    const files = fs.readdirSync(directory);
+    for (const file of files) {
+      const fullPath = path.join(directory, file);
+      if (fs.statSync(fullPath).isDirectory()) {
+        searchDirectory(fullPath);
+      } else if (/\.(ts|js)$/.test(file)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  searchDirectory(dir);
+  return results;
+}
+export function splitLargeFileByLines(filePath, threshold) {
+  const originalContent = fs.readFileSync(filePath, "utf8");
+  const lines = originalContent.split("\n");
+  if (lines.length <= threshold) {
+    return [filePath];
+  }
+  console.log(`File "${filePath}" exceeds ${threshold} lines. Splitting...`);
+  const baseName = path.basename(filePath, path.extname(filePath));
+  const ext = path.extname(filePath);
+  const dirName = path.dirname(filePath);
+  const newFilePaths = [];
+  let chunkIndex = 0;
+  let i = 0;
+  while (i < lines.length) {
+    chunkIndex++;
+    const chunkLines = lines.slice(i, i + threshold);
+    const newFileName = `${baseName}.part${chunkIndex}${ext}`;
+    const newFileFullPath = path.join(dirName, newFileName);
+    fs.writeFileSync(newFileFullPath, chunkLines.join("\n"), "utf8");
+    newFilePaths.push(newFileFullPath);
+    i += threshold;
+  }
+  return newFilePaths;
+}
+export function splitLargeFunctions(filePath, funcLineThreshold) {
+  const sourceCode = fs.readFileSync(filePath, "utf8");
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let newSource = sourceCode;
+  const getLineOfPosition = (pos) => {
+    return sourceFile.getLineAndCharacterOfPosition(pos).line;
+  };
+  const largeFunctions = [];
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node) && node.body) {
+      const startLine = getLineOfPosition(node.body.pos);
+      const endLine = getLineOfPosition(node.body.end);
+      const lineCount = endLine - startLine;
+      if (lineCount > funcLineThreshold) {
+        const name = node.name?.text || "<anonymous>";
+        largeFunctions.push({
+          name,
+          startPos: node.body.pos,
+          endPos: node.body.end,
+          lineCount
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (largeFunctions.length === 0) {
+    return;
+  }
+  console.log(
+    `File "${filePath}" has ${largeFunctions.length} function(s) above ${funcLineThreshold} lines. Attempting to split...`
+  );
+  largeFunctions.sort((a, b) => b.startPos - a.startPos).forEach((fn) => {
+    const bodyText = sourceCode.slice(fn.startPos, fn.endPos);
+    const midIndex = Math.floor(bodyText.length / 2);
+    const helperFunctionName = `${fn.name}HelperAutoGen`;
+    const replacementText = `{
+  // Original function was split automatically
+  ${bodyText.slice(0, midIndex)}
+}
+
+function ${helperFunctionName}() {
+  // auto-generated second half
+  ${bodyText.slice(midIndex)}
+`;
+    newSource = newSource.slice(0, fn.startPos) + replacementText + newSource.slice(fn.endPos);
+  });
+  fs.writeFileSync(filePath, newSource, "utf8");
+}