@reliverse/dler 1.2.3 → 1.2.4

package/README.md

@@ -66,14 +66,6 @@ bun dev # bun src/mod.ts --dev
     bun update --latest
     ```
 
-    **or install globally**:
-
-    ```sh
-    bun i -g @reliverse/dler
-    # or update as needed:
-    bun -g update --latest
-    ```
-
 2. **prepare your project**:
 
     a. **configure `.gitignore`**:

package/bin/app/cmds.js

@@ -0,0 +1,6 @@
+export async function getCmdRelifsoInit() {
+  return (await import("./relifso/init/cmd.js")).default;
+}
+export async function getCmdInjectTsExpectError() {
+  return (await import("./inject/expect/cmd.js")).default;
+}

package/bin/app/inject/README.md

@@ -1,10 +1,10 @@
-# @reliverse/reinject | Reinjection CLI & Core
+# dler inject
 
-[💖 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)
+[💖 GitHub Sponsors](https://github.com/sponsors/blefnk) • [💬 Discord](https://discord.gg/Pb8uKbwpsJ) • [📦 NPM](https://npmjs.com/@reliverse/inject) • [📚 Docs](https://blefnk.reliverse.org/blog/my-products/inject)
 
-**@reliverse/reinject** handles the boring parts for you. For example:
+**@reliverse/inject** handles the boring parts for you. For example:
 
-- ✅ Need to insert `// @ts-expect-error` above a TypeScript error? Reinject’s got you.
+- ✅ Need to insert `// @ts-expect-error` above a TypeScript error? Inject’s got you.
 - 🔜 Fixing repetitive warns, lint suppressions, or compiler nags? One-liner.
 - 🔜 Even more features to come!
 
@@ -23,18 +23,18 @@ Make sure you have Git, Node.js, and bun•pnpm•yarn•npm installed.
 ### Installation
 
 ```bash
-bun i -g @reliverse/reinject
+bun i -g @reliverse/inject
 ```
 
 Or use with `bun x` (or `npx`):
 
 ```bash
-bun x @reliverse/reinject
+bun x @reliverse/inject
 ```
 
 ### Basic Usage
 
-**User config** in `reinject.config.ts`:
+**User config** in `inject.config.ts`:
 
 ```ts
 export default {
@@ -47,15 +47,15 @@ export default {
 
 ```bash
 # 1) Automatic mode:
-reinject ts-expect-error auto
+inject ts-expect-error auto
 # => runs `tsc`, finds errors, injects comment above them.
 
 # 2) Lines-file mode:
-reinject ts-expect-error linesA.txt linesB.txt
+inject ts-expect-error linesA.txt linesB.txt
 # => no TSC, just parses references from lines files
 
 # 3) Mixed:
-reinject ts-expect-error auto lines.txt
+inject ts-expect-error auto lines.txt
 # => merges TSC errors with references in lines.txt
 ```
 
@@ -63,41 +63,41 @@ reinject ts-expect-error auto lines.txt
 
 ```bash
 # When you need a custom comment:
-reinject ts-expect-error auto --comment="// @ts-expect-error FIXME"
+inject ts-expect-error auto --comment="// @ts-expect-error FIXME"
 ```
 
 Run on a TypeScript file with tsc output:
 
 ```bash
-reinject ts-expect-error src
+inject 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
+inject tsc.log
 rm tsc.log
 ```
 
 You can also run it directly on output from stdin:
 
 ```bash
-tsc --noEmit | reinject
+tsc --noEmit | inject
 ```
 
 Or use with other tools:
 
 ```bash
-eslint . | reinject
-biome check . | reinject
+eslint . | inject
+biome check . | inject
 ```
 
 ### Filter by error code or rule ID
 
 ```bash
