@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/build/providers/untyped/untyped-mod.js

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+import { pascalCase } from "scule";
+import { generateMarkdown, generateTypes, resolveSchema } from "untyped";
+import untypedPlugin from "untyped/babel-plugin";
+export async function typesBuild(ctx) {
+  const entries = ctx.options.entries.filter(
+    (entry) => entry.builder === "untyped"
+  );
+  if (entries.length === 0) {
+    return;
+  }
+  await ctx.hooks.callHook("untyped:entries", ctx, entries);
+  for (const entry of entries) {
+    try {
+      const distDir = entry.outDir;
+      if (!distDir) {
+        throw new Error(
+          `[untyped] Missing 'outDir' for entry '${entry.name}'. Please define an output directory.`
+        );
+      }
+      const jitiOptions = {
+        interopDefault: true,
+        transformOptions: {
+          babel: {
+            plugins: [untypedPlugin]
+          }
+        }
+      };
+      await ctx.hooks.callHook("untyped:entry:options", ctx, entry, jitiOptions);
+      const untypedJiti = createJiti(ctx.options.rootDir, jitiOptions);
+      const inputPath = resolve(ctx.options.rootDir, entry.input);
+      let rawSchemaModule;
+      try {
+        rawSchemaModule = await untypedJiti.import(inputPath);
+      } catch (importError) {
+        console.warn(
+          `[untyped] Failed to import schema for entry '${entry.name}' from ${inputPath}: ${importError.message}`
+        );
+        rawSchemaModule = {};
+      }
+      let rawSchema;
+      if (rawSchemaModule && typeof rawSchemaModule === "object" && "default" in rawSchemaModule && // Check if the default export itself is the intended schema object
+      typeof rawSchemaModule.default === "object" && rawSchemaModule.default !== null) {
+        rawSchema = rawSchemaModule.default;
+      } else if (typeof rawSchemaModule === "object" && rawSchemaModule !== null) {
+        rawSchema = rawSchemaModule;
+      } else {
+        console.warn(
+          `[untyped] Invalid schema input resolved for entry '${entry.name}' (path: ${entry.input}). Expected an object, got ${typeof rawSchemaModule}. Using empty schema.`
+        );
+        rawSchema = {};
+      }
+      const defaults = entry.defaults || {};
+      const schema = await resolveSchema(rawSchema, defaults);
+      await ctx.hooks.callHook("untyped:entry:schema", ctx, entry, schema);
+      const outputs = {
+        declaration: entry.declaration ? {
+          contents: generateTypes(schema, {
+            interfaceName: pascalCase(`${entry.name}-schema`)
+            // addDefaults: true, // TODO: Add JSDoc default values (allow to configure via reliverse.ts)
+            // addDescription: true, // TODO: Add JSDoc descriptions (allow to configure via reliverse.ts)
+          }),
+          fileName: `${entry.name}.d.ts`
+        } : void 0,
+        defaults: {
+          contents: JSON.stringify(defaults, null, 2),
+          fileName: `${entry.name}.defaults.json`
+        },
+        markdown: {
+          contents: generateMarkdown(schema),
+          fileName: `${entry.name}.md`
+        },
+        schema: {
+          contents: JSON.stringify(schema, null, 2),
+          fileName: `${entry.name}.schema.json`
+        }
+      };
+      await ctx.hooks.callHook("untyped:entry:outputs", ctx, entry, outputs);
+      await mkdir(distDir, { recursive: true });
+      const writePromises = [];
+      for (const output of Object.values(outputs)) {
+        if (!output) continue;
+        const fullOutputPath = resolve(distDir, output.fileName);
+        writePromises.push(
+          writeFile(fullOutputPath, output.contents, "utf8").catch((writeError) => {
+            console.error(
+              `[untyped] Failed to write output file ${fullOutputPath} for entry '${entry.name}': ${writeError.message}`
+            );
+          })
+        );
+      }
+      await Promise.all(writePromises);
+      relinka("verbose", `[untyped] Generated outputs for '${entry.name}' in ${distDir}`);
+    } catch (error) {
+      console.error(
+        `[untyped] Failed to process entry '${entry.name}': ${error.message}`,
+        error.stack
+      );
+    }
+  }
+  await ctx.hooks.callHook("untyped:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka(
+      "warn",
+      "`untyped` builder does not support transpileWatch mode effectively (schema changes may require manual rebuild)."
+    );
+  }
+}

