@reliverse/dler 1.2.0

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

@@ -0,0 +1,121 @@
+import { relinka } from "@reliverse/relinka";
+import {
+  defineCommand,
+  errorHandler,
+  multiselectPrompt,
+  runMain,
+  selectPrompt,
+} from "@reliverse/rempts";
+
+import type {
+  FileType,
+  InitFileRequest,
+} from "./libs/reinit/reint-impl/types.js";
+
+import { FILE_TYPES } from "./libs/reinit/reint-impl/const.js";
+import { initFile, initFiles } from "./libs/reinit/reint-impl/mod.js";
+
+const main = defineCommand({
+  meta: {
+    name: "reinit",
+    version: "1.0.0",
+    description: "@reliverse/reinit-cli",
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode",
+    },
+    fileType: {
+      type: "string",
+      description: "File type to initialize (e.g. 'md:README')",
+      required: false,
+    },
+    destDir: {
+      type: "string",
+      description: "Destination directory",
+      default: ".",
+      required: false,
+    },
+    multiple: {
+      type: "boolean",
+      description: "Whether to select multiple file types from the library",
+      required: false,
+      default: false,
+    },
+    parallel: {
+      type: "boolean",
+      description: "Run tasks in parallel",
+      required: false,
+      default: false,
+    },
+    concurrency: {
+      type: "string",
+      description: "Concurrency limit if parallel is true",
+      required: false,
+      default: "4",
+    },
+  },
+  async run({ args }) {
+    const { fileType, destDir, multiple, parallel, concurrency } = args;
+    const concurrencyNum = Number(concurrency);
+
+    // throw error if fileType doesn't include FILE_TYPES.type
+    if (fileType && !FILE_TYPES.find((ft) => ft.type === fileType)) {
+      throw new Error(`Invalid file type: ${fileType}`);
+    }
+
+    const effectiveFileType: FileType = fileType as FileType;
+
+    if (multiple) {
+      // Let the user choose multiple file types from a prompt
+      const possibleTypes = FILE_TYPES.map((ft) => ft.type);
+      const chosen = await multiselectPrompt({
+        title: "Select file types to initialize",
+        options: possibleTypes.map((pt) => ({ label: pt, value: pt })),
+      });
+
+      if (chosen.length === 0) {
+        relinka("info", "No file types selected. Exiting...");
+        return;
+      }
+
+      // Construct an array of requests
+      const requests: InitFileRequest[] = chosen.map((ct) => ({
+        fileType: ct,
+        destDir,
+      }));
+
+      const results = await initFiles(requests, {
+        parallel,
+        concurrency: concurrencyNum,
+      });
+      relinka("verbose", `Multiple files result: ${JSON.stringify(results)}`);
+    } else {
+      // Single file approach
+      let finalFileType = effectiveFileType;
+      if (!finalFileType) {
+        // If user didn't specify, prompt for a single file type
+        const possibleTypes = FILE_TYPES.map((ft) => ft.type);
+        const picked = await selectPrompt({
+          title: "Pick a file type to initialize",
+          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)}`);
+    }
+  },
+});
+
+await runMain(main).catch((error: unknown) => {
+  errorHandler(
+    error instanceof Error ? error : new Error(String(error)),
+    "An unhandled error occurred, please report it at https://github.com/reliverse/reinit",
+  );
+});

package/bin/cli/args/init/types.js

@@ -0,0 +1 @@
+export * from "./libs/reinit/reint-impl/types.js";

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

@@ -0,0 +1,148 @@
+# @reliverse/reinject | Reinjection CLI & Core
+
+[💖 GitHub Sponsors](https://github.com/sponsors/blefnk) • [💬 Discord](https://discord.gg/Pb8uKbwpsJ) • [📦 NPM](https://npmjs.com/@reliverse/reinject) • [📚 Docs](https://blefnk.reliverse.org/blog/my-products/reinject)
+
+**@reliverse/reinject** handles the boring parts for you. For example:
+
+- ✅ Need to insert `// @ts-expect-error` above a TypeScript error? Reinject’s got you.
+- 🔜 Fixing repetitive warns, lint suppressions, or compiler nags? One-liner.
+- 🔜 Even more features to come!
+
+## 🛠️ What it can do
+
+- 🧠 Inject comments like `@ts-expect-error` or `eslint-disable` above problematic lines
+- 📄 Works with linter logs (tsc, eslint, biome, etc.)
+- 🚀 Processes entire projects or specific paths
+- ✂️ Supports selective injection via filters or patterns
+- 🤖 Ideal for AI-assisted workflows and auto-"fixing" legacy code
+
+## ⚡ Getting Started
+
+Make sure you have Git, Node.js, and bun•pnpm•yarn•npm installed.
+
+### Installation
+
+```bash
+bun i -g @reliverse/reinject
+```
+
+Or use with `bun x` (or `npx`):
+
+```bash
+bun x @reliverse/reinject
+```
+
+### Basic Usage
+
+**User config** in `reinject.config.ts`:
+
+```ts
+export default {
+  injectComment: "// @ts-expect-error TODO: fix ts",
+  tscCommand: "tsc --project ./tsconfig.json --noEmit"
+}
+```
+
+**Running**:
+
+```bash
+# 1) Automatic mode:
+reinject ts-expect-error auto
+# => runs `tsc`, finds errors, injects comment above them.
+
+# 2) Lines-file mode:
+reinject ts-expect-error linesA.txt linesB.txt
+# => no TSC, just parses references from lines files
+
+# 3) Mixed:
+reinject ts-expect-error auto lines.txt
+# => merges TSC errors with references in lines.txt
+```
+
+**And**:
+
+```bash
+# When you need a custom comment:
+reinject ts-expect-error auto --comment="// @ts-expect-error FIXME"
+```
+
+Run on a TypeScript file with tsc output:
+
+```bash
+reinject ts-expect-error src
+```
+
+You can also run on a specific TypeScript file with manually generated tsc output:
+
+```bash
+tsc --noEmit > tsc.log
+reinject tsc.log
+rm tsc.log
+```
+
+You can also run it directly on output from stdin:
+
+```bash
+tsc --noEmit | reinject
+```
+
+Or use with other tools:
+
+```bash
+eslint . | reinject
+biome check . | reinject
+```
+
+### Filter by error code or rule ID
+
+```bash
+reinject tsc.log --code TS2322
+reinject eslint.log --rule no-unused-vars
+```
+
+## ✨ Examples
+
+```ts
+const x: string = 123;
+```
+
+➡️ becomes:
+
+```ts
+// @ts-expect-error: TS2322
+const x: string = 123;
+```
+
+## 🧪 CLI Flags
+
+| Flag             | Description                                      |
+|------------------|--------------------------------------------------|
+| `--code`         | Filter by TS error code or ESLint rule name      |
+| `--paths`        | Restrict injection to matching file paths        |
+| `--comment`      | Custom comment instead of default                |
+| `--dry-run`      | Preview changes without writing to disk          |
+| `--dev`          | Run in dev mode                                  |
+
+## ✅ TODO
+
+- [x] Inject `@ts-expect-error`, `eslint-disable`, etc.
+- [x] Parse output from multiple linters
+- [ ] Add custom comment templates
+- [ ] Improve support for multi-line diagnostics
+
+## 🔋 Powered by
+
+- ⚡ [`@reliverse/rempts`](https://npmjs.com/@reliverse/rempts) — interactive prompts
+- 🧠 Smart AST & text transformations
+
+## 🫶 Show some love
+
+If `@reliverse/reinject` saved you time or sanity:
+
+- ⭐ [Star the repo](https://github.com/reliverse/reinject)
+- 💖 [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/inject/arg-ts-expect-error.txt

@@ -0,0 +1,49 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+
+import { useTsExpectError } from "./ts-expect-error.js";
+
+export default defineCommand({
+  meta: {
+    name: "tee",
+    description: "Inject `@ts-expect-error` above lines where TS errors occur",
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Run the CLI in dev mode",
+    },
+    files: {
+      type: "positional",
+      // array: true, // TODO: implement in dler
+      required: true,
+      description: `'auto' or path(s) to line references file(s)`,
+    },
+    comment: {
+      type: "string",
+      required: false,
+      description:
+        "Override the comment line to insert. Default is `// @ts-expect-error TODO: fix ts`",
+    },
+    tscPaths: {
+      type: "string",
+      // array: true,
+      required: false,
+      description:
+        "Optional: specify path(s) to restrict TSC processing (only effective when using 'auto')",
+    },
+  },
+  run: async ({ args }) => {
+    if (args.dev) {
+      relinka("verbose", "Using dev mode");
+    }
+
+    await useTsExpectError({
+      files: [args.files],
+      comment: args.comment,
+      tscPaths: [args.tscPaths],
+    });
+
+    process.exit(0);
+  },
+});

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

@@ -0,0 +1,32 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand, selectPrompt } from "@reliverse/rempts";
+export default defineCommand({
+  meta: {
+    name: "cli",
+    description: "Runs the Reinject CLI interactive menu (displays list of available commands)"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    },
+    cwd: {
+      type: "string",
+      description: "The working directory to run the CLI in",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const isDev = args.dev;
+    relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
+    await selectPrompt({
+      title: "Select a command",
+      options: [
+        {
+          value: "ts-expect-error",
+          label: "Inject `@ts-expect-error` above lines where TS errors occur"
+        }
+      ]
+    });
+  }
+});

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

@@ -0,0 +1,28 @@
+// todo: implement
+import { defineCommand, errorHandler, runMain } from "@reliverse/rempts";
+
+const main = defineCommand({
+  meta: {
+    name: "reinject",
+    version: "1.0.0",
+    description: "@reliverse/reinject-cli",
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode",
+    },
+  },
+  subCommands: {
+    cli: () => import("./cli/cli-mod.js").then((r) => r.default),
+    tee: () =>
+      import("./cli/args/arg-ts-expect-error.js").then((r) => r.default),
+  },
+});
+
+await runMain(main).catch((error: unknown) => {
+  errorHandler(
+    error instanceof Error ? error : new Error(String(error)),
+    "An unhandled error occurred, please report it at https://github.com/reliverse/reinject",
+  );
+});

package/bin/cli/args/inject/reinject.config.js

@@ -0,0 +1,4 @@
+export default {
+  injectComment: "// @ts-expect-error TODO: fix ts",
+  tscCommand: "tsc --project ./tsconfig.json --noEmit"
+};

package/bin/cli/args/inject/ts-expect-error.txt

@@ -0,0 +1,277 @@
+import { relinka } from "@reliverse/relinka";
+import { loadConfig } from "c12";
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "pathe";
+
+//-------------------------------------
+// 1) c12 config interface
+//-------------------------------------
+type ReinjectUserConfig = {
+  // The comment to inject above each error line
+  injectComment?: string;
+  // The command used to spawn tsc (e.g. "tsc --noEmit --project tsconfig.json")
+  tscCommand?: string;
+};
+
+//-------------------------------------
+// 2) Load c12 configs
+//-------------------------------------
+async function loadReinjectConfig(): Promise<ReinjectUserConfig> {
+  const { config } = await loadConfig<ReinjectUserConfig>({
+    name: "reinject", // tries reinject.config.*, .reinjectrc, etc.
+    defaults: {},
+    overrides: {},
+    dotenv: false,
+    packageJson: false,
+  });
+
+  return {
+    injectComment: config.injectComment ?? "// @ts-expect-error TODO: fix ts",
+    tscCommand: config.tscCommand ?? "tsc --noEmit",
+  };
+}
+
+//-------------------------------------
+// Helper: Parse command string into command and arguments
+//-------------------------------------
+function parseCommand(command: string): { cmd: string; args: string[] } {
+  // This parser splits the command by whitespace while handling double or single quotes.
+  const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
+  const args: string[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(command)) !== null) {
+    args.push(match[1] || match[2] || match[3]);
+  }
+  const cmd = args.shift() || "";
+  return { cmd, args };
+}
+
+//-------------------------------------
+// 3) parseLineRefs from a lines file
+//-------------------------------------
+async function parseLinesFile(linesFile: string) {
+  const fileContents = await fs.readFile(linesFile, "utf-8");
+  const splitted = fileContents.split(/\r?\n/);
+  const results: { filePath: string; lineNumber: number }[] = [];
+
+  for (const rawLine of splitted) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+
+    // Could match "N  path.ts:line"
+    let match = trimmed.match(/^(\d+)\s+(.+?):(\d+)$/);
+    if (match) {
+      results.push({
+        filePath: match[2],
+        lineNumber: Number.parseInt(match[3], 10),
+      });
+      continue;
+    }
+
+    // Or "path.ts:line"
+    match = trimmed.match(/^(.+?):(\d+)$/);
+    if (match) {
+      results.push({
+        filePath: match[1],
+        lineNumber: Number.parseInt(match[2], 10),
+      });
+    } else {
+      relinka("warn", `Line doesn't match expected format: ${trimmed}`);
+    }
+  }
+  return results;
+}
+
+//-------------------------------------
+// 4) runTscAndParseErrors: run tsc with execa, parse error lines
+// Example TSC error line format:
+//   src/foo.ts(12,5): error TS2322:
+// We'll capture `src/foo.ts` and `12` as the error line number
+//-------------------------------------
+async function runTscAndParseErrors(
+  tscCommand: string,
+  tscPaths?: string[],
+): Promise<{ filePath: string; lineNumber: number }[]> {
+  const linesRefs: { filePath: string; lineNumber: number }[] = [];
+
+  try {
+    // Parse the TSC command into the command and its arguments.
+    const { cmd, args: cmdArgs } = parseCommand(tscCommand);
+    // Append any additional paths (if provided) as extra arguments.
+    if (tscPaths && tscPaths.length > 0) {
+      cmdArgs.push(...tscPaths);
+    }
+
+    // Run TSC.
+    const subprocess = await execa(cmd, cmdArgs, { all: true, reject: false });
+    const combinedOutput = subprocess.all || "";
+    const splitted = combinedOutput.split(/\r?\n/);
+    const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
+
+    for (const line of splitted) {
+      const trimmed = line.trim();
+      const m = trimmed.match(regex);
+      if (m) {
+        let file = m[1];
+        const row = Number.parseInt(m[2], 10);
+        if (row > 0) {
+          // Normalize Windows paths.
+          file = file.replace(/\\/g, "/");
+          linesRefs.push({
+            filePath: file,
+            lineNumber: row,
+          });
+        }
+      }
+    }
+  } catch (error: any) {
+    // In case of error, try to extract the output.
+    const combined = (error.all as string) || "";
+    if (!combined) {
+      relinka("info", `TSC returned no error lines. Possibly no TS errors?`);
+      return [];
+    }
+
+    const splitted = combined.split(/\r?\n/);
+    const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
+
+    for (const line of splitted) {
+      const m = line.trim().match(regex);
+      if (m) {
+        let file = m[1];
+        const row = Number.parseInt(m[2], 10);
+        if (row > 0) {
+          file = file.replace(/\\/g, "/");
+          linesRefs.push({ filePath: file, lineNumber: row });
+        }
+      }
+    }
+  }
+
+  return linesRefs;
+}
+
+//-------------------------------------
+// Helper: Check if file is within any of the provided directories
+//-------------------------------------
+function isWithin(filePath: string, dirs: string[]): boolean {
+  const absFile = path.resolve(filePath);
+  for (const dir of dirs) {
+    const absDir = path.resolve(dir);
+    // Ensure trailing separator for accurate prefix matching
+    const normalizedDir = absDir.endsWith(path.sep)
+      ? absDir
+      : absDir + path.sep;
+    if (absFile.startsWith(normalizedDir)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+//-------------------------------------
+// 5) The injection logic
+//-------------------------------------
+async function injectCommentIntoFiles(
+  linesRecords: { filePath: string; lineNumber: number }[],
+  commentText: string,
+) {
+  // Group error lines by file
+  const byFile = new Map<string, number[]>();
+  for (const rec of linesRecords) {
+    if (!byFile.has(rec.filePath)) {
+      byFile.set(rec.filePath, []);
+    }
+    byFile.get(rec.filePath)!.push(rec.lineNumber);
+  }
+
+  for (const [filePath, lineNums] of byFile.entries()) {
+    // Sort descending so injections don't affect subsequent line numbers
+    lineNums.sort((a, b) => b - a);
+    const absPath = path.resolve(filePath);
+    relinka(
+      "info",
+      `Injecting into ${absPath} at lines: ${lineNums.join(", ")}`,
+    );
+
+    try {
+      const original = await fs.readFile(absPath, "utf-8");
+      const splitted = original.split(/\r?\n/);
+      for (const ln of lineNums) {
+        if (ln <= splitted.length) {
+          splitted.splice(ln - 1, 0, commentText);
+        } else {
+          relinka("warn", `Line ${ln} exceeds file length for ${absPath}`);
+        }
+      }
+      const newContent = splitted.join("\n");
+      await fs.writeFile(absPath, newContent, "utf-8");
+    } catch (error) {
+      relinka("error", `Failed editing ${filePath}: ${error}`);
+    }
+  }
+}
+
+//-------------------------------------
+// 6) The main usage function
+//-------------------------------------
+export async function useTsExpectError(args: {
+  files: string[];
+  comment?: string;
+  tscPaths?: string[];
+}) {
+  // 1) load c12 config
+  const userConfig = await loadReinjectConfig();
+  const finalComment = args.comment || userConfig.injectComment!;
+
+  // Gather references
+  const lines: { filePath: string; lineNumber: number }[] = [];
+  let usedAuto = false;
+  for (const item of args.files) {
+    if (item.toLowerCase() === "auto") {
+      usedAuto = true;
+    }
+  }
+
+  if (usedAuto) {
+    relinka("info", "Running TSC to discover error lines...");
+    const tscCommand = userConfig.tscCommand!;
+    try {
+      const discovered = await runTscAndParseErrors(tscCommand, args.tscPaths);
+      // If tscPaths are provided, filter discovered errors to include only files within those paths.
+      if (args.tscPaths && args.tscPaths.length > 0) {
+        const filtered = discovered.filter((rec) =>
+          isWithin(rec.filePath, args.tscPaths!),
+        );
+        lines.push(...filtered);
+      } else {
+        lines.push(...discovered);
+      }
+    } catch (error) {
+      relinka("error", `Failed running tsc: ${error}`);
+      process.exit(1);
+    }
+  }
+
+  // Parse lines from each file that isn't "auto"
+  for (const item of args.files) {
+    if (item.toLowerCase() === "auto") continue;
+
+    try {
+      const recs = await parseLinesFile(item);
+      lines.push(...recs);
+    } catch (error) {
+      relinka("error", `Failed reading lines file ${item}: ${error}`);
+    }
+  }
+
+  if (lines.length === 0) {
+    relinka("error", "No references found. Nothing to do.");
+    relinka("error", "Lines: ", JSON.stringify(lines));
+    process.exit(1);
+  }
+
+  await injectCommentIntoFiles(lines, finalComment);
+  relinka("success", "All lines processed successfully.");
+}