@reliverse/dler 1.6.1 → 1.6.2

package/bin/app/rempts/cmd/cmd.js

@@ -0,0 +1,152 @@
+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";
+import { generateCommandTemplate, cliTemplate } from "./templates.js";
+export default defineCommand({
+  meta: {
+    name: "init",
+    version: "1.0.0",
+    description: "Scaffold new CLI commands quickly."
+  },
+  args: defineArgs({
+    init: {
+      type: "string",
+      required: true,
+      description: "Names of commands to initialize (space-separated or quoted)"
+    },
+    overwrite: {
+      type: "boolean",
+      default: false,
+      description: "Overwrite existing commands"
+    },
+    customCmdsRoot: {
+      type: "string",
+      default: "",
+      description: "Root directory for custom commands"
+    }
+  }),
+  async run({ args }) {
+    let cmdNames = [];
+    if (Array.isArray(args.init)) {
+      cmdNames = args.init;
+    } else if (typeof args.init === "string") {
+      cmdNames = args.init.split(/\s+/).filter(Boolean);
+    }
+    if (cmdNames.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 && cmdNames[0]) {
+          cmdNames = [cmdNames[0], ...additionalArgs];
+        }
+      }
+    }
+    if (cmdNames.length === 0) {
+      relinka("error", "\u274C No command names provided");
+      return;
+    }
+    let cmdsRoot = args.customCmdsRoot;
+    let cliFilePath = "";
+    if (!cmdsRoot) {
+      const defaultCmdsRoot = path.resolve("src/app");
+      if (await fs.pathExists(defaultCmdsRoot)) {
+        cmdsRoot = defaultCmdsRoot;
+      } else {
+        const { cmdsRoot: configCmdsRoot, cliFile } = await handleDlerConfig();
+        cmdsRoot = configCmdsRoot;
+        cliFilePath = cliFile;
+      }
+    } else {
+      cmdsRoot = path.resolve(cmdsRoot);
+    }
+    relinka(
+      "info",
+      `\u{1F680} Creating ${cmdNames.length} command(s): ${cmdNames.join(", ")}`
+    );
+    for (const cmdName of cmdNames) {
+      const dirPath = path.join(cmdsRoot, cmdName);
+      const filePath = path.join(dirPath, "cmd.ts");
+      if (await fs.pathExists(filePath) && !args.overwrite) {
+        relinka(
+          "warn",
+          `\u274C Command "${cmdName}" already exists. Use --overwrite to overwrite.`
+        );
+        continue;
+      }
+      await fs.ensureDir(dirPath);
+      const content = generateCommandTemplate(cmdName);
+      await fs.writeFile(filePath, content, "utf-8");
+      relinka("log", `\u2705 Created new command: ${filePath}`);
+    }
+    if (cliFilePath) {
+      relinka(
+        "info",
+        "\u{1F4E6} Make sure you have @reliverse/rempts installed: bun add @reliverse/rempts"
+      );
+    }
+  }
+});
+async function handleDlerConfig() {
+  const dlerConfigPath = path.resolve(".config/dler.ts");
+  let cmdsRoot = "src/app";
+  let cliFilePath = "";
+  try {
+    const jiti = createJiti(import.meta.url);
+    const dlerConfig = await jiti.import(dlerConfigPath, {
+      default: true
+    });
+    const coreIsCLI = dlerConfig?.coreIsCLI;
+    if (!coreIsCLI?.enabled || !coreIsCLI?.scripts) {
+      cliFilePath = await ensureCliFile("src/cli.ts");
+      cmdsRoot = "src/app";
+    } else {
+      const firstScript = Object.values(coreIsCLI.scripts)[0];
+      const scriptPath = path.resolve(firstScript);
+      if (await fs.pathExists(scriptPath)) {
+        const content = await fs.readFile(scriptPath, "utf-8");
+        if (content.includes("@reliverse/rempts")) {
+          if (content.includes("runMain")) {
+            const cmdsRootMatch = content.match(
+              /cmdsRootPath:\s*["']([^"']+)["']/
+            );
+            if (cmdsRootMatch?.[1]) {
+              cmdsRoot = path.resolve(cmdsRootMatch[1]);
+            }
+          }
+        } else {
+          relinka("warn", `\u274C ${scriptPath} doesn't use @reliverse/rempts`);
+          cmdsRoot = "src/app";
+        }
+      } else {
+        cliFilePath = await ensureCliFile(scriptPath);
+        cmdsRoot = "src/app";
+      }
+    }
+  } catch {
+    cliFilePath = await ensureCliFile("src/cli.ts");
+    cmdsRoot = "src/app";
+  }
+  return { cmdsRoot: path.resolve(cmdsRoot), cliFile: cliFilePath };
+}
+async function ensureCliFile(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  if (!await fs.pathExists(resolvedPath)) {
+    await fs.ensureDir(path.dirname(resolvedPath));
+    await fs.writeFile(resolvedPath, cliTemplate, "utf-8");
+    relinka("log", `\u2705 Created CLI entry file: ${resolvedPath}`);
+    return resolvedPath;
+  }
+  return "";
+}