package/bin/app/build/providers/utils.d.ts

@@ -0,0 +1,19 @@
+import type { PackageJson } from "pkg-types";
+import type { BuildContext, BuildPreset, UnifiedBuildConfig } from "../../types/mod.js";
+interface OutputDescriptor {
+    file: string;
+    type?: "cjs" | "esm";
+}
+export declare function arrayIncludes(arr: (RegExp | string)[], searchElement: string): boolean;
+export declare function dumpObject(obj: Record<string, any>): string;
+export declare function extractExportFilenames(exports: PackageJson["exports"], conditions?: string[]): OutputDescriptor[];
+export declare function getpkg(id?: string): string;
+export declare function inferPkgExternals(pkg: PackageJson): (RegExp | string)[];
+export declare function listRecursively(path: string): string[];
+export declare function removeExtension(filename: string): string;
+export declare function resolvePreset(preset: BuildPreset | string, rootDir: string): Promise<UnifiedBuildConfig>;
+export declare function rmdir(dir: string): Promise<void>;
+export declare function symlink(from: string, to: string, force?: boolean): Promise<void>;
+export declare function warn(ctx: BuildContext, message: string): void;
+export declare function withTrailingSlash(path: string): string;
+export {};

package/bin/app/build/providers/utils.js

@@ -0,0 +1,148 @@
+import { readdirSync, statSync } from "node:fs";
+import fsp from "node:fs/promises";
+import { resolve } from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+import { autoPreset } from "./auto.js";
+export function arrayIncludes(arr, searchElement) {
+  return arr.some(
+    (entry) => entry instanceof RegExp ? entry.test(searchElement) : entry === searchElement
+  );
+}
+export function dumpObject(obj) {
+  return `{ ${Object.keys(obj).map((key) => `${key}: ${JSON.stringify(obj[key])}`).join(", ")} }`;
+}
+export function extractExportFilenames(exports, conditions = []) {
+  if (!exports) {
+    return [];
+  }
+  if (typeof exports === "string") {
+    return [{ file: exports, type: "esm" }];
+  }
+  return Object.entries(exports).filter(([subpath]) => !subpath.endsWith(".json")).flatMap(
+    ([condition, exports2]) => typeof exports2 === "string" ? {
+      file: exports2,
+      type: inferExportType(condition, conditions, exports2)
+    } : extractExportFilenames(exports2, [...conditions, condition])
+  );
+}
+export function getpkg(id = "") {
+  const s = id.split("/");
+  return s[0]?.startsWith("@") ? `${s[0]}/${s[1] || ""}` : s[0] || "";
+}
+export function inferPkgExternals(pkg) {
+  const externals = [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+    ...Object.keys(pkg.devDependencies || {}).filter((dep) => dep.startsWith("@types/")),
+    ...Object.keys(pkg.optionalDependencies || {})
+  ];
+  if (pkg.name) {
+    externals.push(pkg.name);
+    if (pkg.exports) {
+      for (const subpath of Object.keys(pkg.exports)) {
+        if (subpath.startsWith("./")) {
+          externals.push(pathToRegex(`${pkg.name}/${subpath.slice(2)}`));
+        }
+      }
+    }
+  }
+  if (pkg.imports) {
+    for (const importName of Object.keys(pkg.imports)) {
+      if (importName.startsWith("#")) {
+        externals.push(pathToRegex(importName));
+      }
+    }
+  }
+  return [...new Set(externals)];
+}
+export function listRecursively(path) {
+  const filenames = /* @__PURE__ */ new Set();
+  const walk = (path2) => {
+    const files = readdirSync(path2);
+    for (const file of files) {
+      const fullPath = resolve(path2, file);
+      if (statSync(fullPath).isDirectory()) {
+        filenames.add(`${fullPath}/`);
+        walk(fullPath);
+      } else {
+        filenames.add(fullPath);
+      }
+    }
+  };
+  walk(path);
+  return [...filenames];
+}
+export function removeExtension(filename) {
+  return filename.replace(/\.(js|mjs|cjs|ts|mts|cts|json|jsx|tsx)$/, "");
+}
+export async function resolvePreset(preset, rootDir) {
+  let resolvedPreset = preset;
+  if (preset === "auto") {
+    resolvedPreset = autoPreset;
+  } else if (typeof preset === "string") {
+    resolvedPreset = await createJiti(rootDir, { interopDefault: true }).import(preset, {
+      default: true
+    }) || {};
+  }
+  if (typeof resolvedPreset === "function") {
+    resolvedPreset = resolvedPreset();
+  }
+  return resolvedPreset;
+}
+export async function rmdir(dir) {
+  await fsp.unlink(dir).catch(() => {
+  });
+  await fsp.rm(dir, { force: true, recursive: true }).catch(() => {
+  });
+}
+export async function symlink(from, to, force = true) {
+  await fs.ensureDir(to);
+  if (force) {
+    await fsp.unlink(to).catch(() => {
+    });
+  }
+  await fsp.symlink(from, to, "junction");
+}
+export function warn(ctx, message) {
+  if (ctx.warnings.has(message)) {
+    return;
+  }
+  relinka("verbose", "[dler] [warn]", message);
+  ctx.warnings.add(message);
+}
+export function withTrailingSlash(path) {
+  return path.endsWith("/") ? path : `${path}/`;
+}
+function inferExportType(condition, previousConditions = [], filename = "") {
+  if (filename) {
+    if (filename.endsWith(".d.ts")) {
+      return "esm";
+    }
+    if (filename.endsWith(".mjs")) {
+      return "esm";
+    }
+    if (filename.endsWith(".cjs")) {
+      return "cjs";
+    }
+  }
+  switch (condition) {
+    case "import": {
+      return "esm";
+    }
+    case "require": {
+      return "cjs";
+    }
+    default: {
+      if (previousConditions.length === 0) {
+        return "esm";
+      }
+      const [newCondition] = previousConditions;
+      return inferExportType(newCondition || "import", previousConditions.slice(1), filename);
+    }
+  }
+}
+function pathToRegex(path) {
+  return path.includes("*") ? new RegExp(`^${path.replace(/\./g, String.raw`\.`).replace(/\*/g, ".*")}$`) : path;
+}