-reinject tsc.log --code TS2322
-reinject eslint.log --rule no-unused-vars
+inject tsc.log --code TS2322
+inject eslint.log --rule no-unused-vars
 ```
 
 ## ✨ Examples
@@ -137,9 +137,9 @@ const x: string = 123;
 
 ## 🫶 Show some love
 
-If `@reliverse/reinject` saved you time or sanity:
+If `@reliverse/inject` saved you time or sanity:
 
-- ⭐ [Star the repo](https://github.com/reliverse/reinject)
+- ⭐ [Star the repo](https://github.com/reliverse/inject)
 - 💖 [Sponsor on GitHub](https://github.com/sponsors/blefnk)
 - 🫶 Share it with a dev friend!
 

package/bin/app/inject/cmd.js

@@ -1,9 +1,10 @@
 import { relinka } from "@reliverse/relinka";
-import { defineCommand, selectPrompt } from "@reliverse/rempts";
+import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
+import { getCmdInjectTsExpectError } from "../cmds.js";
 export default defineCommand({
   meta: {
     name: "cli",
-    description: "Runs the Reinject CLI interactive menu (displays list of available commands)"
+    description: "Runs the Inject command interactive menu (displays list of available commands)"
   },
   args: {
     dev: {
@@ -19,7 +20,7 @@ export default defineCommand({
   run: async ({ args }) => {
     const isDev = args.dev;
     relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
-    await selectPrompt({
+    const cmd = await selectPrompt({
       title: "Select a command",
       options: [
         {
@@ -28,5 +29,8 @@ export default defineCommand({
         }
       ]
     });
+    if (cmd === "ts-expect-error") {
+      await runCmd(await getCmdInjectTsExpectError(), []);
+    }
   }
 });

package/bin/app/inject/expect/cmd.js

@@ -0,0 +1,43 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { useTsExpectError } from "./impl.js";
+export default defineCommand({
+  meta: {
+    name: "expect",
+    version: "1.0.0",
+    description: "Inject `@ts-expect-error` above lines where TS errors occur"
+  },
+  args: defineArgs({
+    dev: {
+      type: "boolean",
+      description: "Run the CLI in dev mode"
+    },
+    files: {
+      type: "positional",
+      description: `'auto' or path(s) to line references file(s)`,
+      default: "auto"
+    },
+    comment: {
+      type: "string",
+      description: "Override the comment line to insert. Default is `// @ts-expect-error TODO: fix ts`"
+    },
+    tscPaths: {
+      type: "string",
+      description: "Optional: specify path(s) to restrict TSC processing (only effective when using 'auto')"
+    }
+  }),
+  async run({ args }) {
+    if (args.dev) {
+      relinka("verbose", "Using dev mode");
+    }
+    let pathsTsc = args.tscPaths;
+    if (pathsTsc === void 0 && args.files === "auto") {
+      pathsTsc = "./tsconfig.json";
+    }
+    await useTsExpectError({
+      files: [args.files],
+      comment: args.comment,
+      tscPaths: [pathsTsc]
+    });
+  }
+});

package/bin/app/inject/expect/impl.js