package/bin/app/rempts/cmd/templates.d.ts

@@ -0,0 +1,2 @@
+export declare function generateCommandTemplate(cmdName: string): string;
+export declare const cliTemplate = "import { defineCommand, runMain } from \"@reliverse/rempts\";\n  \n  await runMain(\n    defineCommand({\n      // empty object activates file-based\n      // commands in the src/app directory\n    }),\n  );\n  ";

package/bin/app/rempts/cmd/templates.js

@@ -0,0 +1,30 @@
+export function generateCommandTemplate(cmdName) {
+  return `import { defineCommand, defineArgs } from "@reliverse/rempts";
+  export default defineCommand({
+    meta: {
+      name: "${cmdName}",
+      version: "1.0.0",
+      description: "Describe what ${cmdName} command does.",
+    },
+    args: defineArgs({
+      exampleArg: {
+        type: "string",
+        default: "defaultValue",
+        description: "An example argument",
+      },
+    }),
+    async run({ args }) {
+      console.log("Command '${cmdName}' executed.");
+      console.log("Received args:", args);
+    },
+  });
+  `;
+}
+export const cliTemplate = `import { defineCommand, runMain } from "@reliverse/rempts";
+  await runMain(
+    defineCommand({
+      // empty object activates file-based
+      // commands in the src/app directory
+    }),
+  );
+  `;

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