package/bin/app/build/providers/validate.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson } from "pkg-types";
+import type { BuildContext } from "../../types/mod.js";
+export declare function validateDependencies(ctx: BuildContext): void;
+export declare function validatePackage(pkg: PackageJson, rootDir: string, ctx: BuildContext): void;

package/bin/app/build/providers/validate.js

@@ -0,0 +1,52 @@
+import { existsSync } from "node:fs";
+import { resolve } from "@reliverse/pathkit";
+import { arrayIncludes, extractExportFilenames, getpkg, warn } from "./utils.js";
+export function validateDependencies(ctx) {
+  const usedDependencies = /* @__PURE__ */ new Set();
+  const unusedDependencies = new Set(Object.keys(ctx.pkg.dependencies || {}));
+  const implicitDependencies = /* @__PURE__ */ new Set();
+  for (const id of ctx.usedImports) {
+    unusedDependencies.delete(id);
+    usedDependencies.add(id);
+  }
+  if (Array.isArray(ctx.options.dependencies)) {
+    for (const id of ctx.options.dependencies) {
+      unusedDependencies.delete(id);
+    }
+  }
+  for (const id of usedDependencies) {
+    if (!arrayIncludes(ctx.options.externals, id) && !id.startsWith("chunks/") && !ctx.options.dependencies.includes(getpkg(id)) && !ctx.options.peerDependencies.includes(getpkg(id))) {
+      implicitDependencies.add(id);
+    }
+  }
+  if (unusedDependencies.size > 0) {
+    warn(ctx, `Potential unused dependencies found: ${[...unusedDependencies].join(", ")}`);
+  }
+  if (implicitDependencies.size > 0 && !ctx.options.rollup.inlineDependencies) {
+    warn(ctx, `Potential implicit dependencies found: ${[...implicitDependencies].join(", ")}`);
+  }
+}
+export function validatePackage(pkg, rootDir, ctx) {
+  if (!pkg) {
+    return;
+  }
+  const filenames = new Set(
+    [
+      ...typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin || {}),
+      pkg.main,
+      pkg.module,
+      pkg.types,
+      pkg.typings,
+      ...extractExportFilenames(pkg.exports).map((i) => i.file)
+    ].map((i) => i && resolve(rootDir, i.replace(/\/[^/]*\*.*$/, "")))
+  );
+  const missingOutputs = [];
+  for (const filename of filenames) {
+    if (filename && !filename.includes("*") && !existsSync(filename)) {
+      missingOutputs.push(filename.replace(`${rootDir}/`, ""));
+    }
+  }
+  if (missingOutputs.length > 0) {
+    warn(ctx, `Potential missing package.json files: ${missingOutputs.join(", ")}`);
+  }
+}