@@ -0,0 +1,162 @@
+import { relinka } from "@reliverse/relinka";
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "pathe";
+function parseCommand(command) {
+  const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
+  const args = [];
+  let match;
+  while (regex.exec(command) !== null) {
+    match = regex.exec(command);
+    if (match) {
+      const value = match[1] ?? match[2] ?? match[3];
+      if (value) {
+        args.push(value);
+      }
+    }
+  }
+  const cmd = args.shift() ?? "";
+  return { cmd, args };
+}
+async function parseLinesFile(linesFile) {
+  const fileContents = await fs.readFile(linesFile, "utf-8");
+  const splitted = fileContents.split(/\r?\n/);
+  const results = [];
+  for (const rawLine of splitted) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+    const firstMatch = trimmed.match(/^(\d+)\s+(.+?):(\d+)$/);
+    if (firstMatch?.[2] && firstMatch?.[3]) {
+      results.push({
+        filePath: firstMatch[2],
+        lineNumber: Number.parseInt(firstMatch[3], 10)
+      });
+      continue;
+    }
+    const secondMatch = trimmed.match(/^(.+?):(\d+)$/);
+    if (secondMatch?.[1] && secondMatch?.[2]) {
+      results.push({
+        filePath: secondMatch[1],
+        lineNumber: Number.parseInt(secondMatch[2], 10)
+      });
+    } else {
+      relinka("warn", `Line doesn't match expected format: ${trimmed}`);
+    }
+  }
+  return results;
+}
+async function runTscAndParseErrors(tscCommand, tscPaths) {
+  try {
+    const { cmd, args: cmdArgs } = parseCommand(tscCommand);
+    if (tscPaths?.length) {
+      cmdArgs.push(...tscPaths);
+    }
+    const subprocess = await execa(cmd, cmdArgs, { all: true, reject: false });
+    const combinedOutput = subprocess.all ?? "";
+    return parseErrorOutput(combinedOutput);
+  } catch (error) {
+    if (error && typeof error === "object" && "all" in error) {
+      const combined = error.all ?? "";
+      if (!combined) {
+        relinka("log", "TSC returned no error lines. Possibly no TS errors?");
+        return [];
+      }
+      return parseErrorOutput(combined);
+    }
+    return [];
+  }
+}
+function parseErrorOutput(output) {
+  const results = [];
+  const splitted = output.split(/\r?\n/);
+  const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
+  for (const line of splitted) {
+    const match = line.trim().match(regex);
+    if (match?.[1] && match?.[2]) {
+      const file = match[1].replace(/\\/g, "/");
+      const row = Number.parseInt(match[2], 10);
+      if (row > 0) {
+        results.push({ filePath: file, lineNumber: row });
+      }
+    }
+  }
+  return results;
+}
+function isWithin(filePath, dirs) {
+  const absFile = path.resolve(filePath);
+  return dirs.some((dir) => {
+    const absDir = path.resolve(dir);
+    const normalizedDir = absDir.endsWith(path.sep) ? absDir : absDir + path.sep;
+    return absFile.startsWith(normalizedDir);
+  });
+}
+async function injectCommentIntoFiles(linesRecords, commentText) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const rec of linesRecords) {
+    const lines = byFile.get(rec.filePath) ?? [];
+    lines.push(rec.lineNumber);
+    byFile.set(rec.filePath, lines);
+  }
+  for (const [filePath, lineNums] of byFile.entries()) {
+    lineNums.sort((a, b) => b - a);
+    const absPath = path.resolve(filePath);
+    relinka(
+      "log",
+      `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}`);
+    }
+  }
+}
+export async function useTsExpectError(args) {
+  const finalComment = args.comment ?? "// @ts-expect-error TODO: fix ts";
+  const tscCommand = "tsc --project ./tsconfig.json --noEmit";
+  const lines = [];
+  const usedAuto = args.files.some((item) => item.toLowerCase() === "auto");
+  if (usedAuto) {
+    relinka("log", "Running TSC to discover error lines...");
+    try {
+      const discovered = await runTscAndParseErrors(tscCommand, args.tscPaths);
+      if (args.tscPaths?.length) {
+        const filtered = discovered.filter(
+          (rec) => args.tscPaths ? isWithin(rec.filePath, args.tscPaths) : true
+        );
+        lines.push(...filtered);
+      } else {
+        lines.push(...discovered);
+      }
+    } catch (error) {
+      relinka("error", `Failed running tsc: ${error}`);
+      process.exit(1);
+    }
+  }
+  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.");
+}

package/bin/app/relifso/cmd.js

@@ -1,5 +1,36 @@
-export { FILE_TYPES } from "./impl/const.js";
-export { gitignoreTemplate } from "./impl/templates/t-gitignore.js";
-export { licenseTemplate } from "./impl/templates/t-license.js";
-export { readmeTemplate } from "./impl/templates/t-readme.js";
-export { escapeMarkdownCodeBlocks } from "./impl/utils.js";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
+import { getCmdRelifsoInit } from "../cmds.js";
+export default defineCommand({
+  meta: {
+    name: "cli",
+    description: "Runs the Relifso helper 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`);
+    const cmd = await selectPrompt({
+      title: "Select a command",
+      options: [
+        {
+          value: "init",
+          label: "Initialize files"
+        }
+      ]
+    });
+    if (cmd === "init") {
+      await runCmd(await getCmdRelifsoInit(), []);
+    }
+  }
+});

package/bin/app/{rempts/cmd.txt → relifso/init/cmd.js}

@@ -1,121 +1,93 @@
-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("log", "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",
-  );
-});
+import { relinka } from "@reliverse/relinka";
+import {
+  defineCommand,
+  multiselectPrompt,
+  selectPrompt
+} from "@reliverse/rempts";
+import { FILE_TYPES } from "./impl/const.js";
+import { initFile, initFiles } from "./impl/mod.js";
+export default defineCommand({
+  meta: {
+    name: "relifso",
+    version: "1.0.0",
+    description: "relifso helper utils"
+  },
+  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);
+    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 initialize",
+        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 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)}`);
+    }
+  }
+});