@@ -7,10 +7,8 @@ declare const _default: import("@reliverse/rempts").Command<{
     cmdDirs: {
         type: "array";
         description: string;
-        default: never[];
-        options: string[];
     };
-    force: {
+    overwrite: {
         type: "boolean";
         default: false;
         description: string;

package/bin/app/rempts/{init/cmds → cmdsTs}/cmd.js

@@ -1,14 +1,14 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { defineCommand } from "@reliverse/rempts";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
 export default defineCommand({
   meta: {
     name: "cmds",
     version: "1.0.0",
     description: "Generate command exports file for cmd.ts files."
   },
-  args: {
+  args: defineArgs({
     outFile: {
       type: "string",
       description: "Output file path (relative to workspace root)",
@@ -16,23 +16,21 @@ export default defineCommand({
     },
     cmdDirs: {
       type: "array",
-      description: "Command directories to scan (relative to src/app)",
-      default: [],
-      options: ["relifso", "inject", "rempts"]
+      description: "Command directories to scan (relative to src/app)"
     },
-    force: {
+    overwrite: {
       type: "boolean",
       default: false,
-      description: "Overwrite existing file"
+      description: "Overwrite existing file (default: false)"
     }
-  },
+  }),
   async run({ args }) {
     const root = path.resolve("src/app");
     const outPath = path.resolve(args.outFile ?? "src/app/cmds.ts");
-    if (await fs.pathExists(outPath) && !args.force) {
+    if (await fs.pathExists(outPath) && !args.overwrite) {
       relinka(
         "warn",
-        `\u274C File "${outPath}" already exists. Use --force to overwrite.`
+        `\u274C File "${outPath}" already exists. Use --overwrite to overwrite.`
       );
       return;
     }
@@ -46,6 +44,25 @@ export default defineCommand({
     await fs.writeFile(outPath, exports, "utf-8");
     relinka("success", `\u2705 Generated command exports at: ${outPath}`);
     relinka("log", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
+    relinka(
+      "log",
+      `Usage example:
+import { getCmdName } from "../../cmds.js";
+await runCmd(await getCmdName(), [
+  // String arguments
+  "--name=my-project",
+  "--path=./src",
+  // Boolean flags
+  "--force",
+  "--no-cache",
+  // Number values
+  "--port=3000",
+  // Array values
+  "--files=file1.ts,file2.ts",
+  // Positional arguments (must come last)
+  "--build=src/1.ts src/2.ts",
+]);`
+    );
   }
 });
 async function findCommandDirs(root) {
@@ -58,9 +75,8 @@ async function findCommandDirs(root) {
         if (await fs.pathExists(path.join(fullPath, "cmd.ts"))) {
           const relPath = path.relative(root, fullPath);
           cmdDirs.push(relPath);
-        } else {
-          await scan(fullPath);
         }
+        await scan(fullPath);
       }
     }
   }
@@ -74,7 +90,8 @@ function generateExports(cmdDirs) {
   return (await import("./${dir}/cmd")).default;
 }`;
   });
-  return `// Generated command exports - DO NOT EDIT
+  return `// this file is auto-generated by
+// dler rempts cmdsTs --overwrite
 ${imports.join("\n\n")}
 `;
 }

package/bin/cli.js

@@ -8,7 +8,7 @@ import {
   runCmd
 } from "@reliverse/rempts";
 import { promptAggCommand } from "./app/agg/run.js";
-import { cmdBuild, cmdPub } from "./app/cmds.js";
+import { getCmdBuild, getCmdPub } from "./app/cmds.js";
 import { showEndPrompt, showStartPrompt } from "./init/info.js";
 const INTERACTIVE_CMDS = ["agg", "build", "pub"];
 const main = defineCommand({
@@ -48,10 +48,10 @@ Available interactive commands: ${INTERACTIVE_CMDS.join(", ")}`
       await promptAggCommand();
     }
     if (cmdToRun === "build") {
-      await runCmd(await cmdBuild(), [`--dev=${args.dev}`]);
+      await runCmd(await getCmdBuild(), [`--dev=${args.dev}`]);
     }
     if (cmdToRun === "pub") {
-      await runCmd(await cmdPub(), [`--dev=${args.dev}`]);
+      await runCmd(await getCmdPub(), [`--dev=${args.dev}`]);
     }
     relinka("log", " ");
     await showEndPrompt();

package/bin/init/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.6.1";
+const version = "1.6.2";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/init/load.d.ts

@@ -1,6 +1,6 @@
-import type { BuildPublishConfig } from "../libs/sdk/sdk-types.js";
+import type { DlerConfig } from "../libs/sdk/sdk-types.js";
 /**
  * Searches for and loads the configuration file `.config/dler.ts`.
  * Falls back to default configuration if the file is not found.
  */
-export declare function loadConfig(): Promise<BuildPublishConfig>;
+export declare function loadConfig(): Promise<DlerConfig>;

package/bin/libs/sdk/default.d.ts

@@ -1,5 +1,5 @@
-import type { BuildPublishConfig } from "./sdk-types.js";
+import type { DlerConfig } from "./sdk-types.js";
 /**
  * Default configuration for the build and publish logic.
  */
-export declare const DEFAULT_CONFIG: BuildPublishConfig;
+export declare const DEFAULT_CONFIG: DlerConfig;

package/bin/libs/sdk/sdk-impl/build/build-library.d.ts

@@ -1,5 +1,5 @@
 import type { PerfTimer } from "../../sdk-types.js";
-import type { BundlerName, BuildPublishConfig, Esbuild, LibConfig, NpmOutExt, Sourcemap, transpileFormat, transpileTarget } from "../../sdk-types.js";
+import type { BundlerName, DlerConfig, Esbuild, LibConfig, NpmOutExt, Sourcemap, transpileFormat, transpileTarget } from "../../sdk-types.js";
 /** Options specific to the NPM build target */
 type NpmBuildOptions = {
     npmOutDir: string;
@@ -13,7 +13,7 @@ type JsrBuildOptions = {
     distJsrOutFilesExt: NpmOutExt;
 };
 /** Consolidated options for the main library build function */
-export type LibraryBuildOptions = BuildPublishConfig & {
+export type LibraryBuildOptions = DlerConfig & {
     effectivePubRegistry: "npm" | "jsr" | "npm-jsr" | undefined;
     npm?: NpmBuildOptions;
     jsr?: JsrBuildOptions;

package/bin/libs/sdk/sdk-impl/build/build-regular.d.ts

@@ -1,4 +1,4 @@
-import type { BundlerName, NpmOutExt, Sourcemap, transpileFormat, transpileTarget, BuildPublishConfig, PerfTimer } from "../../sdk-types.js";
+import type { BundlerName, NpmOutExt, Sourcemap, transpileFormat, transpileTarget, DlerConfig, PerfTimer } from "../../sdk-types.js";
 /**
  * Builds a regular JSR distribution.
  * - Copies the entire source directory if `distJsrBuilder` = "jsr"
@@ -7,13 +7,13 @@ import type { BundlerName, NpmOutExt, Sourcemap, transpileFormat, transpileTarge
 export declare function regular_buildJsrDist(isDev: boolean, isJsr: boolean, coreIsCLI: {
     enabled: boolean;
     scripts: Record<string, string>;
-}, coreEntrySrcDir: string, distJsrDirName: string, distJsrBuilder: BundlerName, coreEntryFile: string, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileMinify: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, unifiedBundlerOutExt: NpmOutExt, config: BuildPublishConfig, timer: PerfTimer, transpileStub: boolean, transpileWatch: boolean, distJsrGenTsconfig: boolean, coreDeclarations: boolean): Promise<void>;
+}, coreEntrySrcDir: string, distJsrDirName: string, distJsrBuilder: BundlerName, coreEntryFile: string, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileMinify: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, unifiedBundlerOutExt: NpmOutExt, config: DlerConfig, timer: PerfTimer, transpileStub: boolean, transpileWatch: boolean, distJsrGenTsconfig: boolean, coreDeclarations: boolean): Promise<void>;
 /**
  * Builds a regular NPM distribution.
  * - Copies entire src dir if "jsr"
  * - Otherwise uses Bun or a unified builder
  */
-export declare function regular_buildNpmDist(isDev: boolean, coreEntrySrcDir: string, distNpmDirName: string, distNpmBuilder: BundlerName, coreEntryFile: string, unifiedBundlerOutExt: NpmOutExt, config: BuildPublishConfig, coreIsCLI: {
+export declare function regular_buildNpmDist(isDev: boolean, coreEntrySrcDir: string, distNpmDirName: string, distNpmBuilder: BundlerName, coreEntryFile: string, unifiedBundlerOutExt: NpmOutExt, config: DlerConfig, coreIsCLI: {
     enabled: boolean;
     scripts: Record<string, string>;
 }, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileMinify: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, transpileStub: boolean, transpileWatch: boolean, timer: PerfTimer, coreDeclarations: boolean): Promise<void>;

package/bin/libs/sdk/sdk-impl/library-flow.d.ts

@@ -1,8 +1,8 @@
-import type { BundlerName, Esbuild, LibConfig, NpmOutExt, Sourcemap, transpileFormat, transpileTarget, BuildPublishConfig, PerfTimer } from "../sdk-types.js";
+import type { BundlerName, Esbuild, LibConfig, NpmOutExt, Sourcemap, transpileFormat, transpileTarget, DlerConfig, PerfTimer } from "../sdk-types.js";
 /**
  * Processes libraries based on build mode.
  */
-export declare function processLibraryFlow(timer: PerfTimer, isDev: boolean, config: BuildPublishConfig): Promise<void>;
+export declare function processLibraryFlow(timer: PerfTimer, isDev: boolean, config: DlerConfig): Promise<void>;
 /**
  * Processes all libs defined in config.libsList.
  * Builds and optionally publishes each library based on configuration.
@@ -15,4 +15,4 @@ export declare function libraries_buildPublish(isDev: boolean, timer: PerfTimer,
         npm: string[];
         jsr: string[];
     }>;
-}, transpileEsbuild: Esbuild, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, distJsrBuilder: BundlerName, transpileStub: boolean, transpileWatch: boolean, distJsrOutFilesExt: NpmOutExt, distJsrAllowDirty: boolean, distJsrSlowTypes: boolean, config: BuildPublishConfig): Promise<void>;
+}, transpileEsbuild: Esbuild, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, distJsrBuilder: BundlerName, transpileStub: boolean, transpileWatch: boolean, distJsrOutFilesExt: NpmOutExt, distJsrAllowDirty: boolean, distJsrSlowTypes: boolean, config: DlerConfig): Promise<void>;

package/bin/libs/sdk/sdk-impl/regular-flow.d.ts

@@ -1,5 +1,5 @@
-import type { BuildPublishConfig, PerfTimer } from "../sdk-types.js";
+import type { DlerConfig, PerfTimer } from "../sdk-types.js";
 /**
  * Processes the main project based on build mode and commonPubRegistry.
  */
-export declare function processRegularFlow(timer: PerfTimer, isDev: boolean, config: BuildPublishConfig): Promise<void>;
+export declare function processRegularFlow(timer: PerfTimer, isDev: boolean, config: DlerConfig): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/utils-deps.d.ts

@@ -1,5 +1,5 @@
-import type { BuildPublishConfig } from "../../sdk-types.js";
+import type { DlerConfig } from "../../sdk-types.js";
 /**
  * Filters out development dependencies from a dependency record.
  */
-export declare function filterDeps(deps: Record<string, string> | undefined, clearUnused: boolean, outDirBin: string, isJsr: boolean, config: BuildPublishConfig, libName?: string): Promise<Record<string, string>>;
+export declare function filterDeps(deps: Record<string, string> | undefined, clearUnused: boolean, outDirBin: string, isJsr: boolean, config: DlerConfig, libName?: string): Promise<Record<string, string>>;

package/bin/libs/sdk/sdk-impl/utils/utils-pkg-json-libs.d.ts

@@ -1,5 +1,5 @@
-import type { NpmOutExt, BuildPublishConfig, LibConfig } from "../../sdk-types.js";
+import type { NpmOutExt, DlerConfig, LibConfig } from "../../sdk-types.js";
 /**
  * Creates a package.json for a lib distribution.
  */
-export declare function library_createPackageJSON(libName: string, npmOutDir: string, jsrOutDir: string, effectivePubRegistry: "npm" | "jsr" | "npm-jsr" | undefined, libsList: Record<string, LibConfig>, config: BuildPublishConfig, unifiedBundlerOutExt: NpmOutExt): Promise<void>;
+export declare function library_createPackageJSON(libName: string, npmOutDir: string, jsrOutDir: string, effectivePubRegistry: "npm" | "jsr" | "npm-jsr" | undefined, libsList: Record<string, LibConfig>, config: DlerConfig, unifiedBundlerOutExt: NpmOutExt): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/utils-pkg-json-reg.d.ts

@@ -1,8 +1,8 @@
-import type { NpmOutExt, BuildPublishConfig } from "../../sdk-types.js";
+import type { NpmOutExt, DlerConfig } from "../../sdk-types.js";
 /**
  * Creates a package.json for the main distribution.
  */
 export declare function regular_createPackageJSON(outDirRoot: string, isJsr: boolean, coreIsCLI: {
     enabled: boolean;
     scripts: Record<string, string>;
-}, unifiedBundlerOutExt: NpmOutExt, config: BuildPublishConfig, coreDescription: string, coreBuildOutDir?: string): Promise<void>;
+}, unifiedBundlerOutExt: NpmOutExt, config: DlerConfig, coreDescription: string, coreBuildOutDir?: string): Promise<void>;

package/bin/libs/sdk/sdk-types.d.ts

@@ -10,7 +10,7 @@ import type { Schema } from "untyped";
  * build settings, publishing options, libraries-dler-plugin built-in plugin, and more.
  * It customizes the build and publish pipeline for both NPM and JSR registries.
  */
-export type BuildPublishConfig = {
+export type DlerConfig = {
     /**
      * When `true`, disables version bumping.
      * Useful when retrying a failed publish with an already bumped version.

package/bin/mod.d.ts

@@ -1,2 +1,2 @@
-import type { BuildPublishConfig } from "./libs/sdk/sdk-types.js";
-export declare const defineConfig: (userConfig?: Partial<BuildPublishConfig>) => any;
+import type { DlerConfig } from "./libs/sdk/sdk-types.js";
+export declare const defineConfig: (userConfig?: Partial<DlerConfig>) => any;

package/package.json

@@ -15,7 +15,7 @@
     "@rollup/pluginutils": "^5.1.4",
     "chalk": "^5.4.1",
     "defu": "^6.1.4",
-    "esbuild": "^0.25.4",
+    "esbuild": "^0.25.5",
     "execa": "^9.6.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
     "glob": "^11.0.2",
@@ -41,7 +41,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "keywords": [
     "reliverse",
     "cli",

package/bin/app/rempts/init/cmd/cmd.js

@@ -1,67 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { defineCommand } from "@reliverse/rempts";
-export default defineCommand({
-  meta: {
-    name: "init",
-    version: "1.0.0",
-    description: "Scaffold new CLI commands quickly."
-  },
-  args: {
-    cmd: {
-      type: "array",
-      required: true,
-      description: "Names of commands to initialize",
-      options: ["cmd1", "cmd2", "cmd3"]
-    },
-    force: {
-      type: "boolean",
-      default: false,
-      description: "Overwrite existing commands"
-    }
-  },
-  async run({ args }) {
-    const root = path.resolve("src/app");
-    for (const cmdName of args.cmd) {
-      const dirPath = path.join(root, cmdName);
-      const filePath = path.join(dirPath, "index.ts");
-      if (await fs.pathExists(filePath) && !args.force) {
-        relinka(
-          "warn",
-          `\u274C Command "${cmdName}" already exists. Use --force to overwrite.`
-        );
-        continue;
-      }
-      fs.mkdirSync(dirPath, {
-        recursive: true
-      });
-      const content = generateCommandTemplate(cmdName);
-      fs.writeFileSync(filePath, content, "utf-8");
-      relinka("log", `\u2705 Created new command: ${filePath}`);
-    }
-  }
-});
-function generateCommandTemplate(cmdName) {
-  return `import { relinka } from "@reliverse/relinka";
-import { defineCommand } from "@reliverse/rempts";
-export default defineCommand({
-  meta: {
-    name: "${cmdName}",
-    version: "1.0.0",
-    description: "Describe what ${cmdName} command does.",
-  },
-  args: {
-    exampleArg: {
-      type: "string",
-      default: "defaultValue",
-      description: "An example argument",
-    },
-  },
-  async run({ args }) {
-    relinka("log", "Command '${cmdName}' executed.");
-    relinka("log", "Received args:", args);
-  },
-});
-`;
-}