@reliverse/dler 1.6.1 → 1.6.2

package/bin/app/conv/cmd.d.ts

@@ -0,0 +1,33 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    type: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    input: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    output: {
+        type: "string";
+        description: string;
+    };
+    pattern: {
+        type: "string";
+        description: string;
+    };
+    replacement: {
+        type: "string";
+        description: string;
+    };
+    line: {
+        type: "number";
+        description: string;
+    };
+    transform: {
+        type: "string";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/conv/cmd.js

@@ -0,0 +1,189 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { executeSpell } from "../../libs/sdk/sdk-mod.js";
+export default defineCommand({
+  meta: {
+    name: "conv",
+    version: "1.0.0",
+    description: "Convert files using various SDK converters."
+  },
+  args: defineArgs({
+    type: {
+      type: "string",
+      required: true,
+      description: "Type of conversion to perform (replace, rename, remove-comment, remove-line, remove-file, copy, move, transform, insert)"
+    },
+    input: {
+      type: "string",
+      required: true,
+      description: "Input file or directory path"
+    },
+    output: {
+      type: "string",
+      description: "Output file or directory path (required for copy/move/rename operations)"
+    },
+    pattern: {
+      type: "string",
+      description: "Pattern to match (for replace/remove operations)"
+    },
+    replacement: {
+      type: "string",
+      description: "Replacement text (for replace/insert operations)"
+    },
+    line: {
+      type: "number",
+      description: "Line number (for insert/remove-line operations)"
+    },
+    transform: {
+      type: "string",
+      description: "Transform function name (for transform operation)"
+    }
+  }),
+  async run({ args }) {
+    const { type, input, output, pattern, replacement, line, transform } = args;
+    if (!await fs.pathExists(input)) {
+      relinka("error", `\u274C Input path does not exist: ${input}`);
+      return;
+    }
+    let spell;
+    switch (type) {
+      case "replace":
+        if (!pattern || !replacement) {
+          relinka(
+            "error",
+            "\u274C Pattern and replacement are required for replace operation"
+          );
+          return;
+        }
+        spell = {
+          type: "replace-line",
+          params: { hooked: false },
+          value: replacement,
+          fullMatch: pattern
+        };
+        break;
+      case "rename":
+        if (!output) {
+          relinka("error", "\u274C Output path is required for rename operation");
+          return;
+        }
+        spell = {
+          type: "rename-file",
+          params: { hooked: false },
+          fileName: output
+        };
+        break;
+      case "remove-comment":
+        if (!pattern) {
+          relinka(
+            "error",
+            "\u274C Pattern is required for remove-comment operation"
+          );
+          return;
+        }
+        spell = {
+          type: "remove-comment",
+          params: { hooked: false },
+          fullMatch: pattern
+        };
+        break;
+      case "remove-line":
+        if (!pattern) {
+          relinka("error", "\u274C Pattern is required for remove-line operation");
+          return;
+        }
+        spell = {
+          type: "remove-line",
+          params: { hooked: false },
+          fullMatch: pattern
+        };
+        break;
+      case "remove-file":
+        spell = {
+          type: "remove-file",
+          params: { hooked: false }
+        };
+        break;
+      case "copy":
+        if (!output) {
+          relinka("error", "\u274C Output path is required for copy operation");
+          return;
+        }
+        spell = {
+          type: "copy-file",
+          params: { hooked: false },
+          fileName: output
+        };
+        break;
+      case "move":
+        if (!output) {
+          relinka("error", "\u274C Output path is required for move operation");
+          return;
+        }
+        spell = {
+          type: "move-file",
+          params: { hooked: false },
+          fileName: output
+        };
+        break;
+      case "transform":
+        if (!transform) {
+          relinka(
+            "error",
+            "\u274C Transform function name is required for transform operation"
+          );
+          return;
+        }
+        spell = {
+          type: "transform-content",
+          params: { hooked: false },
+          value: transform
+        };
+        break;
+      case "insert":
+        if (!line || !replacement) {
+          relinka(
+            "error",
+            "\u274C Line number and replacement are required for insert operation"
+          );
+          return;
+        }
+        spell = {
+          type: "insert-at",
+          params: { hooked: false },
+          value: replacement,
+          lineNumber: line
+        };
+        break;
+      default:
+        relinka("error", `\u274C Unknown conversion type: ${type}`);
+        return;
+    }
+    try {
+      const content = await fs.readFile(input, "utf-8");
+      const result = await executeSpell(spell, input, content);
+      if (result.success) {
+        relinka(
+          "log",
+          `\u2705 Successfully performed ${type} operation on ${input}`
+        );
+        if (result.changes) {
+          relinka(
+            "log",
+            `\u{1F4DD} Changes:
+Before: ${result.changes.before}
+After: ${result.changes.after}`
+          );
+        }
+      } else {
+        relinka(
+          "error",
+          `\u274C Failed to perform ${type} operation: ${result.message}`
+        );
+      }
+    } catch (error) {
+      relinka("error", `\u274C Error during conversion: ${error}`);
+    }
+  }
+});

package/bin/app/inject/cmd.js

@@ -1,6 +1,6 @@
 import { relinka } from "@reliverse/relinka";
 import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
-import { cmdInjectExpect } from "../cmds.js";
+import { getCmdInjectExpect } from "../cmds.js";
 export default defineCommand({
   meta: {
     name: "cli",
@@ -30,7 +30,7 @@ export default defineCommand({
       ]
     });
     if (cmd === "ts-expect-error") {
-      await runCmd(await cmdInjectExpect(), []);
+      await runCmd(await getCmdInjectExpect(), []);
     }
   }
 });