package/bin/app/build/regular-flow.d.ts

@@ -0,0 +1,9 @@
+import type { DlerConfig, PerfTimer } from "../types/mod.js";
+/**
+ * Builds the main project based on build mode and commonPubRegistry.
+ */
+export declare function regular_buildFlow(timer: PerfTimer, isDev: boolean, config: DlerConfig): Promise<void>;
+/**
+ * Publishes the main project based on commonPubRegistry.
+ */
+export declare function regular_pubFlow(timer: PerfTimer, isDev: boolean, config: DlerConfig): Promise<void>;

package/bin/app/build/regular-flow.js

@@ -0,0 +1,173 @@
+import { relinka } from "@reliverse/relinka";
+import pAll from "p-all";
+import { CONCURRENCY_DEFAULT } from "../config/constants.js";
+import { regular_pubToJsr, regular_pubToNpm } from "../pub/pub-regular.js";
+import { regular_buildJsrDist, regular_buildNpmDist } from "./build-regular.js";
+export async function regular_buildFlow(timer, isDev, config) {
+  relinka("verbose", "\u2014 \u2014 \u2014 regular_buildFlow \u2014 \u2014 \u2014");
+  if (config.libsActMode === "libs-only") {
+    relinka("verbose", "Skipping main project build as libsActMode is set to 'libs-only'");
+    return;
+  }
+  switch (config.commonPubRegistry) {
+    case "jsr":
+      relinka("verbose", "Initializing build process for main project to JSR only...");
+      await regular_buildJsrDist(
+        isDev,
+        true,
+        config.coreIsCLI,
+        config.coreEntrySrcDir,
+        config.distJsrDirName,
+        config.distJsrBuilder,
+        config.coreEntryFile,
+        config.transpileTarget,
+        config.transpileFormat,
+        config.transpileSplitting,
+        config.transpileMinify,
+        config.transpileSourcemap,
+        config.transpilePublicPath,
+        config.distNpmOutFilesExt,
+        config,
+        timer,
+        config.transpileStub,
+        config.transpileWatch,
+        config.distJsrGenTsconfig,
+        config.coreDeclarations
+      );
+      break;
+    case "npm":
+      relinka("verbose", "Initializing build process for main project to NPM only...");
+      await regular_buildNpmDist(
+        isDev,
+        config.coreIsCLI,
+        config.coreEntrySrcDir,
+        config.distNpmDirName,
+        config.distNpmBuilder,
+        config.coreEntryFile,
+        config.distNpmOutFilesExt,
+        config,
+        config.transpileTarget,
+        config.transpileFormat,
+        config.transpileSplitting,
+        config.transpileMinify,
+        config.transpileSourcemap,
+        config.transpilePublicPath,
+        config.transpileStub,
+        config.transpileWatch,
+        timer,
+        config.coreDeclarations
+      );
+      break;
+    case "npm-jsr": {
+      relinka("verbose", "Initializing build process for main project to both NPM and JSR...");
+      const buildTasks = [
+        () => regular_buildJsrDist(
+          isDev,
+          true,
+          config.coreIsCLI,
+          config.coreEntrySrcDir,
+          config.distJsrDirName,
+          config.distJsrBuilder,
+          config.coreEntryFile,
+          config.transpileTarget,
+          config.transpileFormat,
+          config.transpileSplitting,
+          config.transpileMinify,
+          config.transpileSourcemap,
+          config.transpilePublicPath,
+          config.distNpmOutFilesExt,
+          config,
+          timer,
+          config.transpileStub,
+          config.transpileWatch,
+          config.distJsrGenTsconfig,
+          config.coreDeclarations
+        ),
+        () => regular_buildNpmDist(
+          isDev,
+          config.coreIsCLI,
+          config.coreEntrySrcDir,
+          config.distNpmDirName,
+          config.distNpmBuilder,
+          config.coreEntryFile,
+          config.distNpmOutFilesExt,
+          config,
+          config.transpileTarget,
+          config.transpileFormat,
+          config.transpileSplitting,
+          config.transpileMinify,
+          config.transpileSourcemap,
+          config.transpilePublicPath,
+          config.transpileStub,
+          config.transpileWatch,
+          timer,
+          config.coreDeclarations
+        )
+      ];
+      await pAll(buildTasks, { concurrency: CONCURRENCY_DEFAULT });
+      break;
+    }
+    default:
+      relinka("error", `Invalid commonPubRegistry: ${config.commonPubRegistry}`);
+      throw new Error(`Invalid commonPubRegistry: ${config.commonPubRegistry}`);
+  }
+}
+export async function regular_pubFlow(timer, isDev, config) {
+  relinka("verbose", "\u2014 \u2014 \u2014 regular_pubFlow \u2014 \u2014 \u2014");
+  if (config.libsActMode === "libs-only") {
+    relinka("verbose", "Skipping main project publish as libsActMode is set to 'libs-only'");
+    return;
+  }
+  switch (config.commonPubRegistry) {
+    case "jsr":
+      relinka("verbose", "Publishing main project to JSR...");
+      await regular_pubToJsr(
+        config.distJsrDryRun,
+        config.distJsrFailOnWarn,
+        isDev,
+        config.commonPubPause,
+        config.distJsrDirName,
+        config.distJsrAllowDirty,
+        config.distJsrSlowTypes,
+        timer
+      );
+      break;
+    case "npm":
+      relinka("verbose", "Publishing main project to NPM...");
+      await regular_pubToNpm(
+        config.distJsrDryRun,
+        isDev,
+        config.commonPubPause,
+        config.distNpmDirName,
+        timer
+      );
+      break;
+    case "npm-jsr": {
+      relinka("verbose", "Publishing main project to both NPM and JSR...");
+      const publishTasks = [
+        () => regular_pubToJsr(
+          config.distJsrDryRun,
+          config.distJsrFailOnWarn,
+          isDev,
+          config.commonPubPause,
+          config.distJsrDirName,
+          config.distJsrAllowDirty,
+          config.distJsrSlowTypes,
+          timer
+        ),
+        () => regular_pubToNpm(
+          config.distJsrDryRun,
+          isDev,
+          config.commonPubPause,
+          config.distNpmDirName,
+          timer
+        )
+      ];
+      await pAll(publishTasks, { concurrency: CONCURRENCY_DEFAULT });
+      break;
+    }
+    default:
+      relinka("error", `Invalid commonPubRegistry: ${config.commonPubRegistry}`);
+      throw new Error(`Invalid commonPubRegistry: ${config.commonPubRegistry}`);
+  }
+}

