@reliverse/dler 1.2.0

package/bin/libs/sdk/sdk-impl/utils/utils-pkg-json-libs.js

@@ -0,0 +1,259 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import path from "pathe";
+import {
+  definePackageJSON,
+  readPackageJSON
+} from "pkg-types";
+import { filterDeps } from "./utils-deps.js";
+export async function library_createPackageJSON(libName, outDirRoot, isJsr, libsList, rmDepsMode, rmDepsPatterns, unifiedBundlerOutExt) {
+  relinka(
+    "verbose",
+    `Generating package.json for lib ${libName} (isJsr=${isJsr})...`
+  );
+  if (!libsList) {
+    throw new Error("libsList is empty or not provided");
+  }
+  const originalPkg = await readPackageJSON();
+  let { description } = originalPkg;
+  const { author, keywords, license, version } = originalPkg;
+  if (libsList?.[libName]?.libDescription) {
+    description = libsList[libName].libDescription;
+    relinka(
+      "verbose",
+      `Using ${libName}'s description from config: "${description}"`
+    );
+  } else {
+    description = description || `${libName} is a helper library.`;
+    relinka(
+      "verbose",
+      `Using default helper library description: "${description}"`
+    );
+  }
+  const commonPkg = {
+    description,
+    license: license || "MIT",
+    name: libName,
+    type: "module",
+    version
+  };
+  if (author) {
+    const repoOwner = typeof author === "string" ? author : author.name;
+    const repoName = originalPkg.name ? originalPkg.name.startsWith("@") ? originalPkg.name.split("/").pop() || originalPkg.name : originalPkg.name : "";
+    Object.assign(commonPkg, {
+      author,
+      bugs: {
+        email: "blefnk@gmail.com",
+        url: `https://github.com/${repoOwner}/${repoName}/issues`
+      },
+      keywords: [.../* @__PURE__ */ new Set([author, ...keywords || []])],
+      repository: {
+        type: "git",
+        url: `git+https://github.com/${repoOwner}/${repoName}.git`
+      }
+    });
+  } else if (keywords && keywords.length > 0 && !commonPkg.keywords) {
+    commonPkg.keywords = keywords;
+  }
+  const outDirBin = path.join(outDirRoot, "bin");
+  if (isJsr) {
+    relinka("verbose", `Creating JSR package.json for lib ${libName}...`);
+    await library_writeJsrPackageJSON(
+      libName,
+      outDirBin,
+      outDirRoot,
+      originalPkg,
+      commonPkg,
+      libsList,
+      rmDepsMode,
+      rmDepsPatterns
+    );
+  } else {
+    relinka("verbose", `Creating NPM package.json for lib ${libName}...`);
+    await library_writeNpmLibPackageJSON(
+      libName,
+      outDirBin,
+      outDirRoot,
+      originalPkg,
+      commonPkg,
+      libsList,
+      rmDepsMode,
+      rmDepsPatterns,
+      unifiedBundlerOutExt
+    );
+  }
+  relinka("verbose", `Completed creation of package.json for lib: ${libName}`);
+}
+async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr, libConfig, rmDepsMode, rmDepsPatterns) {
+  relinka("verbose", `Getting lib dependencies for: ${libName}`);
+  if (!originalDeps) return {};
+  if (!libConfig) {
+    const result2 = await filterDeps(
+      originalDeps,
+      true,
+      outDirBin,
+      isJsr,
+      rmDepsMode,
+      rmDepsPatterns
+    );
+    relinka(
+      "verbose",
+      `Lib ${libName} dependencies filtered by usage, count: ${Object.keys(result2).length}`
+    );
+    return result2;
+  }
+  if (libConfig.libPkgKeepDeps === true) {
+    relinka("info", `Preserving all dependencies for lib ${libName}`);
+    const originalPkg = await readPackageJSON();
+    const devDeps = originalDeps === originalPkg.devDependencies;
+    const result2 = Object.entries(originalDeps).reduce(
+      (acc, [k, v]) => {
+        let shouldExclude = false;
+        if (rmDepsMode === "patterns-only") {
+          shouldExclude = rmDepsPatterns.some(
+            (pattern) => k.toLowerCase().includes(pattern.toLowerCase())
+          );
+        } else if (rmDepsMode === "patterns-and-devdeps") {
+          shouldExclude = devDeps || rmDepsPatterns.some(
+            (pattern) => k.toLowerCase().includes(pattern.toLowerCase())
+          );
+        }
+        if (!shouldExclude) {
+          acc[k] = v;
+        }
+        return acc;
+      },
+      {}
+    );
+    return result2;
+  }
+  if (Array.isArray(libConfig.libPkgKeepDeps)) {
+    relinka(
+      "info",
+      `Including specific dependencies for lib ${libName}: ${libConfig.libPkgKeepDeps.join(", ")}`
+    );
+    const result2 = Object.entries(originalDeps).reduce(
+      (acc, [k, v]) => {
+        if (Array.isArray(libConfig.libPkgKeepDeps) && libConfig.libPkgKeepDeps.includes(k)) {
+          acc[k] = v;
+        }
+        return acc;
+      },
+      {}
+    );
+    return result2;
+  }
+  const result = await filterDeps(
+    originalDeps,
+    true,
+    outDirBin,
+    isJsr,
+    rmDepsMode,
+    rmDepsPatterns
+  );
+  relinka(
+    "verbose",
+    `Default filtering for lib ${libName} done, count: ${Object.keys(result).length}`
+  );
+  return result;
+}
+async function library_writeJsrPackageJSON(libName, outDirBin, outDirRoot, originalPkg, commonPkg, libsList, rmDepsMode, rmDepsPatterns) {
+  relinka("verbose", `Writing package.json for JSR lib: ${libName}`);
+  if (!libsList) {
+    throw new Error("libsList is empty or not provided");
+  }
+  const binEntry = commonPkg.bin;
+  if (binEntry) {
+    relinka(
+      "verbose",
+      `Found bin entry in commonPkg: ${JSON.stringify(binEntry)}`
+    );
+    const updatedBin = {};
+    for (const [key, value] of Object.entries(binEntry)) {
+      updatedBin[key] = value.replace(/\.js$/, ".ts");
+    }
+    commonPkg.bin = updatedBin;
+    relinka(
+      "verbose",
+      `Updated bin entry for JSR: ${JSON.stringify(updatedBin)}`
+    );
+  }
+  const jsrPkg = definePackageJSON({
+    ...commonPkg,
+    dependencies: await library_getlibPkgKeepDeps(
+      libName,
+      originalPkg.dependencies,
+      outDirBin,
+      true,
+      libsList?.[libName] ?? {
+        libDeclarations: false,
+        libDescription: "",
+        libDirName: libName,
+        libMainFile: "src/libs/libName/libName-main.ts",
+        libPkgKeepDeps: false,
+        libTranspileMinify: true
+      },
+      rmDepsMode,
+      rmDepsPatterns
+    ),
+    devDependencies: await filterDeps(
+      originalPkg.devDependencies,
+      true,
+      outDirBin,
+      true,
+      rmDepsMode,
+      rmDepsPatterns
+    ),
+    exports: {
+      ".": "./bin/main.ts"
+    }
+  });
+  await fs.writeJSON(path.join(outDirRoot, "package.json"), jsrPkg, {
+    spaces: 2
+  });
+  relinka("verbose", `Completed writing package.json for JSR lib: ${libName}`);
+}
+async function library_writeNpmLibPackageJSON(libName, outDirBin, outDirRoot, originalPkg, commonPkg, libsList, rmDepsMode, rmDepsPatterns, unifiedBundlerOutExt) {
+  relinka("verbose", `Writing package.json for NPM lib: ${libName}`);
+  if (!libsList) {
+    throw new Error("libsList is empty or not provided");
+  }
+  const npmPkg = definePackageJSON({
+    ...commonPkg,
+    dependencies: await library_getlibPkgKeepDeps(
+      libName,
+      originalPkg.dependencies,
+      outDirBin,
+      false,
+      libsList?.[libName] ?? {
+        libDeclarations: true,
+        libDescription: "",
+        libDirName: libName,
+        libMainFile: "src/libs/libName/libName-main.ts",
+        libPkgKeepDeps: true,
+        libTranspileMinify: true
+      },
+      rmDepsMode,
+      rmDepsPatterns
+    ),
+    devDependencies: await filterDeps(
+      originalPkg.devDependencies,
+      true,
+      outDirBin,
+      false,
+      rmDepsMode,
+      rmDepsPatterns
+    ),
+    exports: {
+      ".": `./bin/main.${unifiedBundlerOutExt}`
+    },
+    files: ["bin", "package.json", "README.md", "LICENSE"],
+    main: `./bin/main.${unifiedBundlerOutExt}`,
+    module: `./bin/main.${unifiedBundlerOutExt}`,
+    publishConfig: { access: "public" }
+  });
+  await fs.writeJSON(path.join(outDirRoot, "package.json"), npmPkg, {
+    spaces: 2
+  });
+  relinka("verbose", `Completed writing package.json for NPM lib: ${libName}`);
+}

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

