@reliverse/dler 1.2.0

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

@@ -0,0 +1,121 @@
+# @reliverse/reinit | Reinit CLI & Core
+
+[💖 GitHub Sponsors](https://github.com/sponsors/blefnk) • [💬 Discord](https://discord.gg/Pb8uKbwpsJ) • [📦 NPM](https://npmjs.com/@reliverse/reinit-cli) • [📚 Docs](https://blefnk.reliverse.org/blog/my-products/reinit)
+
+**@reliverse/reinit** is your buddy for bootstrapping the boring stuff — so you can jump straight into building the good stuff.
+
+- Need a `README.md`? `.gitignore`? `eslint.config.js`? Boom — done.
+- Configs, docs, boilerplate — Reinit helps you set them up in seconds, not hours.
+
+## 🛠️ What it can do
+
+- 📝 Instantly generate common project files (README, LICENSE, configs, etc).
+- ⚙️ Supports a wide range of file types: `eslint`, `knip`, `tsconfig`, `gitignore`, and more.
+- 🚀 Use presets or customize everything with interactive prompts.
+- 🛠️ Choose between single-file or multi-file generation.
+- 📦 Comes in two flavors: CLI (`@reliverse/reinit-cli`) and Core (`@reliverse/reinit`) — use whichever fits your flow.
+- 🧠 Handles conflicts smartly: overwrite, skip, prompt, or attach an index.
+
+## ⚡ Getting Started
+
+Ensure Git, Node.js, and bun•pnpm•yarn•npm are installed. Then:
+
+### Installation
+
+```bash
+bun i -g @reliverse/reinit-cli
+```
+
+Or use with `bun x` (or `npx`):
+
+```bash
+bun x @reliverse/reinit-cli
+```
+
+### Basic Usage
+
+Run without arguments to launch interactive mode:
+
+```bash
+reinit-cli
+```
+
+### Generate a specific file
+
+```bash
+reinit-cli --fileType md:README
+```
+
+### Generate multiple files
+
+```bash
+reinit-cli --multiple
+```
+
+Add `--parallel` to go even faster:
+
+```bash
+reinit-cli --multiple --parallel --concurrency 3
+```
+
+### Custom destination
+
+```bash
+reinit-cli --fileType git:gitignore --destDir ./my-folder
+```
+
+## 🧩 Supported File Types
+
+Some examples of supported `fileType` values:
+
+- `md:README`
+- `md:LICENSE`
+- `cfg:eslint`
+- `cfg:tsconfig.json`
+- `cfg:package.json`
+- `cfg:reliverse`
+- `cfg:knip`
+- `git:gitignore`
+- `git:gitattributes`
+
+Each file type has smart defaults and helpful variations. Choose one, or let the CLI guide you.
+
+## 🧠 Advanced Features
+
+- 🔄 **Fallback copy mode** — If generating fails, Reinit can copy templates from your local base.
+- 🧩 **Attach index** — Already have a file? Reinit can create `file.1.json`, `file.2.json`, etc. Instead of overwriting, it builds alongside.
+- 🧠 **Configurable behavior** — Add `reinit.config.ts` to control parallelism, conflict handling, and lifecycle hooks.
+
+## 🧪 CLI Flags
+
+| Flag            | Description                                |
+|-----------------|--------------------------------------------|
+| `--fileType`    | File type to generate (e.g. `md:README`)   |
+| `--destDir`     | Destination directory (default: `.`)       |
+| `--multiple`    | Select multiple files via interactive UI   |
+| `--parallel`    | Run tasks in parallel                      |
+| `--concurrency` | Set concurrency for parallel execution     |
+| `--dev`         | Run in dev mode                            |
+
+## ✅ TODO
+
+- [x] Implement basic logic
+- [ ] Parse templates for `gitignore` ([link](https://github.com/github/gitignore#readme)), `gitattributes` ([link](https://github.com/gitattributes/gitattributes#readme)), etc
+
+## 🔋 Powered by
+
+- 🧠 [`@reliverse/reinit`](https://npmjs.com/@reliverse/reinit) — the core engine
+- ⚡ [`@reliverse/rempts`](https://npmjs.com/@reliverse/rempts) — interactive prompts
+- 🧰 [`c12`](https://github.com/unjs/c12) — zero-config file loading
+
+## 🫶 Show some love
+
+If `@reliverse/reinit` made your setup easier:
+
+- ⭐ [Star the repo](https://github.com/reliverse/reinit)
+- 💖 [Sponsor on GitHub](https://github.com/sponsors/blefnk)
+- 🫶 Share it with a dev friend!
+
+## 📄 License
+
+MIT © 2025 [blefnk (Nazar Kornienko)](https://github.com/blefnk)

package/bin/cli/args/init/libs/reinit/reinit-main.js

@@ -0,0 +1,5 @@
+export { FILE_TYPES } from "./reint-impl/const.js";
+export { gitignoreTemplate } from "./reint-impl/templates/t-gitignore.js";
+export { licenseTemplate } from "./reint-impl/templates/t-license.js";
+export { readmeTemplate } from "./reint-impl/templates/t-readme.js";
+export { escapeMarkdownCodeBlocks } from "./reint-impl/utils.js";

package/bin/cli/args/init/libs/reinit/reint-impl/const.js

@@ -0,0 +1,26 @@
+export const FILE_TYPES = [
+  { type: "cfg:eslint", variations: ["eslint.config.js"] },
+  { type: "cfg:knip", variations: ["knip.json"] },
+  {
+    type: "cfg:reliverse",
+    variations: [".config/rse.jsonc", ".config/rse.ts"]
+  },
+  { type: "cfg:package.json", variations: ["package.json"] },
+  { type: "cfg:tsconfig.json", variations: ["tsconfig.json"] },
+  { type: "git:gitattributes", variations: [".gitattributes"] },
+  { type: "git:gitignore", variations: [".gitignore"] },
+  { type: "md:LICENSE", variations: ["LICENSE.md", "LICENSE"] },
+  { type: "md:README", variations: ["README.md"] }
+];
+export const INIT_BEHAVIOURS = [
+  "create",
+  "copy",
+  "create-if-copy-failed"
+];
+export const DEST_FILE_EXISTS_BEHAVIOURS = [
+  "rewrite",
+  "skip",
+  "attach-index",
+  "prompt"
+];
+export const CONTENT_CREATE_MODES = ["license-basic", "simple-readme"];

package/bin/cli/args/init/libs/reinit/reint-impl/mod.txt

@@ -0,0 +1,395 @@
+import { relinka, selectPrompt } from "@reliverse/rempts";
+import { loadConfig } from "c12";
+import fs from "fs-extra";
+import pMap from "p-map";
+import path from "pathe";
+
+import type {
+  DestFileExistsBehaviour,
+  FileType,
+  InitBehaviour,
+  InitFileRequest,
+  InitFileResult,
+  ReinitUserConfig,
+} from "./types.js";
+
+import { FILE_TYPES } from "./const.js";
+import { gitignoreTemplate } from "./templates/t-gitignore.js";
+import { licenseTemplate } from "./templates/t-license.js";
+import { readmeTemplate } from "./templates/t-readme.js";
+import { escapeMarkdownCodeBlocks } from "./utils.js";
+
+/**
+ * Creates a file from scratch, including parent directories,
+ * basing the file content on the fileType.
+ */
+export async function createFileFromScratch(
+  destPath: string,
+  fileType: FileType, // e.g. "cfg:eslint", "md:LICENSE", "md:README", ...
+  contentCreateMode?: string,
+) {
+  // Ensure parent directory
+  await fs.ensureDir(path.dirname(destPath));
+
+  let content = "";
+  switch (fileType) {
+    case "md:LICENSE":
+      content = licenseTemplate;
+      break;
+    case "md:README":
+      content = escapeMarkdownCodeBlocks(readmeTemplate);
+      break;
+    case "git:gitignore":
+      content = gitignoreTemplate;
+      break;
+    default:
+      content = `// Auto-generated file for type: ${fileType}`;
+      break;
+  }
+
+  if (contentCreateMode) {
+    content = contentCreateMode;
+    relinka("verbose", `Using custom content for file ${destPath}`);
+  }
+
+  await fs.outputFile(destPath, content, { encoding: "utf-8" });
+}
+
+/**
+ * Loads user config from `reinit.config.(ts|js|json...)` using c12
+ * and merges with fallback defaults.
+ */
+async function loadReinitConfig(): Promise<ReinitUserConfig> {
+  const { config } = await loadConfig<ReinitUserConfig>({
+    name: "reinit",
+    defaults: {},
+    overrides: {},
+    dotenv: false,
+    packageJson: false,
+  });
+
+  const merged: ReinitUserConfig = {
+    defaultInitBehaviour: config.defaultInitBehaviour ?? "create",
+    defaultDestFileExistsBehaviour:
+      config.defaultDestFileExistsBehaviour ?? "prompt",
+    parallelByDefault: config.parallelByDefault ?? false,
+    parallelConcurrency: config.parallelConcurrency ?? 4,
+    onFileStart: config.onFileStart,
+    onFileComplete: config.onFileComplete,
+  };
+  return merged;
+}
+
+/**
+ * Single-file initialization using the merged config.
+ */
+export async function initFile(
+  req: InitFileRequest,
+  userCfg?: ReinitUserConfig,
+): Promise<InitFileResult> {
+  const config = userCfg ?? (await loadReinitConfig());
+  const initBehaviour = req.initBehaviour ?? config.defaultInitBehaviour!;
+  const existsBehaviour =
+    req.destFileExistsBehaviour ?? config.defaultDestFileExistsBehaviour!;
+
+  config.onFileStart?.(req);
+
+  let result: InitFileResult;
+  try {
+    result = await doInitFile(req, initBehaviour, existsBehaviour);
+  } catch (error) {
+    result = {
+      requested: req,
+      status: "error",
+      error,
+    };
+  }
+
+  config.onFileComplete?.(result);
+  return result;
+}
+
+/**
+ * Multi-file version. By default, uses the "parallelByDefault" from config.
+ * If parallel is true, uses p-map with concurrency from "parallelConcurrency".
+ */
+export async function initFiles(
+  items: InitFileRequest[],
+  options?: { parallel?: boolean; concurrency?: number },
+  userCfg?: ReinitUserConfig,
+): Promise<InitFileResult[]> {
+  const config = userCfg ?? (await loadReinitConfig());
+
+  const parallel =
+    typeof options?.parallel === "boolean"
+      ? options.parallel
+      : config.parallelByDefault;
+
+  const concurrency = options?.concurrency ?? config.parallelConcurrency ?? 4;
+
+  if (parallel) {
+    return pMap(items, (item) => initFile(item, config), { concurrency });
+  } else {
+    const results: InitFileResult[] = [];
+    for (const item of items) {
+      results.push(await initFile(item, config));
+    }
+    return results;
+  }
+}
+
+/**
+ * The main logic for creating or copying a file.
+ */
+async function doInitFile(
+  req: InitFileRequest,
+  initBehaviour: InitBehaviour,
+  destFileExistsBehaviour: DestFileExistsBehaviour,
+): Promise<InitFileResult> {
+  const { fileType, destDir, options } = req;
+  const { destFileName, srcCopyMode, fallbackSource } = options ?? {};
+
+  // Look up known variations for the fileType
+  const knownType = FILE_TYPES.find(
+    (f) => f.type.toLowerCase() === fileType.toLowerCase(),
+  );
+  const variations = knownType ? knownType.variations : [fileType];
+
+  // Possibly prompt if multiple variations exist
+  let chosenVariation: string;
+  if (variations.length === 1) {
+    chosenVariation = variations[0];
+  } else {
+    chosenVariation = await selectPrompt({
+      title: `Select variation for ${fileType}`,
+      options: variations.map((v) => ({ label: v, value: v })),
+    });
+  }
+
+  const finalName = destFileName ?? chosenVariation;
+
+  // Convert destDir to absolute path
+  const absoluteDestDir = path.resolve(process.cwd(), destDir || "");
+  const resolvedDestPath = path.join(absoluteDestDir, finalName);
+
+  relinka(
+    "verbose",
+    `Preparing to init file:
+  - File Type: ${fileType}
+  - Variation: ${chosenVariation}
+  - Destination Dir: ${absoluteDestDir}
+  - Final Path: ${resolvedDestPath}
+  `,
+  );
+
+  // If file already exists
+  const alreadyExists = await fs.pathExists(resolvedDestPath);
+  if (alreadyExists) {
+    const maybeNewDest = await handleExistingFile(
+      resolvedDestPath,
+      destFileExistsBehaviour,
+    );
+    if (!maybeNewDest) {
+      return {
+        requested: req,
+        status: "skipped",
+      };
+    }
+    if (maybeNewDest !== resolvedDestPath) {
+      // e.g., attach-index was chosen
+      relinka("info", `attach-index or rename => ${maybeNewDest}`);
+      return await finalizeInit(
+        req,
+        initBehaviour,
+        chosenVariation,
+        maybeNewDest,
+      );
+    }
+  }
+
+  return await finalizeInit(
+    req,
+    initBehaviour,
+    chosenVariation,
+    resolvedDestPath,
+  );
+}
+
+/** Reusable helper to finalize creation or copy after we pick a path. */
+async function finalizeInit(
+  req: InitFileRequest,
+  initBehaviour: InitBehaviour,
+  chosenVariation: string,
+  resolvedDestPath: string,
+): Promise<InitFileResult> {
+  try {
+    switch (initBehaviour) {
+      case "copy":
+        return await runCopy(req, chosenVariation, resolvedDestPath);
+      case "create":
+        return await runCreate(req, resolvedDestPath);
+      // If user or config explicitly sets "create-if-copy-failed" or something else
+      case "create-if-copy-failed":
+      default:
+        try {
+          return await runCopy(req, chosenVariation, resolvedDestPath);
+        } catch (err) {
+          relinka(
+            "warn",
+            `Copy failed for ${chosenVariation}, fallback to create...`,
+          );
+          return await runCreate(req, resolvedDestPath);
+        }
+    }
+  } catch (error) {
+    throw error;
+  }
+}
+
+async function runCopy(
+  req: InitFileRequest,
+  chosenVariation: string,
+  resolvedDestPath: string,
+): Promise<InitFileResult> {
+  const { srcCopyMode, fallbackSource } = req.options ?? {};
+  const resolvedSrcDir = path.resolve(process.cwd(), srcCopyMode || "");
+  const sourcePath = path.join(resolvedSrcDir, chosenVariation);
+
+  if (sourcePath === resolvedDestPath) {
+    relinka(
+      "warn",
+      `Source path equals destination => doing a no-op: ${sourcePath}`,
+    );
+    return {
+      requested: req,
+      finalPath: resolvedDestPath,
+      status: "copied",
+    };
+  }
+
+  relinka(
+    "info",
+    `Attempting copy:
+  - Source Dir: ${resolvedSrcDir}
+  - Source Path: ${sourcePath}
+  - Destination Path: ${resolvedDestPath}
+  `,
+  );
+
+  try {
+    await fs.ensureDir(path.dirname(resolvedDestPath));
+
+    if (!(await fs.pathExists(sourcePath))) {
+      throw new Error(`Source file not found: ${sourcePath}`);
+    }
+    await fs.copy(sourcePath, resolvedDestPath, { overwrite: true });
+    relinka("info", `Copied file: ${chosenVariation} -> ${resolvedDestPath}`);
+    return {
+      requested: req,
+      finalPath: resolvedDestPath,
+      status: "copied",
+    };
+  } catch (primaryErr) {
+    if (fallbackSource) {
+      relinka(
+        "warn",
+        `Primary copy failed, trying fallback: ${fallbackSource}`,
+      );
+      const fallbackFullPath = path.join(resolvedSrcDir, fallbackSource);
+      try {
+        await fs.ensureDir(path.dirname(resolvedDestPath));
+        if (!(await fs.pathExists(fallbackFullPath))) {
+          throw new Error(
+            `Fallback source file not found: ${fallbackFullPath}`,
+          );
+        }
+        await fs.copy(fallbackFullPath, resolvedDestPath, { overwrite: true });
+        relinka(
+          "info",
+          `Fallback copy: ${fallbackSource} -> ${resolvedDestPath}`,
+        );
+        return {
+          requested: req,
+          finalPath: resolvedDestPath,
+          status: "copied",
+        };
+      } catch (fallbackErr) {
+        throw new Error(
+          `Primary copy error: ${String(primaryErr)}\nFallback copy error: ${String(
+            fallbackErr,
+          )}`,
+        );
+      }
+    }
+    throw primaryErr;
+  }
+}
+
+async function runCreate(
+  req: InitFileRequest,
+  resolvedDestPath: string,
+): Promise<InitFileResult> {
+  relinka("verbose", `Creating file from scratch at: ${resolvedDestPath}`);
+
+  // The "fileType" is used to decide how to create content inside `createFileFromScratch`
+  const { fileType } = req;
+
+  await createFileFromScratch(resolvedDestPath, fileType);
+  relinka("verbose", `Created file from scratch: ${resolvedDestPath}`);
+  return {
+    requested: req,
+    finalPath: resolvedDestPath,
+    status: "created",
+  };
+}
+
+/** If file exists, handle rewrite, skip, attach-index, or prompt. */
+async function handleExistingFile(
+  destPath: string,
+  behaviour: DestFileExistsBehaviour,
+): Promise<string | null> {
+  switch (behaviour) {
+    case "rewrite":
+      relinka("warn", `File exists, rewriting in-place: ${destPath}`);
+      return destPath;
+
+    case "skip":
+      relinka("warn", `File exists, skipping: ${destPath}`);
+      return null;
+
+    case "attach-index":
+      return attachIndex(destPath);
+
+    case "prompt":
+      const choice = await selectPrompt({
+        title: `File exists: ${path.basename(destPath)}. How to handle?`,
+        options: [
+          { label: "Overwrite", value: "overwrite" },
+          { label: "Skip", value: "skip" },
+          { label: "Attach Index", value: "attachIndex" },
+        ],
+      });
+      if (choice === "skip") return null;
+      if (choice === "attachIndex") {
+        return attachIndex(destPath);
+      }
+      relinka("warn", `Overwriting in-place: ${destPath}`);
+      return destPath;
+  }
+}
+
+/** For attach-index, do file.1.ext, file.2.ext, etc. */
+async function attachIndex(originalPath: string) {
+  const ext = path.extname(originalPath);
+  const base = path.basename(originalPath, ext);
+  const dir = path.dirname(originalPath);
+
+  let counter = 1;
+  let newPath = originalPath;
+  while (await fs.pathExists(newPath)) {
+    newPath = path.join(dir, `${base}.${counter}${ext}`);
+    counter++;
+  }
+  relinka("info", `Attaching index => ${newPath}`);
+  return newPath;
+}

package/bin/cli/args/init/libs/reinit/reint-impl/templates/t-gitignore.js

@@ -0,0 +1,9 @@
+export const gitignoreTemplate = `*.log
+.env
+.DS_Store
+.eslintcache
+node_modules
+dist-jsr
+dist-libs
+dist-npm
+`;

package/bin/cli/args/init/libs/reinit/reint-impl/templates/t-license.js

@@ -0,0 +1,22 @@
+export const licenseTemplate = `# MIT License
+
+Copyright (c) 2025 Nazar Kornienko (blefnk), 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;

package/bin/cli/args/init/libs/reinit/reint-impl/templates/t-readme.js

@@ -0,0 +1,59 @@
+export const readmeTemplate = `# \u{1F680} Project Name
+
+Welcome! This project was bootstrapped with [@reliverse/reinit](https://www.npmjs.com/package/@reliverse/reinit).  
+It's already got the basics \u2014 now it's your turn to make it awesome \u2728
+
+## \u{1F527} Tech Stack
+
+- \u2699\uFE0F Framework: _<Add your framework here>_
+- \u{1F6E0}\uFE0F Tools: _<Add your tooling, CLIs, etc>_
+- \u{1F9EA} Tests: _<Vitest, Jest, or something else?>_
+- \u{1F9E0} Linting: _ESLint, Biome, etc_
+- \u{1F310} Deployment: _<Vercel, Netlify, Railway?>_
+
+## \u{1F680} Getting Started
+
+Clone the repo and install dependencies:
+
+'''bash
+bun install
+bun dev
+'''
+
+Or if you're using another package manager:
+
+'''bash
+npm install && npm run dev
+# or
+pnpm i && pnpm dev
+'''
+
+## \u{1F5C2}\uFE0F Project Structure
+
+'''bash
+src/
+\u251C\u2500\u2500 components/
+\u251C\u2500\u2500 pages/
+\u251C\u2500\u2500 lib/
+\u2514\u2500\u2500 styles/
+'''
+
+Feel free to tweak the structure to your liking.
+
+## \u{1F9E9} Customize it
+
+This project is just a starting point. You can add:
+
+- \u{1F9D9}\u200D\u2642\uFE0F Your own components and UI
+- \u{1F4E6} APIs, auth, i18n, analytics, whatever you need
+- \u{1F916} AI integrations using [Reliverse CLI](https://www.npmjs.com/package/@reliverse/rse)
+
+## \u{1FAF6} Credits
+
+Made with \u2764\uFE0F using [@reliverse/reinit](https://reliverse.org)  
+Need help? [Join the Discord](https://discord.gg/Pb8uKbwpsJ)
+
+## \u{1F4C4} License
+
+MIT \xA9 YourNameHere
+`;

package/bin/cli/args/init/libs/reinit/reint-impl/utils.js

@@ -0,0 +1,3 @@
+export function escapeMarkdownCodeBlocks(input) {
+  return input.replace(/'''/g, "```");
+}