package/bin/app/catalog/cmd.js

@@ -1,7 +1,7 @@
 import { relinka } from "@reliverse/relinka";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { listCatalogs, isCatalogSupported } from "../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
-import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+import { isCatalogSupported, listCatalogs } from "../utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
 export default defineCommand({
   meta: {
     name: "catalog",

package/bin/app/check/cmd.js

@@ -1,20 +1,20 @@
 import path from "@reliverse/pathkit";
 import { re } from "@reliverse/relico";
 import { relinka } from "@reliverse/relinka";
-import { defineCommand, selectPrompt, multiselectPrompt, defineArgs } from "@reliverse/rempts";
-import { checkDlerConfigHealth } from "../../libs/sdk/sdk-impl/rules/reliverse/dler-config-health/dler-config-health.js";
-import { checkFileExtensions } from "../../libs/sdk/sdk-impl/rules/reliverse/file-extensions/file-extensions.js";
-import { analyzeDependencies } from "../../libs/sdk/sdk-impl/rules/reliverse/missing-deps/analyzer.js";
-import { checkMissingDependencies } from "../../libs/sdk/sdk-impl/rules/reliverse/missing-deps/deps-mod.js";
-import { formatOutput } from "../../libs/sdk/sdk-impl/rules/reliverse/missing-deps/formatter.js";
-import { checkNoDynamicImports } from "../../libs/sdk/sdk-impl/rules/reliverse/no-dynamic-imports/no-dynamic-imports.js";
-import { checkNoIndexFiles } from "../../libs/sdk/sdk-impl/rules/reliverse/no-index-files/no-index-files.js";
-import { checkPackageJsonHealth } from "../../libs/sdk/sdk-impl/rules/reliverse/package-json-health/package-json-health.js";
-import { checkPathExtensions } from "../../libs/sdk/sdk-impl/rules/reliverse/path-extensions/path-extensions.js";
-import { checkSelfInclude } from "../../libs/sdk/sdk-impl/rules/reliverse/self-include/self-include.js";
-import { checkTsConfigHealth } from "../../libs/sdk/sdk-impl/rules/reliverse/tsconfig-health/tsconfig-health.js";
-import { displayCheckResults } from "../../libs/sdk/sdk-impl/rules/rules-mod.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-mod.js";
+import { defineArgs, defineCommand, multiselectPrompt, selectPrompt } from "@reliverse/rempts";
+import { ensureDlerConfig } from "../config/prepare.js";
+import { checkDlerConfigHealth } from "../rules/reliverse/dler-config-health/dler-config-health.js";
+import { checkFileExtensions } from "../rules/reliverse/file-extensions/file-extensions.js";
+import { analyzeDependencies } from "../rules/reliverse/missing-deps/analyzer.js";
+import { checkMissingDependencies } from "../rules/reliverse/missing-deps/deps-mod.js";
+import { formatOutput } from "../rules/reliverse/missing-deps/formatter.js";
+import { checkNoDynamicImports } from "../rules/reliverse/no-dynamic-imports/no-dynamic-imports.js";
+import { checkNoIndexFiles } from "../rules/reliverse/no-index-files/no-index-files.js";
+import { checkPackageJsonHealth } from "../rules/reliverse/package-json-health/package-json-health.js";
+import { checkPathExtensions } from "../rules/reliverse/path-extensions/path-extensions.js";
+import { checkSelfInclude } from "../rules/reliverse/self-include/self-include.js";
+import { checkTsConfigHealth } from "../rules/reliverse/tsconfig-health/tsconfig-health.js";
+import { displayCheckResults } from "../rules/rules-mod.js";
 export default defineCommand({
   meta: {
     name: "check",

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

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

package/bin/app/cli/cmd.js

@@ -0,0 +1,56 @@
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { getOrCreateRseConfig } from "../config/cfg-core.js";
+import { cliName, useLocalhost } from "../config/constants.js";
+import { showStartPrompt } from "../init/use-template/cp-modules/cli-main-modules/modules/showStartEndPrompt.js";
+import { authCheck } from "../login/login-impl.js";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+import { app } from "./impl.js";
+export default defineCommand({
+  meta: {
+    name: "cli",
+    description: `Runs the ${cliName}`
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    },
+    cwd: {
+      type: "string",
+      description: "The working directory to run the CLI in",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const isDev = args.dev;
+    await showStartPrompt(isDev, false);
+    if (!process.versions.bun) {
+      relinka.warn(
+        "Rse is currently optimized for Bun only. Unexpected behavior may occur with other runtimes."
+      );
+      relinka.warn("To avoid issues, it's strongly recommended to install Bun: https://bun.sh/get");
+    }
+    let cwd;
+    if (args.cwd) {
+      cwd = args.cwd;
+      if (!await fs.pathExists(cwd)) {
+        await ensuredir(cwd);
+      }
+    } else {
+      cwd = getCurrentWorkingDirectory();
+    }
+    const memory = await getOrCreateReliverseMemory();
+    const { config, mrse } = await getOrCreateRseConfig({
+      projectPath: cwd,
+      isDev,
+      overrides: {}
+    });
+    await authCheck(isDev, memory, useLocalhost);
+    const updatedMemory = await getOrCreateReliverseMemory();
+    await app({ cwd, isDev, config, memory: updatedMemory, mrse });
+    process.exit(0);
+  }
+});

package/bin/app/cli/impl.d.ts

@@ -0,0 +1,5 @@
+import type { ParamsOmitSkipPN } from "../types/mod.js";
+export declare function app(params: ParamsOmitSkipPN): Promise<void>;
+export declare function showWebUiMenu({ isDev }: {
+    isDev: boolean;
+}): Promise<void>;