@@ -0,0 +1,207 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import path from "pathe";
+import {
+  definePackageJSON,
+  readPackageJSON
+} from "pkg-types";
+import { cliDomainDocs } from "./utils-consts.js";
+export async function regular_createPackageJSON(outDirRoot, isJsr, coreIsCLI, unifiedBundlerOutExt, rmDepsMode, rmDepsPatterns) {
+  relinka(
+    "info",
+    `Generating distribution package.json and tsconfig.json (isJsr=${isJsr})...`
+  );
+  const commonPkg = await regular_createCommonPackageFields(coreIsCLI);
+  const originalPkg = await readPackageJSON();
+  const packageName = originalPkg.name || "";
+  const cliCommandName = packageName.startsWith("@") ? packageName.split("/").pop() || "cli" : packageName;
+  relinka(
+    "verbose",
+    `Package name: "${packageName}", CLI command name: "${cliCommandName}", coreIsCLI: ${coreIsCLI}`
+  );
+  const outDirBin = path.join(outDirRoot, "bin");
+  const outExt = unifiedBundlerOutExt || "js";
+  if (isJsr) {
+    const binEntry = coreIsCLI ? { [cliCommandName]: "bin/main.ts" } : void 0;
+    if (coreIsCLI) {
+      relinka(
+        "verbose",
+        `Adding CLI bin entry for JSR: { "${cliCommandName}": "bin/main.ts" }`
+      );
+    }
+    const jsrPkg = definePackageJSON({
+      ...commonPkg,
+      bin: binEntry,
+      dependencies: await regular_getPkgKeepDeps(
+        originalPkg.dependencies,
+        outDirBin,
+        isJsr,
+        rmDepsMode,
+        rmDepsPatterns
+      ),
+      devDependencies: await regular_getPkgKeepDeps(
+        originalPkg.devDependencies,
+        outDirBin,
+        isJsr,
+        rmDepsMode,
+        rmDepsPatterns
+      ),
+      exports: {
+        ".": "./bin/main.ts"
+      }
+    });
+    await fs.writeJSON(path.join(outDirRoot, "package.json"), jsrPkg, {
+      spaces: 2
+    });
+    if (coreIsCLI) {
+      relinka(
+        "verbose",
+        `JSR package.json created with CLI bin entry: ${JSON.stringify(jsrPkg.bin)}`
+      );
+    }
+  } else {
+    const binEntry = coreIsCLI ? { [cliCommandName]: `bin/main.${outExt}` } : void 0;
+    if (coreIsCLI) {
+      relinka(
+        "verbose",
+        `Adding CLI bin entry for NPM: { "${cliCommandName}": "bin/main.${outExt}" }`
+      );
+    }
+    const npmPkg = definePackageJSON({
+      ...commonPkg,
+      bin: binEntry,
+      dependencies: await regular_getPkgKeepDeps(
+        originalPkg.dependencies,
+        outDirBin,
+        isJsr,
+        rmDepsMode,
+        rmDepsPatterns
+      ),
+      devDependencies: await regular_getPkgKeepDeps(
+        originalPkg.devDependencies,
+        outDirBin,
+        isJsr,
+        rmDepsMode,
+        rmDepsPatterns
+      ),
+      exports: {
+        ".": `./bin/main.${outExt}`
+      },
+      files: ["bin", "package.json", "README.md", "LICENSE"],
+      main: `./bin/main.${outExt}`,
+      module: `./bin/main.${outExt}`,
+      publishConfig: { access: "public" }
+    });
+    await fs.writeJSON(path.join(outDirRoot, "package.json"), npmPkg, {
+      spaces: 2
+    });
+    if (coreIsCLI) {
+      relinka(
+        "verbose",
+        `NPM package.json created with CLI bin entry: ${JSON.stringify(npmPkg.bin)}`
+      );
+    }
+  }
+  relinka("verbose", `Created package.json in ${outDirRoot}`);
+}
+async function regular_createCommonPackageFields(coreIsCLI) {
+  relinka("verbose", "Generating common package fields");
+  const originalPkg = await readPackageJSON();
+  const { author, description, keywords, license, name, version } = originalPkg;
+  relinka("verbose", `Original package name: "${name}", version: "${version}"`);
+  const pkgHomepage = cliDomainDocs;
+  const commonPkg = {
+    dependencies: originalPkg.dependencies || {},
+    description,
+    homepage: pkgHomepage,
+    license: license || "MIT",
+    name,
+    type: "module",
+    version
+  };
+  if (coreIsCLI) {
+    relinka(
+      "verbose",
+      "coreIsCLI is true, adding CLI-specific fields to common package fields"
+    );
+    if (commonPkg.keywords) {
+      const cliCommandName = name?.startsWith("@") ? name.split("/").pop() || "cli" : name || "dler";
+      relinka(
+        "verbose",
+        `Adding CLI keywords to existing keywords, CLI command name: "${cliCommandName}"`
+      );
+      commonPkg.keywords = [
+        .../* @__PURE__ */ new Set([
+          "cli",
+          cliCommandName,
+          "command-line",
+          ...commonPkg.keywords
+        ])
+      ];
+      relinka(
+        "verbose",
+        `Updated keywords: ${JSON.stringify(commonPkg.keywords)}`
+      );
+    } else if (name) {
+      const cliCommandName = name.startsWith("@") ? name.split("/").pop() || "cli" : name;
+      relinka(
+        "verbose",
+        `Setting new CLI keywords, CLI command name: "${cliCommandName}"`
+      );
+      commonPkg.keywords = ["cli", "command-line", cliCommandName];
+      relinka("verbose", `Set keywords: ${JSON.stringify(commonPkg.keywords)}`);
+    }
+  } else {
+    relinka("verbose", "coreIsCLI is false, skipping CLI-specific fields");
+  }
+  if (author) {
+    const repoOwner = typeof author === "string" ? author : author.name;
+    const repoName = name ? name.startsWith("@") ? name.split("/").pop() || name : name : "";
+    Object.assign(commonPkg, {
+      author,
+      bugs: {
+        email: "blefnk@gmail.com",
+        url: `https://github.com/${repoOwner}/${repoName}/issues`
+      },
+      keywords: [.../* @__PURE__ */ new Set([repoOwner, ...commonPkg.keywords || []])],
+      repository: {
+        type: "git",
+        url: `git+https://github.com/${repoOwner}/${repoName}.git`
+      }
+    });
+  } else if (keywords && keywords.length > 0 && !commonPkg.keywords) {
+    commonPkg.keywords = keywords;
+  }
+  relinka("verbose", "Common package fields generated");
+  return commonPkg;
+}
+async function regular_getPkgKeepDeps(originalDeps, outDirBin, isJsr, rmDepsMode, rmDepsPatterns) {
+  relinka("verbose", "Getting main package dependencies");
+  if (!originalDeps) return {};
+  const originalPkg = await readPackageJSON();
+  const devDeps = originalDeps === originalPkg.devDependencies;
+  const result = Object.entries(originalDeps).reduce(
+    (acc, [k, v]) => {
+      let shouldExclude = false;
+      if (rmDepsMode === "patterns-only") {
+        shouldExclude = rmDepsPatterns.some(
+          (pattern) => k.toLowerCase().includes(pattern.toLowerCase())
+        );
+      } else if (rmDepsMode === "patterns-and-devdeps") {
+        shouldExclude = devDeps || rmDepsPatterns.some(
+          (pattern) => k.toLowerCase().includes(pattern.toLowerCase())
+        );
+      }
+      if (!shouldExclude) {
+        acc[k] = v;
+      }
+      return acc;
+    },
+    {}
+  );
+  relinka(
+    "verbose",
+    `Main package dependencies filtered, count: ${Object.keys(result).length}`
+  );
+  return result;
+}

