@reliverse/dler 1.7.72 → 1.7.74

package/bin/app/build/postbuild.js

@@ -14,6 +14,7 @@ export async function dlerPostBuild(isDev, debugDontCopyNonBuildFiles) {
   relinka("info", "\u2014 \u2014 \u2014 dlerPostBuild \u2014 \u2014 \u2014");
   const config = await getConfigDler();
   await resolveAllCrossLibs(
+    "package",
     ALIAS_TO_REPLACE,
     ["npm", "jsr"],
     config.buildPreExtensions,

package/bin/app/cmds.d.ts

@@ -1,19 +1,245 @@
 import type { Command } from "@reliverse/rempts";
+interface CommandArgsMap {
+    agg: {
+        imports?: boolean;
+        input?: string;
+        named?: boolean;
+        out?: string;
+        recursive?: boolean;
+        strip?: string;
+        sort?: boolean;
+        header?: string;
+        verbose?: boolean;
+        includeInternal?: boolean;
+        internalMarker?: string;
+        override?: boolean;
+        extensions?: string;
+        separateTypesFile?: boolean;
+        typesOut?: string;
+        nonInteractive?: boolean;
+    };
+    build: {
+        dev?: boolean;
+        debugOnlyCopyNonBuildFiles?: boolean;
+        debugDontCopyNonBuildFiles?: boolean;
+    };
+    build_binary: {
+        input?: string;
+        targets?: string;
+        outdir?: string;
+        minify?: boolean;
+        sourcemap?: boolean;
+        bytecode?: boolean;
+        clean?: boolean;
+        parallel?: boolean;
+        external?: string[];
+    };
+    check: {
+        dev?: boolean;
+        directory?: string;
+        checks?: string;
+        strict?: boolean;
+        json?: boolean;
+        deps?: boolean;
+        all?: boolean;
+        ignore?: string;
+        builtins?: boolean;
+        peer?: boolean;
+        optional?: boolean;
+        fix?: boolean;
+        depth?: number;
+    };
+    conv: {};
+    create: {
+        template?: string;
+        mode?: "template" | "files";
+        fileType?: string;
+        destDir?: string;
+        multiple?: boolean;
+        parallel?: boolean;
+        concurrency?: string;
+        cwd?: string;
+    };
+    fs: {
+        mode: "copy" | "rm" | "rename";
+        target: string;
+        nonInteractive?: boolean;
+        source?: string;
+        destination?: string;
+        recursive?: boolean;
+        preserveStructure?: boolean;
+        increment?: boolean;
+        concurrency?: number;
+        gitignore?: boolean;
+        prepareMyCLI?: boolean;
+        revert?: boolean;
+        useDtsTxtForPrepareMyCLI?: boolean;
+    };
+    get: {};
+    init: {};
+    inject: {};
+    install: {
+        action?: string;
+        name?: string;
+        global?: boolean;
+        cwd?: string;
+        workspace?: boolean;
+        silent?: boolean;
+        recreateLockFile?: boolean;
+        linter?: boolean;
+    };
+    libs: {
+        init: string;
+        overwrite?: boolean;
+    };
+    magic: {
+        targets: string[];
+        lib?: string;
+        concurrency?: number;
+        batchSize?: number;
+        stopOnError?: boolean;
+        about?: boolean;
+    };
+    merge: {
+        s?: string[];
+        d?: string;
+        ignore?: string[];
+        format?: string;
+        stdout?: boolean;
+        noPath?: boolean;
+        pathAbove?: boolean;
+    };
+    migrate: {
+        interactive?: boolean;
+        codemod?: string;
+        project?: string;
+        mrTarget?: string;
+        dryRun?: boolean;
+        noBackup?: boolean;
+        consoleRelinkaInput?: string;
+        consoleRelinkaFrom?: string;
+        consoleRelinkaTo?: string;
+    };
+    mkdist: {
+        mkdistOnly?: boolean;
+        dev?: boolean;
+        dir?: string;
+        cwd?: string;
+        src?: string;
+        dist?: string;
+        clean?: boolean;
+        pattern?: string;
+        format?: string;
+        declaration?: boolean;
+        ext?: string;
+        jsx?: string;
+        jsxFactory?: string;
+        jsxFragment?: string;
+        loaders?: string;
+        minify?: boolean;
+        target?: string;
+    };
+    pack: {
+        input: string;
+        output?: string;
+        whitelabel?: string;
+        cdn?: string;
+        force?: boolean;
+        update?: boolean;
+        files?: string;
+        lastUpdate?: string;
+        unpack?: boolean;
+    };
+    pub: {
+        dev?: boolean;
+    };
+    remdn: {
+        mode?: "dirs-scan-only" | "dirs-scan-compare";
+        configPath?: string;
+        outputFilePath?: string;
+        initConfig?: string;
+    };
+    remove: {
+        action?: string;
+        name: string;
+        global?: boolean;
+        cwd?: string;
+        workspace?: boolean;
+        silent?: boolean;
+        linter?: boolean;
+        standalone?: boolean;
+    };
+    rempts: {
+        init?: string;
+        overwrite?: boolean;
+        customCmdsRoot?: string;
+        outFile?: string;
+        cmdDirs?: string[];
+    };
+    split: {
+        directory: string;
+        fileLineThreshold: number;
+        funcLineThreshold: number;
+    };
+    transform: {};
+    update: {
+        name?: string[];
+        ignore?: string[];
+        concurrency?: number;
+        linker?: "isolated" | "hoisted";
+        global?: boolean;
+        interactive?: boolean;
+    };
+    upgrade: {
+        interactive?: boolean;
+    };
+    x: {
+        action: string;
+        name?: string;
+        cwd?: string;
+        silent?: boolean;
+        target?: string;
+        timeout?: number;
+        throwOnError?: boolean;
+        args?: string;
+        global?: boolean;
+        yes?: boolean;
+        bun?: boolean;
+        npm?: boolean;
+        pnpm?: boolean;
+        yarn?: boolean;
+    };
+}
+export declare function loadTypedCommand<T extends keyof CommandArgsMap>(cmdName: T): Promise<Command>;
 export declare const getAggCmd: () => Promise<Command>;
 export declare const getBuildCmd: () => Promise<Command>;
+export declare const getBuildBinaryCmd: () => Promise<Command>;
 export declare const getCheckCmd: () => Promise<Command>;
 export declare const getConvCmd: () => Promise<Command>;
-export declare const getCopyCmd: () => Promise<Command>;
+export declare const getCreateCmd: () => Promise<Command>;
+export declare const getFsCmd: () => Promise<Command>;
+export declare const getGetCmd: () => Promise<Command>;
 export declare const getInitCmd: () => Promise<Command>;
 export declare const getInjectCmd: () => Promise<Command>;
+export declare const getInstallCmd: () => Promise<Command>;
 export declare const getLibsCmd: () => Promise<Command>;
+export declare const getMagicCmd: () => Promise<Command>;
 export declare const getMergeCmd: () => Promise<Command>;
 export declare const getMigrateCmd: () => Promise<Command>;
+export declare const getMkdistCmd: () => Promise<Command>;
+export declare const getPackCmd: () => Promise<Command>;
 export declare const getPubCmd: () => Promise<Command>;
+export declare const getRemdnCmd: () => Promise<Command>;
+export declare const getRemoveCmd: () => Promise<Command>;
 export declare const getRemptsCmd: () => Promise<Command>;
-export declare const getRenameCmd: () => Promise<Command>;
-export declare const getMagicCmd: () => Promise<Command>;
 export declare const getSplitCmd: () => Promise<Command>;
-export declare const getRmCmd: () => Promise<Command>;
+export declare const getTransformCmd: () => Promise<Command>;
 export declare const getUpdateCmd: () => Promise<Command>;
 export declare const getUpgradeCmd: () => Promise<Command>;
+export declare const getXCmd: () => Promise<Command>;
+export declare function callCmd<T extends keyof CommandArgsMap>(cmdName: T, args?: CommandArgsMap[T]): Promise<void>;
+export declare function getTypedCmd<T extends keyof CommandArgsMap>(cmdName: T): Promise<{
+    command: Command;
+    run: (args?: CommandArgsMap[T]) => Promise<void>;
+}>;
+export type { CommandArgsMap };

package/bin/app/cmds.js

@@ -1,19 +1,36 @@
-import { loadCommand } from "@reliverse/rempts";
-export const getAggCmd = async () => loadCommand("agg");
-export const getBuildCmd = async () => loadCommand("build");
-export const getCheckCmd = async () => loadCommand("check");
-export const getConvCmd = async () => loadCommand("conv");
-export const getCopyCmd = async () => loadCommand("copy");
-export const getInitCmd = async () => loadCommand("init");
-export const getInjectCmd = async () => loadCommand("inject");
-export const getLibsCmd = async () => loadCommand("libs");
-export const getMergeCmd = async () => loadCommand("merge");
-export const getMigrateCmd = async () => loadCommand("migrate");
-export const getPubCmd = async () => loadCommand("pub");
-export const getRemptsCmd = async () => loadCommand("rempts");
-export const getRenameCmd = async () => loadCommand("rename");
-export const getMagicCmd = async () => loadCommand("magic");
-export const getSplitCmd = async () => loadCommand("split");
-export const getRmCmd = async () => loadCommand("rm");
-export const getUpdateCmd = async () => loadCommand("update");
-export const getUpgradeCmd = async () => loadCommand("upgrade");
+import { loadCommand, callCmdImpl, getTypedCmdImpl } from "@reliverse/rempts";
+export async function loadTypedCommand(cmdName) {
+  return await loadCommand(cmdName);
+}
+export const getAggCmd = async () => loadTypedCommand("agg");
+export const getBuildCmd = async () => loadTypedCommand("build");
+export const getBuildBinaryCmd = async () => loadTypedCommand("build_binary");
+export const getCheckCmd = async () => loadTypedCommand("check");
+export const getConvCmd = async () => loadTypedCommand("conv");
+export const getCreateCmd = async () => loadTypedCommand("create");
+export const getFsCmd = async () => loadTypedCommand("fs");
+export const getGetCmd = async () => loadTypedCommand("get");
+export const getInitCmd = async () => loadTypedCommand("init");
+export const getInjectCmd = async () => loadTypedCommand("inject");
+export const getInstallCmd = async () => loadTypedCommand("install");
+export const getLibsCmd = async () => loadTypedCommand("libs");
+export const getMagicCmd = async () => loadTypedCommand("magic");
+export const getMergeCmd = async () => loadTypedCommand("merge");
+export const getMigrateCmd = async () => loadTypedCommand("migrate");
+export const getMkdistCmd = async () => loadTypedCommand("mkdist");
+export const getPackCmd = async () => loadTypedCommand("pack");
+export const getPubCmd = async () => loadTypedCommand("pub");
+export const getRemdnCmd = async () => loadTypedCommand("remdn");
+export const getRemoveCmd = async () => loadTypedCommand("remove");
+export const getRemptsCmd = async () => loadTypedCommand("rempts");
+export const getSplitCmd = async () => loadTypedCommand("split");
+export const getTransformCmd = async () => loadTypedCommand("transform");
+export const getUpdateCmd = async () => loadTypedCommand("update");
+export const getUpgradeCmd = async () => loadTypedCommand("upgrade");
+export const getXCmd = async () => loadTypedCommand("x");
+export async function callCmd(cmdName, args) {
+  await callCmdImpl(cmdName, args);
+}
+export async function getTypedCmd(cmdName) {
+  return await getTypedCmdImpl(cmdName);
+}

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

@@ -0,0 +1,18 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    mode: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    tool: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    update: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/config/cmd.js

@@ -0,0 +1,43 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { ensureConfigMod } from "../../libs/sdk/sdk-impl/config/core.js";
+export default defineCommand({
+  meta: {
+    name: "config",
+    description: "Manage project-level and device-global configurations"
+  },
+  args: defineArgs({
+    mode: {
+      type: "string",
+      description: "Config mode: copy-remote, copy-internal",
+      default: "copy-remote"
+    },
+    tool: {
+      type: "string",
+      description: "Tool name (e.g., dler, rse)",
+      default: "dler"
+    },
+    update: {
+      type: "boolean",
+      description: "Force update existing configuration",
+      default: false
+    }
+  }),
+  run: async ({ args }) => {
+    const { mode, tool, update } = args;
+    try {
+      await ensureConfigMod({
+        tool,
+        mode,
+        forceUpdate: update
+      });
+      relinka("success", `Configuration for ${tool} has been ${update ? "updated" : "created"}`);
+    } catch (error) {
+      relinka(
+        "error",
+        `Failed to manage config: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  }
+});

package/bin/app/config/impl/typebox.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a JSON schema file from the TypeBox schema
+ */
+export declare function generateJsonSchema(typeboxSchema: any, outputPath: string): Promise<void>;
+/**
+ * Generates the schema.json in the project root
+ */
+export declare function generateSchemaFile(schema: any): Promise<void>;

package/bin/app/config/impl/typebox.js

@@ -0,0 +1,82 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+function convertTypeBoxToJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema.type === "string" && schema.enum) {
+    return {
+      type: "string",
+      enum: schema.enum
+    };
+  }
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    const variants = schema.anyOf || schema.allOf || schema.oneOf;
+    const allLiterals = variants.every((v) => v.const !== void 0);
+    if (allLiterals) {
+      return {
+        type: "string",
+        enum: variants.map((v) => v.const)
+      };
+    }
+  }
+  if (schema.type === "object") {
+    const result = {
+      type: "object",
+      properties: {}
+    };
+    if (schema.required) {
+      result.required = schema.required;
+    }
+    if (schema.properties) {
+      for (const [key, value] of Object.entries(schema.properties)) {
+        result.properties[key] = convertTypeBoxToJsonSchema(value);
+      }
+    }
+    if (schema.additionalProperties) {
+      result.additionalProperties = convertTypeBoxToJsonSchema(schema.additionalProperties);
+    }
+    if (schema.patternProperties) {
+      result.patternProperties = {};
+      for (const [pattern, value] of Object.entries(schema.patternProperties)) {
+        result.patternProperties[pattern] = convertTypeBoxToJsonSchema(value);
+      }
+    }
+    return result;
+  }
+  if (schema.type === "array") {
+    return {
+      type: "array",
+      items: convertTypeBoxToJsonSchema(schema.items)
+    };
+  }
+  if (schema.type) {
+    const result = { type: schema.type };
+    if (schema.minimum !== void 0) result.minimum = schema.minimum;
+    if (schema.maximum !== void 0) result.maximum = schema.maximum;
+    if (schema.minLength !== void 0) result.minLength = schema.minLength;
+    if (schema.maxLength !== void 0) result.maxLength = schema.maxLength;
+    if (schema.pattern !== void 0) result.pattern = schema.pattern;
+    if (schema.format !== void 0) result.format = schema.format;
+    if (schema.default !== void 0) result.default = schema.default;
+    return result;
+  }
+  return schema;
+}
+export async function generateJsonSchema(typeboxSchema, outputPath) {
+  const converted = convertTypeBoxToJsonSchema(typeboxSchema);
+  const schema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title: "rse configuration schema",
+    description: "https://docs.reliverse.org",
+    type: "object",
+    properties: converted.properties,
+    required: converted.required
+  };
+  await fs.writeFile(outputPath, JSON.stringify(schema, null, 2));
+}
+export async function generateSchemaFile(schema) {
+  const schemaPath = path.join(process.cwd(), "schema.json");
+  if (fs.existsSync(schemaPath)) {
+    await fs.remove(schemaPath);
+  }
+  await generateJsonSchema(schema, schemaPath);
+}

package/bin/app/mkdist/cmd.js

@@ -2,7 +2,7 @@ import { resolve } from "@reliverse/pathkit";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerBuild } from "../build/impl.js";
 import { mkdist } from "../../libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/make.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/prepare.js";
 export default defineCommand({
   meta: {
     name: "mkdist",

package/bin/app/pub/cmd.js

@@ -1,7 +1,7 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerPub } from "./impl.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
 import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/prepare.js";
 export default defineCommand({
   meta: {
     name: "pub",

package/bin/app/rempts/cmd.js

@@ -115,7 +115,7 @@ export default defineCommand({
         relinka("warn", `\u274C File "${outPath2}" already exists. Use --overwrite to overwrite.`);
         return;
       }
-      const exports2 = generateExports(cmdDirs2);
+      const exports2 = await generateExports(cmdDirs2);
       await fs.ensureDir(path.dirname(outPath2));
       await fs.writeFile(outPath2, exports2, "utf8");
       relinka("success", `\u2705 Generated command exports at: ${outPath2}`);
@@ -133,7 +133,7 @@ export default defineCommand({
       relinka("warn", "No command directories found with cmd.ts or cmd.js files.");
       return;
     }
-    const exports = generateExports(cmdDirs);
+    const exports = await generateExports(cmdDirs);
     await fs.ensureDir(path.dirname(outPath));
     await fs.writeFile(outPath, exports, "utf8");
     relinka("success", `\u2705 Generated command exports at: ${outPath}`);
@@ -232,22 +232,160 @@ async function findCommandDirs(root) {
   await scan(root);
   return cmdDirs;
 }
-function generateExports(cmdDirs) {
+async function generateCommandArgsMap(cmdDirs) {
+  let interfaceContent = "// Argument types for each command based on their defineArgs\ninterface CommandArgsMap {\n";
+  for (const dir of cmdDirs) {
+    const cmdPath = path.join("src/app", dir, "cmd.ts");
+    try {
+      if (await fs.pathExists(cmdPath)) {
+        const content = await fs.readFile(cmdPath, "utf-8");
+        const args = extractArgsFromContent(content);
+        const keyName = dir.replace(/[/\\]/g, "_");
+        interfaceContent += `  "${keyName}": {
+`;
+        if (args.length > 0) {
+          for (const arg of args) {
+            let tsType;
+            switch (arg.type) {
+              case "boolean":
+                tsType = "boolean";
+                break;
+              case "number":
+                tsType = "number";
+                break;
+              case "array":
+                tsType = "string[]";
+                break;
+              case "string":
+                if (arg.allowed) {
+                  tsType = arg.allowed.map((v) => `"${v}"`).join(" | ");
+                } else {
+                  tsType = "string";
+                }
+                break;
+              default:
+                tsType = "string";
+            }
+            const optional = arg.required ? "" : "?";
+            interfaceContent += `    ${arg.name}${optional}: ${tsType};
+`;
+          }
+        } else {
+          interfaceContent += `    // No arguments defined
+`;
+        }
+        interfaceContent += "  };\n";
+      } else {
+        const keyName = dir.replace(/[/\\]/g, "_");
+        interfaceContent += `  "${keyName}": Record<string, unknown>;
+`;
+      }
+    } catch (error) {
+      const keyName = dir.replace(/[/\\]/g, "_");
+      interfaceContent += `  "${keyName}": Record<string, unknown>;
+`;
+    }
+  }
+  interfaceContent += "}";
+  return interfaceContent;
+}
+function extractArgsFromContent(content) {
+  const args = [];
+  const defineArgsMatch = content.match(/defineArgs\(\s*\{([\s\S]*?)\}\s*\)/);
+  if (!defineArgsMatch?.[1]) return args;
+  const argsBlock = defineArgsMatch[1];
+  const argMatches = argsBlock.matchAll(/(\w+):\s*\{([^}]*)\}/g);
+  for (const match of argMatches) {
+    const argName = match[1];
+    const argProps = match[2];
+    if (!argName || !argProps) continue;
+    const typeMatch = argProps.match(/type:\s*["']([^"']+)["']/);
+    const type = typeMatch?.[1] || "string";
+    const requiredMatch = argProps.match(/required:\s*(true|false)/);
+    const required = requiredMatch?.[1] === "true";
+    const defaultMatch = argProps.match(/default:\s*([^,\n]+)/);
+    let defaultValue;
+    if (defaultMatch?.[1]) {
+      const defaultStr = defaultMatch[1].trim();
+      try {
+        defaultValue = JSON.parse(defaultStr);
+      } catch {
+        defaultValue = defaultStr.replace(/["']/g, "");
+      }
+    }
+    const allowedMatch = argProps.match(/allowed:\s*\[([^\]]+)\]/);
+    let allowed;
+    if (allowedMatch?.[1]) {
+      allowed = allowedMatch[1].split(",").map((s) => s.trim().replace(/["']/g, ""));
+    }
+    args.push({
+      name: argName,
+      type,
+      required,
+      default: defaultValue,
+      allowed
+    });
+  }
+  return args;
+}
+async function generateExports(cmdDirs) {
   const lines = [
-    "// this file is auto-(re)generated by `dler rempts`",
+    "// autogenerated by `dler rempts`",
+    "// don't edit this file manually",
     "",
     'import type { Command } from "@reliverse/rempts";',
     "",
-    'import { loadCommand } from "@reliverse/rempts";',
+    'import { loadCommand, callCmdImpl, getTypedCmdImpl } from "@reliverse/rempts";'
+  ];
+  lines.push("", "// ========== TYPED COMMAND SYSTEM ==========", "");
+  const commandArgsMap = await generateCommandArgsMap(cmdDirs);
+  lines.push(commandArgsMap);
+  lines.push(
+    "",
+    "// Typed loadCommand wrapper with intellisense",
+    "export async function loadTypedCommand<T extends keyof CommandArgsMap>(",
+    "  cmdName: T",
+    "): Promise<Command> {",
+    "  return await loadCommand(cmdName as string);",
+    "}",
+    ""
+  );
+  const traditionalExports = [
+    "",
+    "// ========== TRADITIONAL COMMAND EXPORTS (with typed intellisense) ==========",
     ""
   ];
   for (const dir of cmdDirs) {
     const funcName = "get" + dir.split(/[/\\]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).replace(/[^a-zA-Z0-9]/g, "")).join("") + "Cmd";
-    lines.push(
-      `export const ${funcName} = async (): Promise<Command> => loadCommand("${dir}");`,
-      ""
+    const keyName = dir.replace(/[/\\]/g, "_");
+    traditionalExports.push(
+      `export const ${funcName} = async (): Promise<Command> => loadTypedCommand("${keyName}");`
     );
   }
+  lines.push(...traditionalExports);
+  lines.push(
+    "",
+    "// Typed command functions with type safety",
+    "export async function callCmd<T extends keyof CommandArgsMap>(",
+    "  cmdName: T,",
+    "  args?: CommandArgsMap[T]",
+    "): Promise<void> {",
+    "  await callCmdImpl<CommandArgsMap>(cmdName, args);",
+    "}",
+    "",
+    "export async function getTypedCmd<T extends keyof CommandArgsMap>(",
+    "  cmdName: T",
+    "): Promise<{",
+    "  command: Command;",
+    "  run: (args?: CommandArgsMap[T]) => Promise<void>;",
+    "}> {",
+    "  return await getTypedCmdImpl<CommandArgsMap>(cmdName);",
+    "}",
+    "",
+    "// Export type for external use",
+    "export type { CommandArgsMap };",
+    ""
+  );
   return lines.join("\n");
 }
 function generateCommandTemplate(cmdName) {