package/bin/app/libs/cmd.d.ts

@@ -0,0 +1,13 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    init: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    overwrite: {
+        type: "boolean";
+        default: false;
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/libs/cmd.js

@@ -0,0 +1,109 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { createJiti } from "jiti";
+export default defineCommand({
+  meta: {
+    name: "libs",
+    version: "1.0.0",
+    description: "Initialize and manage library packages."
+  },
+  args: defineArgs({
+    init: {
+      type: "string",
+      required: true,
+      description: "Names of libraries to initialize (space-separated or quoted)"
+    },
+    overwrite: {
+      type: "boolean",
+      default: false,
+      description: "Overwrite existing libraries"
+    }
+  }),
+  async run({ args }) {
+    let libNames = [];
+    if (Array.isArray(args.init)) {
+      libNames = args.init;
+    } else if (typeof args.init === "string") {
+      libNames = args.init.split(/\s+/).filter(Boolean);
+    }
+    if (libNames.length === 1) {
+      const argv = process.argv;
+      const initIndex = argv.findIndex((arg) => arg === "--init");
+      if (initIndex !== -1 && initIndex + 1 < argv.length) {
+        const additionalArgs = [];
+        for (let i = initIndex + 2; i < argv.length; i++) {
+          const arg = argv[i];
+          if (arg?.startsWith("--")) break;
+          if (arg && !arg.startsWith("-")) {
+            additionalArgs.push(arg);
+          } else {
+            break;
+          }
+        }
+        if (additionalArgs.length > 0 && libNames[0]) {
+          libNames = [libNames[0], ...additionalArgs];
+        }
+      }
+    }
+    if (libNames.length === 0) {
+      relinka("error", "\u274C No library names provided");
+      return;
+    }
+    const dlerConfigPath = path.resolve(".config/dler.ts");
+    let dlerConfig;
+    try {
+      const jiti = createJiti(import.meta.url);
+      dlerConfig = await jiti.import(dlerConfigPath, {
+        default: true
+      });
+    } catch {
+      relinka("error", "\u274C Failed to read .config/dler.ts");
+      return;
+    }
+    const { libsDirSrc, libsList } = dlerConfig;
+    if (!libsDirSrc || !libsList) {
+      relinka("error", "\u274C Missing libsDirSrc or libsList in dler config");
+      return;
+    }
+    relinka(
+      "info",
+      `\u{1F680} Processing ${libNames.length} library(s): ${libNames.join(", ")}`
+    );
+    for (const libName of libNames) {
+      const libConfig = libsList[libName];
+      if (!libConfig) {
+        relinka("warn", `\u274C Library "${libName}" not found in libsList config`);
+        continue;
+      }
+      const { libDirName, libMainFile } = libConfig;
+      if (!libDirName || !libMainFile) {
+        relinka(
+          "warn",
+          `\u274C Missing libDirName or libMainFile for "${libName}"`
+        );
+        continue;
+      }
+      const libDirPath = path.join(libsDirSrc, libDirName);
+      const mainFilePath = path.join(libsDirSrc, libMainFile);
+      if (!await fs.pathExists(libDirPath)) {
+        await fs.ensureDir(libDirPath);
+        relinka("log", `\u2705 Created library directory: ${libDirPath}`);
+      }
+      if (!await fs.pathExists(mainFilePath) || args.overwrite) {
+        const mainFileContent = `// Main entry point for ${libName}
+  export * from "./${libDirName}";
+  `;
+        await fs.ensureDir(path.dirname(mainFilePath));
+        await fs.writeFile(mainFilePath, mainFileContent, "utf-8");
+        relinka("log", `\u2705 Created/Updated main file: ${mainFilePath}`);
+      } else {
+        relinka(
+          "warn",
+          `\u26A0\uFE0F Main file already exists: ${mainFilePath}. Use --overwrite to update.`
+        );
+      }
+    }
+  }
+});

package/bin/app/relifso/cmd.js

@@ -1,6 +1,6 @@
 import { relinka } from "@reliverse/relinka";
 import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
-import { cmdRelifsoInit, cmdRelifsoRename } from "../cmds.js";
+import { getCmdRelifsoInit, getCmdRelifsoRename } from "../cmds.js";
 export default defineCommand({
   meta: {
     name: "relifso",
@@ -38,11 +38,11 @@ export default defineCommand({
       ]
     });
     if (cmd === "init") {
-      await runCmd(await cmdRelifsoInit(), []);
+      await runCmd(await getCmdRelifsoInit(), []);
     } else if (cmd === "rename-prepare") {
-      await runCmd(await cmdRelifsoRename(), ["--prepareMyCLI"]);
+      await runCmd(await getCmdRelifsoRename(), ["--prepareMyCLI"]);
     } else if (cmd === "rename-prepare-revert") {
-      await runCmd(await cmdRelifsoRename(), ["--prepareMyCLI", "--revert"]);
+      await runCmd(await getCmdRelifsoRename(), ["--prepareMyCLI", "--revert"]);
     }
   }
 });