package/bin/libs/sdk/sdk-impl/utils/utils-tsconfig.js

@@ -0,0 +1,44 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import path from "pathe";
+import { defineTSConfig } from "pkg-types";
+import { tsconfigJson } from "./utils-consts.js";
+export async function createTSConfig(outDirRoot, allowImportingTsExtensions) {
+  relinka(
+    "verbose",
+    `Creating tsconfig.json in ${outDirRoot} (allowImportingTsExtensions=${allowImportingTsExtensions})`
+  );
+  const tsConfig = defineTSConfig({
+    compilerOptions: {
+      allowImportingTsExtensions,
+      allowJs: true,
+      esModuleInterop: true,
+      exactOptionalPropertyTypes: false,
+      isolatedModules: true,
+      lib: ["ESNext"],
+      module: "NodeNext",
+      moduleDetection: "force",
+      moduleResolution: "nodenext",
+      noEmit: true,
+      noFallthroughCasesInSwitch: false,
+      noImplicitAny: false,
+      noImplicitOverride: true,
+      noImplicitReturns: false,
+      noUncheckedIndexedAccess: true,
+      noUnusedLocals: false,
+      noUnusedParameters: false,
+      resolveJsonModule: true,
+      skipLibCheck: true,
+      strict: true,
+      strictNullChecks: false,
+      transpileTarget: "ESNext",
+      verbatimModuleSyntax: true
+    },
+    exclude: ["**/node_modules"],
+    include: ["./bin/**/*.ts"]
+  });
+  await fs.writeJSON(path.join(outDirRoot, tsconfigJson), tsConfig, {
+    spaces: 2
+  });
+  relinka("verbose", `Created tsconfig.json in ${outDirRoot}`);
+}

