@reliverse/dler 1.2.3 → 1.2.5

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`**:
@@ -124,7 +116,7 @@ bun dev # bun src/mod.ts --dev
 
 ## 🔌 plugins
 
-dler ships with a flexible plugin system and **15 built-in plugins** (from [@reliverse/addons](https://reliverse.org/addons)).
+dler ships with a flexible plugin system and **14 built-in plugins** (from [@reliverse/addons](https://reliverse.org/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`.
 
@@ -136,15 +128,7 @@ generates aggregator file with content like `import { getsomething } from "./uti
 dler agg ...
 ```
 
-### 2. `auth`
-
-best friend of auth+db libs like [better-auth](https://better-auth.com) and [drizzle-orm](https://orm.drizzle.team).
-
-```bash
-dler auth better-auth generate
-```
-
-### 3. `build`
+### 2. `build`
 
 since dler is fully modular, build command is separated for its own build-in plugin as well.
 
@@ -152,11 +136,11 @@ since dler is fully modular, build command is separated for its own build-in plu
 dler build ...
 ```
 
-### 4. `conv`
+### 3. `conv`
 
 not yet documented.
 
-### 5. `deps`
+### 4. `deps`
 
 finds missing dependencies in your project by scanning your code for imports and comparing them to your `package.json`.
 
@@ -203,11 +187,11 @@ dler deps --all --directory ./src --include-builtins
 missing dependencies are shown only once, even if used in multiple files.  
 deep imports like `dep/some/file` or `@org/dep/some/thing` are always resolved to their root package.
 
-### 6. `inject`
+### 5. `inject`
 
 not yet documented.
 
-### 7. `libs`
+### 6. `libs`
 
 builds and publishes specific subdirectories of your main project as standalone packages.
 
@@ -243,15 +227,15 @@ libslist: {
 
 - more magic commands coming soon...
 
-### 8. `merge`
+### 7. `merge`
 
 not yet documented.
 
-### 9. `mono`
+### 8. `mono`
 
 not yet documented.
 
-### 10. `pub`
+### 9. `pub`
 
 pub command is separated for its own build-in plugin as well.
 
@@ -261,13 +245,13 @@ it already calls build command by itself, so you don't need to run `dler build`
 dler pub ...
 ```
 
-### 11. `relifso`
+### 10. `relifso`
 
 ```bash
 dler relifso init ...
 ```
 
-### 12. `relinka`
+### 11. `relinka`
 
 @reliverse/relinka's best friend. learn more in its [docs](https://github.com/reliverse/relinka).
 
@@ -275,7 +259,7 @@ dler relifso init ...
 dler relinka --console-to-relinka
 ```
 
-### 13. `rempts`
+### 12. `rempts`
 
 @reliverse/rempts's best friend. learn more in its [docs](https://github.com/reliverse/rempts).
 
@@ -284,7 +268,7 @@ dler rempts init --cmd my-cmd-1
 dler rempts init --cmds
 ```
 
-### 14. `spell`
+### 13. `spell`
 
 **available spell types:**
 
@@ -342,7 +326,7 @@ 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)
 
-### 15. `tools`
+### 14. `tools`
 
 lets you run standalone dler features directly from the cli:
 

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(), []);
+    }
+  }
+});