@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/config/cfg-detect.d.ts

@@ -0,0 +1,22 @@
+import { type PackageJson } from "pkg-types";
+import type { DetectedProject, ProjectFramework } from "../types/mod.js";
+export declare function detectProjectFramework(projectPath: string): Promise<ProjectFramework | null>;
+export declare function getPackageJson(projectPath: string): Promise<PackageJson | null>;
+export declare function getPackageJsonSafe(projectPath: string): Promise<PackageJson | null>;
+export declare function detectProject(projectPath: string, isDev: boolean): Promise<DetectedProject | null>;
+export declare function detectProjectsWithRseConfig(projectPath: string, isDev: boolean): Promise<DetectedProject[]>;
+export declare function detectFeatures(projectPath: string, packageJson: PackageJson | null): Promise<{
+    i18n: boolean;
+    analytics: boolean;
+    themeMode: "light" | "dark" | "dark-light";
+    authentication: boolean;
+    api: boolean;
+    database: boolean;
+    testing: boolean;
+    docker: boolean;
+    ci: boolean;
+    commands: string[];
+    webview: string[];
+    language: string[];
+    themes: string[];
+}>;

package/bin/app/config/cfg-detect.js

@@ -0,0 +1,347 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON } from "pkg-types";
+import { getProjectContent } from "./cfg-content.js";
+import { PROJECT_FRAMEWORK_FILES } from "./cfg-default.js";
+import { getRseConfigPath } from "./cfg-path.js";
+import { readRseConfig } from "./cfg-read.js";
+export async function detectProjectFramework(projectPath) {
+  const packageJson = await getPackageJson(projectPath);
+  if (!packageJson) {
+    for (const [type, files] of Object.entries(PROJECT_FRAMEWORK_FILES)) {
+      for (const file of files) {
+        const [filePath = file] = file.split(":");
+        if (filePath !== "package.json" && await fs.pathExists(path.join(projectPath, filePath))) {
+          return type;
+        }
+      }
+    }
+    return null;
+  }
+  const deps = {
+    ...packageJson.dependencies ?? {},
+    ...packageJson.devDependencies ?? {}
+  };
+  const matches = [];
+  for (const [type, files] of Object.entries(PROJECT_FRAMEWORK_FILES)) {
+    for (const file of files) {
+      const [filePath = file, packageName] = file.split(":");
+      if (filePath === "package.json" && packageName) {
+        if (packageName in deps) {
+          matches.push({ type, priority: 1 });
+        }
+      }
+    }
+  }
+  if (matches.length > 0) {
+    const [firstMatch] = matches;
+    return firstMatch?.type ?? null;
+  }
+  for (const [type, files] of Object.entries(PROJECT_FRAMEWORK_FILES)) {
+    for (const file of files) {
+      const [filePath = file] = file.split(":");
+      if (filePath !== "package.json" && await fs.pathExists(path.join(projectPath, filePath))) {
+        return type;
+      }
+    }
+  }
+  return null;
+}
+export async function getPackageJson(projectPath) {
+  try {
+    const packageJsonPath = path.join(projectPath, "package.json");
+    if (!await fs.pathExists(packageJsonPath)) return null;
+    return await readPackageJSON(projectPath);
+  } catch (error) {
+    const packageJsonPath = path.join(projectPath, "package.json");
+    if (await fs.pathExists(packageJsonPath)) {
+      relinka(
+        "warn",
+        "Could not read package.json:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return null;
+  }
+}
+export async function getPackageJsonSafe(projectPath) {
+  const packageJsonPath = path.join(projectPath, "package.json");
+  if (!await fs.pathExists(packageJsonPath)) return null;
+  return await readPackageJSON(projectPath);
+}
+export async function detectProject(projectPath, isDev) {
+  try {
+    const { requiredContent, optionalContent } = await getProjectContent(projectPath);
+    if (!requiredContent.filePackageJson) return null;
+    const { configPath } = await getRseConfigPath(projectPath, isDev, false);
+    if (!await fs.pathExists(configPath)) return null;
+    const config = await readRseConfig(configPath, isDev);
+    if (!config) return null;
+    return {
+      name: path.basename(projectPath),
+      path: projectPath,
+      config,
+      needsDepsInstall: !optionalContent.dirNodeModules,
+      hasGit: optionalContent.dirGit
+    };
+  } catch (error) {
+    relinka(
+      "warn",
+      `Error processing ${projectPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+export async function detectProjectsWithRseConfig(projectPath, isDev) {
+  const detected = [];
+  const rootProject = await detectProject(projectPath, isDev);
+  if (rootProject) detected.push(rootProject);
+  try {
+    const items = await fs.readdir(projectPath, { withFileTypes: true });
+    const subProjects = await Promise.all(
+      items.filter((item) => item.isDirectory()).map(async (item) => {
+        const effectiveProjectPath = path.join(projectPath, item.name);
+        return await detectProject(effectiveProjectPath, isDev);
+      })
+    );
+    for (const project of subProjects) {
+      if (project) detected.push(project);
+    }
+  } catch (error) {
+    relinka(
+      "warn",
+      `Error reading directory ${projectPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return detected;
+}
+export async function detectFeatures(projectPath, packageJson) {
+  const deps = {
+    ...packageJson?.dependencies ?? {},
+    ...packageJson?.devDependencies ?? {}
+  };
+  const hasNextAuth = "next-auth" in deps;
+  const hasClerk = "@clerk/nextjs" in deps;
+  const hasBetterAuth = "better-auth" in deps;
+  const hasAuth0 = "@auth0/nextjs-auth0" in deps;
+  const hasPrisma = "@prisma/client" in deps;
+  const hasDrizzle = "drizzle-orm" in deps;
+  const hasSupabase = "@supabase/supabase-js" in deps;
+  const hasMongoose = "mongoose" in deps;
+  const hasPg = "pg" in deps || "@neondatabase/serverless" in deps;
+  const hasMysql = "mysql" in deps || "mysql2" in deps;
+  const hasSqlite = "sqlite" in deps || "sqlite3" in deps || "better-sqlite3" in deps;
+  const hasMongo = "mongodb" in deps || "mongoose" in deps;
+  const hasVercelAnalytics = "@vercel/analytics" in deps;
+  const hasSegmentAnalytics = "@segment/analytics-next" in deps;
+  const hasGoogleAnalytics = "ga-4-react" in deps || "react-ga" in deps;
+  const hasPlausible = "next-plausible" in deps;
+  const hasFathom = "fathom-client" in deps;
+  const hasZustand = "zustand" in deps;
+  const hasJotai = "jotai" in deps;
+  const hasRedux = "@reduxjs/toolkit" in deps || "redux" in deps;
+  const hasReactHookForm = "react-hook-form" in deps;
+  const hasFormik = "formik" in deps;
+  const hasTailwind = "tailwindcss" in deps;
+  const hasStyledComponents = "styled-components" in deps;
+  const hasCssModules = packageJson?.dependencies && Object.keys(deps).some((key) => key.includes("css-loader") || key.includes("css-modules"));
+  const hasSass = "sass" in deps || "node-sass" in deps;
+  const hasShadcnUi = await fs.pathExists(path.join(projectPath, "components/ui"));
+  const hasChakraUi = "@chakra-ui/react" in deps;
+  const hasMaterialUi = "@mui/material" in deps;
+  const hasBunTest = packageJson?.scripts && Object.values(packageJson.scripts).some(
+    (script) => script && typeof script === "string" && script.includes("bun test")
+  );
+  const hasVitest = "vitest" in deps;
+  const hasJest = "jest" in deps;
+  const hasPlaywright = "@playwright/test" in deps;
+  const hasCypress = "cypress" in deps;
+  const hasHono = "hono" in deps;
+  const hasTrpc = "@trpc/server" in deps;
+  const hasGraphql = "graphql" in deps || "apollo-server" in deps;
+  const hasRest = await fs.pathExists(path.join(projectPath, "src/api")) || await fs.pathExists(path.join(projectPath, "src/app/api"));
+  const hasEslint = "eslint" in deps;
+  const hasBiome = "@biomejs/biome" in deps;
+  const hasStripe = "stripe" in deps || "@stripe/stripe-js" in deps;
+  const hasSentry = "@sentry/nextjs" in deps || "@sentry/react" in deps;
+  const hasAxiom = "next-axiom" in deps;
+  const hasSonner = "sonner" in deps;
+  const hasAlgolia = "algoliasearch" in deps || "react-instantsearch" in deps;
+  const hasUploadthing = "uploadthing" in deps;
+  const hasZod = "zod" in deps;
+  const hasTypebox = "@sinclair/typebox" in deps;
+  const hasValibot = "valibot" in deps;
+  const hasStarlight = "@astrojs/starlight" in deps;
+  const hasNextra = "nextra" in deps;
+  const hasLucide = "lucide-react" in deps;
+  const hasResend = "resend" in deps;
+  const hasRedis = "redis" in deps || "@upstash/redis" in deps;
+  const hasCloudflare = "cloudflare" in deps || "@cloudflare/workers-types" in deps;
+  const hasContentlayer = "contentlayer" in deps;
+  const hasNextIntl = "next-intl" in deps;
+  const hasI18next = "i18next" in deps || "react-i18next" in deps;
+  const hasRosetta = "rosetta" in deps;
+  const hasNextSeo = "next-seo" in deps;
+  const hasFramer = "framer-motion" in deps;
+  const hasRecharts = "recharts" in deps;
+  const hasDayjs = "dayjs" in deps;
+  const hasMdx = "mdx" in deps || "@next/mdx" in deps;
+  const hasDocker = await fs.pathExists(path.join(projectPath, "Dockerfile"));
+  const hasCI = await fs.pathExists(path.join(projectPath, ".github/workflows")) || await fs.pathExists(path.join(projectPath, ".gitlab-ci.yml"));
+  const languages = ["typescript"];
+  if ("python" in deps || await fs.pathExists(path.join(projectPath, "requirements.txt"))) {
+    languages.push("python");
+  }
+  if (await fs.pathExists(path.join(projectPath, "go.mod"))) {
+    languages.push("go");
+  }
+  if (await fs.pathExists(path.join(projectPath, "Cargo.toml"))) {
+    languages.push("rust");
+  }
+  const themes = ["default"];
+  if (hasTailwind) {
+    themes.push("tailwind");
+  }
+  if (hasChakraUi) {
+    themes.push("chakra");
+  }
+  if (hasMaterialUi) {
+    themes.push("material");
+  }
+  if (hasStyledComponents) {
+    themes.push("styled-components");
+  }
+  if (hasCssModules) {
+    themes.push("css-modules");
+  }
+  if (hasSass) {
+    themes.push("sass");
+  }
+  if (hasShadcnUi) {
+    themes.push("shadcn");
+  }
+  if (hasZustand) {
+    themes.push("zustand");
+  }
+  if (hasJotai) {
+    themes.push("jotai");
+  }
+  if (hasRedux) {
+    themes.push("redux");
+  }
+  if (hasReactHookForm) {
+    themes.push("react-hook-form");
+  }
+  if (hasFormik) {
+    themes.push("formik");
+  }
+  if (hasEslint) {
+    themes.push("eslint");
+  }
+  if (hasBiome) {
+    themes.push("biome");
+  }
+  if (hasStripe) {
+    themes.push("stripe");
+  }
+  if (hasSentry) {
+    themes.push("sentry");
+  }
+  if (hasAxiom) {
+    themes.push("axiom");
+  }
+  if (hasSonner) {
+    themes.push("sonner");
+  }
+  if (hasAlgolia) {
+    themes.push("algolia");
+  }
+  if (hasUploadthing) {
+    themes.push("uploadthing");
+  }
+  if (hasZod) {
+    themes.push("zod");
+  }
+  if (hasTypebox) {
+    themes.push("typebox");
+  }
+  if (hasValibot) {
+    themes.push("valibot");
+  }
+  if (hasStarlight) {
+    themes.push("starlight");
+  }
+  if (hasNextra) {
+    themes.push("nextra");
+  }
+  if (hasLucide) {
+    themes.push("lucide");
+  }
+  if (hasResend) {
+    themes.push("resend");
+  }
+  if (hasRedis) {
+    themes.push("redis");
+  }
+  if (hasCloudflare) {
+    themes.push("cloudflare");
+  }
+  if (hasContentlayer) {
+    themes.push("contentlayer");
+  }
+  if (hasNextSeo) {
+    themes.push("next-seo");
+  }
+  if (hasFramer) {
+    themes.push("framer-motion");
+  }
+  if (hasRecharts) {
+    themes.push("recharts");
+  }
+  if (hasDayjs) {
+    themes.push("dayjs");
+  }
+  if (hasMdx) {
+    themes.push("mdx");
+  }
+  const webviews = [];
+  if ("electron" in deps) {
+    webviews.push("electron");
+  }
+  if ("tauri" in deps) {
+    webviews.push("tauri");
+  }
+  if ("capacitor" in deps) {
+    webviews.push("capacitor");
+  }
+  if ("react-native" in deps) {
+    webviews.push("react-native");
+  }
+  const commands = [];
+  if (packageJson?.scripts) {
+    for (const [name] of Object.entries(packageJson.scripts)) {
+      if (name !== "start" && name !== "build" && name !== "dev" && name !== "test") {
+        commands.push(name);
+      }
+    }
+  }
+  const hasTestingFramework = !!(hasJest || hasVitest || hasPlaywright || hasCypress || hasBunTest);
+  return {
+    i18n: hasNextIntl || hasI18next || hasRosetta,
+    analytics: hasVercelAnalytics || hasSegmentAnalytics || hasGoogleAnalytics || hasPlausible || hasFathom,
+    themeMode: "dark-light",
+    authentication: hasNextAuth || hasClerk || hasBetterAuth || hasAuth0 || hasSupabase,
+    api: hasHono || hasTrpc || hasGraphql || hasRest,
+    database: hasPrisma || hasDrizzle || hasSupabase || hasMongoose || hasPg || hasMysql || hasSqlite || hasMongo,
+    testing: hasTestingFramework,
+    docker: hasDocker,
+    ci: hasCI,
+    commands: commands.slice(0, 10),
+    // Limit to 10 commands to avoid overly large configs
+    webview: webviews,
+    language: languages,
+    themes: themes.slice(0, 20)
+    // Limit to 20 themes to avoid overly large configs
+  };
+}

package/bin/app/config/cfg-gen-cfg.d.ts

@@ -0,0 +1,3 @@
+import type { DeploymentService } from "../types/mod.js";
+export declare function generateConfigFiles(projectPath: string, overwrite: boolean, projectName: string, deployService: DeploymentService, primaryDomain: string, frontendUsername: string, enableI18n: boolean, isDev: boolean, filesToGenerate?: string[]): Promise<void>;
+export declare function generateProjectConfigs(projectPath: string, projectName: string, frontendUsername: string, deployService: DeploymentService, primaryDomain: string, enableI18n: boolean, isDev: boolean): Promise<void>;

package/bin/app/config/cfg-gen-cfg.js

@@ -0,0 +1,185 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { destr } from "destr";
+import { execaCommand } from "execa";
+import { generateRseConfig } from "./cfg-create.js";
+import { getRseConfigPath } from "./cfg-path.js";
+import { CONFIG_CATEGORIES, UNKNOWN_VALUE } from "./constants.js";
+async function generateBiomeConfig(projectPath) {
+  const biomePath = path.join(projectPath, "biome.json");
+  const biomeExists = await fs.pathExists(biomePath);
+  if (!biomeExists) {
+    await execaCommand("bunx biome init", {
+      cwd: projectPath,
+      stdio: "inherit"
+    });
+    relinka("verbose", "Generated biome.json");
+  }
+}
+async function generateVSCodeSettings(projectPath, overwrite) {
+  const vscodePath = path.join(projectPath, ".vscode");
+  await ensuredir(vscodePath);
+  const settingsPath = path.join(vscodePath, "settings.json");
+  const defaultSettings = {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.codeActionsOnSave": {
+      "quickfix.biome": "explicit",
+      "source.addMissingImports": "never",
+      "source.fixAll.eslint": "explicit",
+      "source.organizeImports": "never",
+      "source.removeUnused": "never"
+    },
+    "eslint.ignoreUntitled": true,
+    "eslint.rules.customizations": [
+      {
+        rule: "perfectionist/sort-imports",
+        severity: "off"
+      }
+    ],
+    "markdownlint.config": {
+      MD033: false
+    },
+    "typescript.enablePromptUseWorkspaceTsdk": true
+  };
+  let settings = { ...defaultSettings };
+  if (!overwrite && await fs.pathExists(settingsPath)) {
+    try {
+      const content = await fs.readFile(settingsPath, "utf-8");
+      const existingSettings = destr(content);
+      if (existingSettings && typeof existingSettings === "object") {
+        const defaultCodeActions = {
+          "quickfix.biome": "explicit",
+          "source.addMissingImports": "never",
+          "source.fixAll.eslint": "explicit",
+          "source.organizeImports": "never",
+          "source.removeUnused": "never"
+        };
+        const existingCodeActions = {
+          ...defaultCodeActions,
+          ...existingSettings["editor.codeActionsOnSave"]
+        };
+        settings = {
+          ...defaultSettings,
+          ...existingSettings,
+          "editor.codeActionsOnSave": existingCodeActions
+        };
+      }
+    } catch (error) {
+      relinka(
+        "verbose",
+        "Error reading existing settings.json, creating new one",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  relinka(
+    "verbose",
+    overwrite ? "Generated brand new VSCode settings.json file" : "Updated VSCode settings.json with required settings"
+  );
+}
+export async function generateConfigFiles(projectPath, overwrite, projectName, deployService, primaryDomain, frontendUsername, enableI18n, isDev, filesToGenerate = []) {
+  try {
+    const shouldGenerateFile = (filename) => {
+      return filesToGenerate.length === 0 || filesToGenerate.includes(filename);
+    };
+    const cleanDomain = primaryDomain.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    const finalFrontendUsername = isDev && frontendUsername === "blefnk" ? "reliverse" : frontendUsername;
+    const configInfo = await getRseConfigPath(projectPath, isDev, false);
+    const mainConfigFileName = path.basename(configInfo.configPath);
+    const configGenerators = {
+      [mainConfigFileName]: async () => {
+        await generateRseConfig({
+          projectName,
+          frontendUsername: !finalFrontendUsername || finalFrontendUsername.trim() === "" ? UNKNOWN_VALUE : finalFrontendUsername,
+          deployService,
+          primaryDomain: cleanDomain,
+          projectPath,
+          githubUsername: UNKNOWN_VALUE,
+          enableI18n,
+          overwrite,
+          isDev,
+          configInfo,
+          ...isDev && configInfo?.isTS ? {
+            customPathToTypes: "./src/libs/sdk/sdk-mod"
+          } : {},
+          overrides: {}
+        });
+        return true;
+      },
+      "biome.json": async () => {
+        await generateBiomeConfig(projectPath);
+        return true;
+      },
+      "settings.json": async () => {
+        await generateVSCodeSettings(projectPath, overwrite);
+        return true;
+      }
+    };
+    const generatedFiles = [];
+    await Promise.all(
+      Object.entries(configGenerators).filter(([filename]) => shouldGenerateFile(filename)).map(async ([filename, generator]) => {
+        const wasGenerated = await generator();
+        if (wasGenerated) {
+          generatedFiles.push(filename);
+        }
+      })
+    );
+    if (generatedFiles.length > 0) {
+      relinka("verbose", `Generated configuration files: ${generatedFiles.join(", ")}`);
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      "Error generating config files:",
+      error instanceof Error ? error.message : String(error)
+    );
+    throw error;
+  }
+}
+export async function generateProjectConfigs(projectPath, projectName, frontendUsername, deployService, primaryDomain, enableI18n, isDev) {
+  try {
+    const existingFiles = [];
+    for (const category of Object.keys(CONFIG_CATEGORIES)) {
+      const files = CONFIG_CATEGORIES[category];
+      for (const file of files) {
+        const filePath = path.join(projectPath, file);
+        if (await fs.pathExists(filePath)) {
+          existingFiles.push(file);
+        }
+      }
+    }
+    if (existingFiles.length > 0) {
+      relinka("verbose", `Found ${existingFiles.length} existing configuration files`);
+      await generateConfigFiles(
+        projectPath,
+        false,
+        projectName,
+        deployService,
+        primaryDomain,
+        frontendUsername,
+        enableI18n,
+        isDev
+      );
+    } else {
+      await generateConfigFiles(
+        projectPath,
+        true,
+        projectName,
+        deployService,
+        primaryDomain,
+        frontendUsername,
+        enableI18n,
+        isDev
+      );
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to set up configuration files: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw error;
+  }
+}

package/bin/app/config/cfg-migrate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Migrates an external rseg file into the current project config.
+ * Only migrates fields that exist in the current schema.
+ */
+export declare function migrateRseConfig(externalrseth: string, projectPath: string, isDev: boolean): Promise<void>;

package/bin/app/config/cfg-migrate.js

@@ -0,0 +1,56 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { parseJSONC } from "confbox";
+import { updateRseConfig } from "./cfg-update.js";
+export async function migrateRseConfig(externalrseth, projectPath, isDev) {
+  try {
+    const content = await fs.readFile(externalrseth, "utf-8");
+    const parsed = parseJSONC(content);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("Invalid JSONC format in external config file");
+    }
+    const tempConfig = parsed;
+    const migratedFields = [];
+    const validConfig = {};
+    const keysToMigrate = [
+      "projectDescription",
+      "version",
+      "projectLicense",
+      "projectRepository",
+      "projectCategory",
+      "projectSubcategory",
+      "projectFramework",
+      "projectTemplate",
+      "projectArchitecture",
+      "deployBehavior",
+      "depsBehavior",
+      "gitBehavior",
+      "i18nBehavior",
+      "scriptsBehavior",
+      "existingRepoBehavior",
+      "repoPrivacy",
+      "features",
+      "preferredLibraries",
+      "codeStyle",
+      "monorepo",
+      "ignoreDependencies",
+      "customRules",
+      "skipPromptsUseAutoBehavior",
+      "relinterConfirm"
+    ];
+    for (const key of keysToMigrate) {
+      if (tempConfig[key] !== void 0) {
+        validConfig[key] = tempConfig[key];
+        migratedFields.push(String(key));
+      }
+    }
+    const success = await updateRseConfig(projectPath, validConfig, isDev);
+    if (success) {
+      relinka("success", "Successfully migrated config");
+      relinka("verbose", "Migrated fields:", migratedFields.join(", "));
+    }
+    await fs.remove(externalrseth);
+  } catch (error) {
+    relinka("warn", "Failed to migrate external config:", String(error));
+  }
+}

package/bin/app/config/cfg-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Determines the rse config file path and whether it's TS or JSONC.
+ * Always looks in the .config directory first.
+ * - In dev mode, automatically selects the TS path.
+ * - Honors a custom tsconfig.json path if provided.
+ * - Caches results by projectPath.
+ */
+export declare function getRseConfigPath(projectPath: string, isDev: boolean, skipPrompt: boolean, customTsconfigPath?: string): Promise<{
+    configPath: string;
+    isTS: boolean;
+}>;

package/bin/app/config/cfg-path.js

@@ -0,0 +1,33 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { askRseConfigType } from "./cfg-prompts.js";
+import { tsconfigJson } from "./constants.js";
+const configPathCache = /* @__PURE__ */ new Map();
+export async function getRseConfigPath(projectPath, isDev, skipPrompt, customTsconfigPath) {
+  const cached = configPathCache.get(projectPath);
+  if (cached) {
+    return cached;
+  }
+  const finalTsconfigPath = customTsconfigPath ? path.resolve(customTsconfigPath) : path.join(projectPath, tsconfigJson);
+  const configDir = path.join(projectPath, ".config");
+  const rseJsonc = path.join(configDir, "reliverse.jsonc");
+  const rseTs = path.join(configDir, "reliverse.ts");
+  const [tsconfigExists, jsoncExists, tsExists] = await Promise.all([
+    fs.pathExists(finalTsconfigPath),
+    fs.pathExists(rseJsonc),
+    fs.pathExists(rseTs)
+  ]);
+  let result;
+  if (isDev) {
+    result = { configPath: rseTs, isTS: true };
+  } else if (tsExists) {
+    result = { configPath: rseTs, isTS: true };
+  } else if (tsconfigExists && !jsoncExists && !skipPrompt) {
+    const choice = await askRseConfigType();
+    result = choice === "ts" ? { configPath: rseTs, isTS: true } : { configPath: rseJsonc, isTS: false };
+  } else {
+    result = { configPath: rseJsonc, isTS: false };
+  }
+  configPathCache.set(projectPath, result);
+  return result;
+}

package/bin/app/config/cfg-prepare.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureRseConfig(isDev: boolean): Promise<void>;
+export declare function prepareRseEnvironment(isDev: boolean): Promise<void>;