package/bin/libs/sdk/sdk-main.js

@@ -0,0 +1,114 @@
+export { library_buildLibrary } from "./sdk-impl/build/build-library.js";
+export {
+  regular_buildJsrDist,
+  regular_buildNpmDist
+} from "./sdk-impl/build/build-regular.js";
+export { autoPreset } from "./sdk-impl/build/bundlers/unified/auto.js";
+export { build } from "./sdk-impl/build/bundlers/unified/build.js";
+export { copyBuild } from "./sdk-impl/build/bundlers/unified/copy/copy.js";
+export { mkdistBuild } from "./sdk-impl/build/bundlers/unified/mkdist/mkdist.js";
+export { rollupBuild } from "./sdk-impl/build/bundlers/unified/rollup/build.js";
+export { getRollupOptions } from "./sdk-impl/build/bundlers/unified/rollup/config.js";
+export {
+  cjsPlugin,
+  fixCJSExportTypePlugin
+} from "./sdk-impl/build/bundlers/unified/rollup/plugins/cjs.js";
+export { esbuild } from "./sdk-impl/build/bundlers/unified/rollup/plugins/esbuild.js";
+export { JSONPlugin } from "./sdk-impl/build/bundlers/unified/rollup/plugins/json.js";
+export { rawPlugin } from "./sdk-impl/build/bundlers/unified/rollup/plugins/raw.js";
+export {
+  getShebang,
+  makeExecutable,
+  removeShebangPlugin,
+  shebangPlugin
+} from "./sdk-impl/build/bundlers/unified/rollup/plugins/shebang.js";
+export { rollupStub } from "./sdk-impl/build/bundlers/unified/rollup/stub.js";
+export {
+  DEFAULT_EXTENSIONS,
+  getChunkFilename,
+  resolveAliases
+} from "./sdk-impl/build/bundlers/unified/rollup/utils.js";
+export { rollupWatch } from "./sdk-impl/build/bundlers/unified/rollup/watch.js";
+export {
+  defineBuildConfig,
+  definePreset
+} from "./sdk-impl/build/bundlers/unified/types.js";
+export { typesBuild } from "./sdk-impl/build/bundlers/unified/untyped/index.js";
+export {
+  arrayIncludes,
+  dumpObject,
+  ensuredir,
+  extractExportFilenames,
+  getpkg,
+  inferPkgExternals,
+  listRecursively,
+  removeExtension,
+  resolvePreset,
+  rmdir,
+  symlink,
+  warn,
+  withTrailingSlash
+} from "./sdk-impl/build/bundlers/unified/utils.js";
+export {
+  validateDependencies,
+  validatePackage
+} from "./sdk-impl/build/bundlers/unified/validate.js";
+export { processLibraryFlow } from "./sdk-impl/library-flow.js";
+export { library_publishLibrary } from "./sdk-impl/pub/pub-library.js";
+export {
+  regular_pubToJsr,
+  regular_pubToNpm
+} from "./sdk-impl/pub/pub-regular.js";
+export { processRegularFlow } from "./sdk-impl/regular-flow.js";
+export { useAggregator } from "./sdk-impl/utils/tools/tools-agg.js";
+export { printUsage } from "./sdk-impl/utils/tools/tools-impl.js";
+export {
+  getBunSourcemapOption,
+  getUnifiedSourcemapOption,
+  renameEntryFile
+} from "./sdk-impl/utils/utils-build.js";
+export { bumpHandler, setBumpDisabled } from "./sdk-impl/utils/utils-bump.js";
+export { removeDistFolders } from "./sdk-impl/utils/utils-clean.js";
+export {
+  cliDomainDocs,
+  CONCURRENCY_DEFAULT,
+  PROJECT_ROOT,
+  SHOW_VERBOSE,
+  tsconfigJson,
+  validExtensions
+} from "./sdk-impl/utils/utils-consts.js";
+export {
+  validateDevCwd,
+  withWorkingDirectory
+} from "./sdk-impl/utils/utils-cwd.js";
+export { filterDeps } from "./sdk-impl/utils/utils-deps.js";
+export { determineDistName } from "./sdk-impl/utils/utils-determine.js";
+export { handleDlerError } from "./sdk-impl/utils/utils-error.js";
+export {
+  copyRootFile,
+  deleteSpecificFiles,
+  getDirectorySize,
+  outDirBinFilesCount,
+  readFileSafe,
+  writeFileSafe
+} from "./sdk-impl/utils/utils-fs.js";
+export { finalizeBuild } from "./sdk-impl/utils/utils-info.js";
+export {
+  createJsrJSON,
+  renameTsxFiles
+} from "./sdk-impl/utils/utils-jsr-json.js";
+export {
+  convertImportExtensionsJsToTs,
+  convertImportPaths,
+  extractPackageName,
+  normalizeQuotes
+} from "./sdk-impl/utils/utils-paths.js";
+export {
+  createPerfTimer,
+  getElapsedPerfTime,
+  pausePerfTimer,
+  resumePerfTimer
+} from "./sdk-impl/utils/utils-perf.js";
+export { library_createPackageJSON } from "./sdk-impl/utils/utils-pkg-json-libs.js";
+export { regular_createPackageJSON } from "./sdk-impl/utils/utils-pkg-json-reg.js";
+export { createTSConfig } from "./sdk-impl/utils/utils-tsconfig.js";