package/bin/app/relinka/cmd.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    input: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    from: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    to: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/relinka/cmd.js

@@ -0,0 +1,149 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+export default defineCommand({
+  meta: {
+    name: "relinka",
+    version: "1.0.0",
+    description: "Convert between different logging formats (console, consola method/object, relinka function/method/object)."
+  },
+  args: defineArgs({
+    input: {
+      type: "string",
+      required: true,
+      description: "Input file or directory path"
+    },
+    from: {
+      type: "string",
+      required: true,
+      description: "Source format (console, consolaMethod, consolaObject, relinkaFunction, relinkaMethod, relinkaObject)"
+    },
+    to: {
+      type: "string",
+      required: true,
+      description: "Target format (console, consolaMethod, consolaObject, relinkaFunction, relinkaMethod, relinkaObject)"
+    }
+  }),
+  async run({ args }) {
+    const { input, from, to } = args;
+    if (!await fs.pathExists(input)) {
+      relinka("error", `\u274C Input path does not exist: ${input}`);
+      return;
+    }
+    let content = await fs.readFile(input, "utf-8");
+    let changes = false;
+    const levels = [
+      "log",
+      "info",
+      "warn",
+      "error",
+      "debug",
+      "verbose",
+      "success",
+      "ready",
+      "start",
+      "box",
+      "trace"
+    ];
+    const getSourcePattern = (level, format) => {
+      switch (format) {
+        case "console":
+          return new RegExp(`console\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
+        case "consolaMethod":
+          if (level === "box") {
+            return /consola\.box\(\s*{\s*title:\s*"([^"]*)",\s*message:\s*"([^"]*)"\s*\}\s*\)/g;
+          }
+          return new RegExp(`consola\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
+        case "consolaObject":
+          return new RegExp(
+            `consola\\({level:\\s*"${level}",\\s*message:\\s*(.*?)(?:,\\s*title:\\s*"([^"]*)")?\\s*\\}\\)`,
+            "g"
+          );
+        case "relinkaFunction":
+          return new RegExp(
+            `relinka\\("${level}",\\s*(.*?)(?:,\\s*(.*))?\\)`,
+            "g"
+          );
+        case "relinkaMethod":
+          return new RegExp(`relinka\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
+        case "relinkaObject":
+          return new RegExp(
+            `relinka\\({level:\\s*"${level}",\\s*message:\\s*(.*?)(?:,\\s*title:\\s*"([^"]*)")?\\s*\\}\\)`,
+            "g"
+          );
+        default:
+          throw new Error(`Invalid source format: ${format}`);
+      }
+    };
+    const createReplacement = (level, message, title, args2) => {
+      switch (to) {
+        case "console":
+          return `console.${level}(${message}${args2 ? `, ${args2}` : ""})`;
+        case "consolaMethod":
+          if (level === "box" && title) {
+            return `consola.box({ title: "${title}", message: "${message}" })`;
+          }
+          return `consola.${level}(${message}${args2 ? `, ${args2}` : ""})`;
+        case "consolaObject": {
+          const obj = {
+            level: `"${level}"`,
+            message,
+            ...title && { title: `"${title}"` },
+            ...args2 && { args: `[${args2}]` }
+          };
+          return `consola(${JSON.stringify(obj).replace(/"([^"]+)":/g, "$1:")})`;
+        }
+        case "relinkaFunction":
+          if (level === "box" && title) {
+            return `relinka("${level}", "${title}\\n${message}"${args2 ? `, ${args2}` : ""})`;
+          }
+          return `relinka("${level}", ${message}${args2 ? `, ${args2}` : ""})`;
+        case "relinkaMethod":
+          if (level === "box" && title) {
+            return `relinka.${level}("${title}\\n${message}"${args2 ? `, ${args2}` : ""})`;
+          }
+          return `relinka.${level}(${message}${args2 ? `, ${args2}` : ""})`;
+        case "relinkaObject": {
+          const obj = {
+            level: `"${level}"`,
+            message,
+            ...title && { title: `"${title}"` },
+            ...args2 && { args: `[${args2}]` }
+          };
+          return `relinka(${JSON.stringify(obj).replace(/"([^"]+)":/g, "$1:")})`;
+        }
+        default:
+          throw new Error(`Invalid target format: ${to}`);
+      }
+    };
+    for (const level of levels) {
+      const pattern = getSourcePattern(level, from);
+      const newContent = content.replace(
+        pattern,
+        (_, message, titleOrArgs, args2) => {
+          changes = true;
+          if ((from === "consolaMethod" || from === "relinkaMethod") && level === "box") {
+            return createReplacement(level, message, titleOrArgs, args2);
+          }
+          return createReplacement(level, message, void 0, titleOrArgs);
+        }
+      );
+      if (newContent !== content) {
+        content = newContent;
+        relinka(
+          "log",
+          `\u2705 Converted ${level} calls from ${from} to ${to} format`
+        );
+      }
+    }
+    if (!changes) {
+      relinka("warn", "\u26A0\uFE0F No matching calls found to convert");
+    } else {
+      await fs.writeFile(input, content, "utf-8");
+      relinka(
+        "success",
+        "\u2728 Successfully converted all logging calls to the target format"
+      );
+    }
+  }
+});

package/bin/app/rempts/{init/cmd → cmd}/cmd.d.ts

@@ -1,14 +1,18 @@
 declare const _default: import("@reliverse/rempts").Command<{
-    cmd: {
-        type: "array";
+    init: {
+        type: "string";
         required: true;
         description: string;
-        options: string[];
     };
-    force: {
+    overwrite: {
         type: "boolean";
         default: false;
         description: string;
     };
+    customCmdsRoot: {
+        type: "string";
+        default: string;
+        description: string;
+    };
 }>;
 export default _default;