@reliverse/dler 1.7.90 → 1.7.92

package/bin/app/libs/cmd.js

@@ -29,7 +29,7 @@ export default defineCommand({
     }
     if (libNames.length === 1) {
       const argv = process.argv;
-      const initIndex = argv.findIndex((arg) => arg === "--init");
+      const initIndex = argv.indexOf("--init");
       if (initIndex !== -1 && initIndex + 1 < argv.length) {
         const additionalArgs = [];
         for (let i = initIndex + 2; i < argv.length; i++) {

package/bin/app/rempts/cmd.js

@@ -46,7 +46,7 @@ export default defineCommand({
       }
       if (cmdNames.length === 1) {
         const argv = process.argv;
-        const initIndex = argv.findIndex((arg) => arg === "--init");
+        const initIndex = argv.indexOf("--init");
         if (initIndex !== -1 && initIndex + 1 < argv.length) {
           const additionalArgs = [];
           for (let i = initIndex + 2; i < argv.length; i++) {

package/bin/app/update/migrate/cmd.d.ts

@@ -0,0 +1,23 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    "to-catalog": {
+        type: "boolean";
+        description: string;
+    };
+    "from-catalog": {
+        type: "boolean";
+        description: string;
+    };
+    "remove-catalog": {
+        type: "boolean";
+        description: string;
+    };
+    "dry-run": {
+        type: "boolean";
+        description: string;
+    };
+    interactive: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/update/migrate/cmd.js

@@ -0,0 +1,604 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
+import { readPackageJSON } from "pkg-types";
+import semver from "semver";
+import { glob } from "tinyglobby";
+import { isCatalogSupported } from "../../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+function isCatalogReference(versionSpec) {
+  return versionSpec.startsWith("catalog:");
+}
+function isWorkspaceDependency(versionSpec) {
+  return versionSpec.startsWith("workspace:");
+}
+function isNpmAlias(versionSpec) {
+  return versionSpec.startsWith("npm:");
+}
+function shouldSkipDependency(versionSpec) {
+  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
+}
+async function findWorkspacePackageJsons(cwd) {
+  const root = await readPackageJSON(cwd);
+  const ws = root.workspaces;
+  let patterns = [];
+  if (Array.isArray(ws)) {
+    patterns = ws;
+  } else if (ws && Array.isArray(ws.packages)) {
+    patterns = ws.packages;
+  }
+  if (!patterns.length) return [];
+  const dirs = await glob(patterns, {
+    cwd,
+    onlyDirectories: true,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  const pkgJsonPaths = [];
+  for (const dir of dirs) {
+    const pj = path.join(dir, "package.json");
+    if (await fs.pathExists(pj)) pkgJsonPaths.push(pj);
+  }
+  return pkgJsonPaths;
+}
+async function isMonorepo(cwd) {
+  try {
+    const root = await readPackageJSON(cwd);
+    const ws = root.workspaces;
+    if (Array.isArray(ws) && ws.length > 0) {
+      return true;
+    }
+    if (ws && Array.isArray(ws.packages) && ws.packages.length > 0) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function extractDependencies(packageJson, packageJsonPath) {
+  const dependencies = [];
+  const deps = packageJson.dependencies || {};
+  for (const [name, version] of Object.entries(deps)) {
+    if (typeof version === "string" && !shouldSkipDependency(version)) {
+      dependencies.push({
+        name,
+        version,
+        locations: /* @__PURE__ */ new Set(["dependencies"]),
+        packageJsonPath
+      });
+    }
+  }
+  const devDeps = packageJson.devDependencies || {};
+  for (const [name, version] of Object.entries(devDeps)) {
+    if (typeof version === "string" && !shouldSkipDependency(version)) {
+      const existing = dependencies.find((d) => d.name === name);
+      if (existing) {
+        existing.locations.add("devDependencies");
+        if (existing.locations.has("dependencies")) {
+          existing.version = deps[name] || existing.version;
+        }
+      } else {
+        dependencies.push({
+          name,
+          version,
+          locations: /* @__PURE__ */ new Set(["devDependencies"]),
+          packageJsonPath
+        });
+      }
+    }
+  }
+  return dependencies;
+}
+function mergeToCatalog(existingCatalog, newDependencies) {
+  const result = {
+    added: [],
+    bumped: [],
+    skipped: []
+  };
+  for (const dep of newDependencies) {
+    const existingVersion = existingCatalog[dep.name];
+    if (!existingVersion) {
+      existingCatalog[dep.name] = dep.version;
+      result.added.push(dep);
+    } else {
+      try {
+        const cleanExisting = existingVersion.replace(/^[\^~]/, "");
+        const cleanNew = dep.version.replace(/^[\^~]/, "");
+        if (semver.valid(cleanExisting) && semver.valid(cleanNew)) {
+          if (semver.gt(cleanNew, cleanExisting)) {
+            existingCatalog[dep.name] = dep.version;
+            result.bumped.push({ ...dep, oldVersion: existingVersion });
+          } else {
+            result.skipped.push(dep);
+          }
+        } else {
+          result.skipped.push(dep);
+        }
+      } catch {
+        result.skipped.push(dep);
+      }
+    }
+  }
+  return result;
+}
+async function replaceDependenciesWithCatalogRefs(packageJsonPath, dependenciesToReplace) {
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    let replacedCount = 0;
+    for (const dep of dependenciesToReplace) {
+      for (const location of dep.locations) {
+        if (location === "dependencies" && packageJson.dependencies?.[dep.name]) {
+          packageJson.dependencies[dep.name] = "catalog:";
+          replacedCount++;
+        } else if (location === "devDependencies" && packageJson.devDependencies?.[dep.name]) {
+          packageJson.devDependencies[dep.name] = "catalog:";
+          replacedCount++;
+        }
+      }
+    }
+    if (replacedCount > 0) {
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+    }
+    return replacedCount;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+async function restoreCatalogReferences(packageJsonPath, catalog) {
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    let restoredCount = 0;
+    const deps = packageJson.dependencies || {};
+    for (const [name, version] of Object.entries(deps)) {
+      if (typeof version === "string" && isCatalogReference(version)) {
+        const catalogVersion = catalog[name];
+        if (catalogVersion && packageJson.dependencies) {
+          packageJson.dependencies[name] = catalogVersion;
+          restoredCount++;
+        } else {
+          relinka("warn", `No catalog entry found for dependency: ${name} in ${packageJsonPath}`);
+        }
+      }
+    }
+    const devDeps = packageJson.devDependencies || {};
+    for (const [name, version] of Object.entries(devDeps)) {
+      if (typeof version === "string" && isCatalogReference(version)) {
+        const catalogVersion = catalog[name];
+        if (catalogVersion && packageJson.devDependencies) {
+          packageJson.devDependencies[name] = catalogVersion;
+          restoredCount++;
+        } else {
+          relinka(
+            "warn",
+            `No catalog entry found for devDependency: ${name} in ${packageJsonPath}`
+          );
+        }
+      }
+    }
+    if (restoredCount > 0) {
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+    }
+    return restoredCount;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to restore ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 0;
+  }
+}
+async function updateRootWithCatalog(rootPackageJsonPath, catalog) {
+  try {
+    const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    if (!packageJson.workspaces) {
+      packageJson.workspaces = {};
+    }
+    if (Array.isArray(packageJson.workspaces)) {
+      packageJson.workspaces = { packages: packageJson.workspaces };
+    }
+    packageJson.workspaces.catalog = catalog;
+    await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to update root package.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function removeCatalogFromRoot(rootPackageJsonPath) {
+  try {
+    const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    if (packageJson.workspaces && !Array.isArray(packageJson.workspaces) && packageJson.workspaces.catalog) {
+      delete packageJson.workspaces.catalog;
+      if (Object.keys(packageJson.workspaces).length === 0 || Object.keys(packageJson.workspaces).length === 1 && packageJson.workspaces.packages) {
+        if (!packageJson.workspaces.packages) {
+          delete packageJson.workspaces;
+        }
+      }
+    }
+    if (packageJson.catalog) {
+      delete packageJson.catalog;
+    }
+    await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to remove catalog from root package.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function migrateToCatalog(rootPath, dryRun = false, interactive = false) {
+  const results = [];
+  const workspacePaths = await findWorkspacePackageJsons(rootPath);
+  if (workspacePaths.length === 0) {
+    throw new Error("No workspace packages found. This command requires a monorepo setup.");
+  }
+  relinka("log", `Found ${workspacePaths.length} workspace packages`);
+  const allDependencies = [];
+  for (const workspacePath of workspacePaths) {
+    try {
+      const packageJsonContent = await fs.readFile(workspacePath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const deps = extractDependencies(packageJson, workspacePath);
+      allDependencies.push(...deps);
+    } catch (error) {
+      relinka(
+        "warn",
+        `Failed to read ${workspacePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (allDependencies.length === 0) {
+    relinka("log", "No dependencies found to migrate to catalog");
+    return results;
+  }
+  relinka("log", `Found ${allDependencies.length} total dependency entries across workspaces`);
+  const rootPackageJsonPath = path.resolve(rootPath, "package.json");
+  let existingCatalog = {};
+  try {
+    const rootPackageJson = await readPackageJSON(rootPath);
+    existingCatalog = rootPackageJson.workspaces?.catalog || {};
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to read root package.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const mergeResult = mergeToCatalog(existingCatalog, allDependencies);
+  relinka("log", `Catalog merge summary:`);
+  relinka("log", `  - ${mergeResult.added.length} new dependencies added`);
+  relinka("log", `  - ${mergeResult.bumped.length} dependencies bumped to newer versions`);
+  relinka(
+    "log",
+    `  - ${mergeResult.skipped.length} dependencies skipped (already up-to-date or incompatible)`
+  );
+  let dependenciesToMigrate = allDependencies;
+  if (interactive && allDependencies.length > 0) {
+    const selectedPackages = await multiselectPrompt({
+      title: "Select dependencies to migrate to catalog",
+      options: [
+        { label: "Migrate all dependencies", value: "all" },
+        { label: "Cancel migration", value: "cancel" },
+        ...Array.from(new Set(allDependencies.map((d) => d.name))).map((name) => ({
+          label: name,
+          value: name
+        }))
+      ]
+    });
+    if (selectedPackages.includes("cancel")) {
+      relinka("log", "Migration cancelled");
+      return results;
+    }
+    if (!selectedPackages.includes("all")) {
+      dependenciesToMigrate = allDependencies.filter((dep) => selectedPackages.includes(dep.name));
+    }
+  }
+  if (dryRun) {
+    relinka("log", "Dry run mode - no changes were made");
+    relinka("log", "Would migrate the following dependencies to catalog:");
+    const uniqueDeps = Array.from(new Set(dependenciesToMigrate.map((d) => d.name)));
+    for (const depName of uniqueDeps) {
+      const catalogVersion = existingCatalog[depName];
+      relinka("log", `  ${depName}: ${catalogVersion || "new entry"}`);
+    }
+    return results;
+  }
+  await updateRootWithCatalog(rootPackageJsonPath, existingCatalog);
+  const workspaceResults = /* @__PURE__ */ new Map();
+  for (const dep of dependenciesToMigrate) {
+    if (!workspaceResults.has(dep.packageJsonPath)) {
+      workspaceResults.set(dep.packageJsonPath, []);
+    }
+    workspaceResults.get(dep.packageJsonPath).push(dep);
+  }
+  for (const [packagePath, deps] of workspaceResults.entries()) {
+    const replacedCount = await replaceDependenciesWithCatalogRefs(packagePath, deps);
+    if (replacedCount > 0) {
+      relinka("log", `Updated ${replacedCount} dependencies in ${packagePath}`);
+      for (const dep of deps) {
+        results.push({
+          package: dep.name,
+          action: "replaced-with-catalog",
+          oldVersion: dep.version,
+          newVersion: "catalog:",
+          location: Array.from(dep.locations).join(", "),
+          packageJsonPath: packagePath
+        });
+      }
+    }
+  }
+  for (const dep of mergeResult.added) {
+    results.push({
+      package: dep.name,
+      action: "added-to-catalog",
+      newVersion: dep.version,
+      location: "catalog"
+    });
+  }
+  for (const dep of mergeResult.bumped) {
+    results.push({
+      package: dep.name,
+      action: "version-bumped",
+      oldVersion: dep.oldVersion,
+      newVersion: dep.version,
+      location: "catalog"
+    });
+  }
+  return results;
+}
+async function migrateFromCatalog(rootPath, removeCatalog = false, dryRun = false, interactive = false) {
+  const results = [];
+  const rootPackageJson = await readPackageJSON(rootPath);
+  const catalog = rootPackageJson.workspaces?.catalog || {};
+  if (Object.keys(catalog).length === 0) {
+    relinka("warn", "No workspaces.catalog found in root package.json");
+    return results;
+  }
+  relinka("log", `Found catalog with ${Object.keys(catalog).length} entries`);
+  const workspacePaths = await findWorkspacePackageJsons(rootPath);
+  if (workspacePaths.length === 0) {
+    relinka("warn", "No workspace packages found");
+    return results;
+  }
+  const packagesWithCatalogRefs = [];
+  for (const workspacePath of workspacePaths) {
+    try {
+      const packageJsonContent = await fs.readFile(workspacePath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const catalogRefs = [];
+      const deps = packageJson.dependencies || {};
+      for (const [name, version] of Object.entries(deps)) {
+        if (typeof version === "string" && isCatalogReference(version)) {
+          catalogRefs.push(name);
+        }
+      }
+      const devDeps = packageJson.devDependencies || {};
+      for (const [name, version] of Object.entries(devDeps)) {
+        if (typeof version === "string" && isCatalogReference(version)) {
+          catalogRefs.push(name);
+        }
+      }
+      if (catalogRefs.length > 0) {
+        packagesWithCatalogRefs.push({
+          path: workspacePath,
+          catalogRefs: [...new Set(catalogRefs)]
+          // Remove duplicates
+        });
+      }
+    } catch (error) {
+      relinka(
+        "warn",
+        `Failed to read ${workspacePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (packagesWithCatalogRefs.length === 0) {
+    relinka("log", "No catalog references found in workspace packages");
+    if (removeCatalog && !dryRun) {
+      const rootPackageJsonPath = path.resolve(rootPath, "package.json");
+      await removeCatalogFromRoot(rootPackageJsonPath);
+      relinka("log", "Removed catalog from root package.json");
+    }
+    return results;
+  }
+  const totalCatalogRefs = packagesWithCatalogRefs.reduce(
+    (sum, pkg) => sum + pkg.catalogRefs.length,
+    0
+  );
+  relinka(
+    "log",
+    `Found ${totalCatalogRefs} catalog references across ${packagesWithCatalogRefs.length} packages`
+  );
+  let packagesToProcess = packagesWithCatalogRefs;
+  if (interactive && packagesWithCatalogRefs.length > 0) {
+    const allCatalogRefs = Array.from(
+      new Set(packagesWithCatalogRefs.flatMap((p) => p.catalogRefs))
+    );
+    const selectedPackages = await multiselectPrompt({
+      title: "Select dependencies to restore from catalog",
+      options: [
+        { label: "Restore all catalog references", value: "all" },
+        { label: "Cancel restoration", value: "cancel" },
+        ...allCatalogRefs.map((name) => ({
+          label: `${name} (${catalog[name] || "missing in catalog"})`,
+          value: name,
+          disabled: !catalog[name]
+        }))
+      ]
+    });
+    if (selectedPackages.includes("cancel")) {
+      relinka("log", "Restoration cancelled");
+      return results;
+    }
+    if (!selectedPackages.includes("all")) {
+      packagesToProcess = packagesWithCatalogRefs.map((pkg) => ({
+        ...pkg,
+        catalogRefs: pkg.catalogRefs.filter((ref) => selectedPackages.includes(ref))
+      })).filter((pkg) => pkg.catalogRefs.length > 0);
+    }
+  }
+  if (dryRun) {
+    relinka("log", "Dry run mode - no changes were made");
+    relinka("log", "Would restore the following catalog references:");
+    for (const pkg of packagesToProcess) {
+      relinka("log", `  ${pkg.path}:`);
+      for (const ref of pkg.catalogRefs) {
+        const catalogVersion = catalog[ref];
+        relinka("log", `    ${ref}: catalog: \u2192 ${catalogVersion || "MISSING"}`);
+      }
+    }
+    if (removeCatalog) {
+      relinka("log", "Would also remove workspaces.catalog from root package.json");
+    }
+    return results;
+  }
+  for (const pkg of packagesToProcess) {
+    const restoredCount = await restoreCatalogReferences(pkg.path, catalog);
+    if (restoredCount > 0) {
+      relinka("log", `Restored ${restoredCount} catalog references in ${pkg.path}`);
+      for (const ref of pkg.catalogRefs) {
+        if (catalog[ref]) {
+          results.push({
+            package: ref,
+            action: "restored-from-catalog",
+            oldVersion: "catalog:",
+            newVersion: catalog[ref],
+            location: "dependencies/devDependencies",
+            packageJsonPath: pkg.path
+          });
+        }
+      }
+    }
+  }
+  if (removeCatalog) {
+    const rootPackageJsonPath = path.resolve(rootPath, "package.json");
+    await removeCatalogFromRoot(rootPackageJsonPath);
+    relinka("log", "Removed workspaces.catalog from root package.json");
+  }
+  return results;
+}
+function displayMigrationResults(results) {
+  if (results.length === 0) {
+    relinka("log", "No changes were made");
+    return;
+  }
+  const byAction = results.reduce(
+    (acc, result) => {
+      if (!acc[result.action]) acc[result.action] = [];
+      acc[result.action].push(result);
+      return acc;
+    },
+    {}
+  );
+  for (const [action, actionResults] of Object.entries(byAction)) {
+    relinka("log", `
+${action.replace(/-/g, " ")} (${actionResults.length}):`);
+    for (const result of actionResults) {
+      let message = `  ${result.package}`;
+      if (result.oldVersion && result.newVersion) {
+        message += `: ${result.oldVersion} \u2192 ${result.newVersion}`;
+      } else if (result.newVersion) {
+        message += `: ${result.newVersion}`;
+      }
+      if (result.packageJsonPath) {
+        message += ` (${result.packageJsonPath})`;
+      }
+      relinka("log", message);
+    }
+  }
+  relinka("success", `Migration completed: ${results.length} changes made`);
+}
+export default defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Migrate dependencies between workspace packages and workspaces.catalog"
+  },
+  args: defineArgs({
+    "to-catalog": {
+      type: "boolean",
+      description: "Migrate workspace dependencies to workspaces.catalog and replace with catalog references"
+    },
+    "from-catalog": {
+      type: "boolean",
+      description: "Restore catalog references to actual versions from workspaces.catalog"
+    },
+    "remove-catalog": {
+      type: "boolean",
+      description: "Remove workspaces.catalog from root package.json after restoring (only with --from-catalog)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without making modifications"
+    },
+    interactive: {
+      type: "boolean",
+      description: "Interactively select dependencies to migrate"
+    }
+  }),
+  async run({ args }) {
+    try {
+      if (!args["to-catalog"] && !args["from-catalog"]) {
+        relinka("error", "Must specify either --to-catalog or --from-catalog");
+        return process.exit(1);
+      }
+      if (args["to-catalog"] && args["from-catalog"]) {
+        relinka("error", "Cannot specify both --to-catalog and --from-catalog");
+        return process.exit(1);
+      }
+      if (args["remove-catalog"] && !args["from-catalog"]) {
+        relinka("error", "--remove-catalog can only be used with --from-catalog");
+        return process.exit(1);
+      }
+      const cwd = process.cwd();
+      const packageJsonPath = path.resolve(cwd, "package.json");
+      if (!await fs.pathExists(packageJsonPath)) {
+        relinka("error", "No package.json found in current directory");
+        return process.exit(1);
+      }
+      if (!await isMonorepo(cwd)) {
+        relinka("error", "This command requires a monorepo with workspace configuration");
+        return process.exit(1);
+      }
+      const packageManager = await detectPackageManager(cwd);
+      if (!packageManager) {
+        relinka("warn", "Could not detect package manager");
+      } else if (!isCatalogSupported(packageManager)) {
+        relinka(
+          "warn",
+          `Catalogs may not be fully supported by ${packageManager.name}. Only Bun has full catalog support.`
+        );
+      }
+      let results = [];
+      if (args["to-catalog"]) {
+        relinka("log", "Migrating workspace dependencies to catalog...");
+        results = await migrateToCatalog(cwd, !!args["dry-run"], !!args.interactive);
+      } else if (args["from-catalog"]) {
+        relinka("log", "Restoring dependencies from catalog...");
+        results = await migrateFromCatalog(
+          cwd,
+          !!args["remove-catalog"],
+          !!args["dry-run"],
+          !!args.interactive
+        );
+      }
+      displayMigrationResults(results);
+      if (args["dry-run"]) {
+        relinka("info", "This was a dry run - no actual changes were made");
+      }
+    } catch (error) {
+      relinka(
+        "error",
+        `Migration failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  }
+});

package/bin/cli.js

@@ -9,7 +9,7 @@ let isDev = process.env.DLER_DEV_MODE === "true";
 const main = defineCommand({
   meta: {
     name: "dler",
-    version: "1.7.90",
+    version: "1.7.92",
     description: `Displays dler's command menu.
 To see ALL available commands and arguments, run: 'dler --help' (or 'dler <command> --help')
 Available menu commands: ${MENU_CMDS.join(", ")}`

package/bin/libs/sdk/sdk-impl/config/info.js

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

package/package.json

@@ -52,7 +52,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.90",
+  "version": "1.7.92",
   "keywords": [
     "reliverse",
     "cli",