package/bin/libs/sdk/sdk-types.js

@@ -0,0 +1 @@
+export * from "../../types.js";

package/bin/load.js

@@ -0,0 +1,27 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import { resolve } from "node:path";
+import { defineConfig } from "./libs/cfg/cfg-mod.js";
+const CONFIG_FILENAME = ".config/dler.ts";
+export async function loadConfig() {
+  const cwd = process.cwd();
+  const configPath = resolve(cwd, CONFIG_FILENAME);
+  if (await fs.pathExists(configPath)) {
+    try {
+      const configModule = await import(`file://${configPath}`);
+      const config = configModule.default || configModule;
+      if (typeof config === "function") {
+        return defineConfig(config());
+      }
+      return defineConfig(config);
+    } catch (error) {
+      relinka("error", `Error loading config from ${configPath}:`, error);
+    }
+  }
+  relinka(
+    "info",
+    `Config file not found at ${configPath}. Using default configuration.`
+    // Inform user about fallback
+  );
+  return defineConfig();
+}

package/bin/main.js

@@ -0,0 +1,46 @@
+import { defineCommand, runMain } from "@reliverse/rempts";
+import { dler } from "./cli.js";
+import { initDlerConfig } from "./init.js";
+import { validateDevCwd } from "./libs/sdk/sdk-impl/utils/utils-cwd.js";
+const mainCommand = defineCommand({
+  meta: {
+    name: "dler",
+    version: "1.2.0",
+    description: "dler CLI https://docs.reliverse.org"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    }
+  },
+  async run({ args }) {
+    const isDev = args.dev;
+    await validateDevCwd(isDev, ["dler"], "dler", "reliverse");
+    await initDlerConfig(isDev);
+    await dler(isDev);
+  }
+});
+await runMain(mainCommand, {
+  fileBasedCmds: {
+    enable: true,
+    // Enables file-based subcommand detection.
+    cmdsRootPath: "src/cli/args"
+    // Directory to scan for subcommands.
+  },
+  alias: {
+    v: "verbose"
+    // Maps shorthand flag -v to --verbose.
+  },
+  strict: false,
+  // Do not throw errors for unknown flags.
+  warnOnUnknown: false,
+  // Warn when encountering unknown flags.
+  negatedBoolean: true
+  // Support for negated booleans (e.g., --no-verbose).
+  // unknown: (flagName) => {
+  //   relinka("warn", "Unknown flag encountered:", flagName);
+  //   return false;
+  // },
+  // TODO: unknownErrorMsg: "An unhandled error occurred, please report it at https://github.com/reliverse/dler"
+});