@reliverse/dler 1.7.91 → 1.7.93

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

@@ -0,0 +1,281 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt } from "@reliverse/rempts";
+import { Value } from "@sinclair/typebox/value";
+import { execaCommand } from "execa";
+async function addDevDependency(pkgName, opts) {
+  const pkgPath = path.join(opts.cwd, "package.json");
+  let pkg;
+  try {
+    const { readPackageJSON } = await import("pkg-types");
+    pkg = await readPackageJSON(pkgPath);
+  } catch {
+    if (await fs.pathExists(pkgPath)) {
+      pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+    } else {
+      pkg = {};
+    }
+  }
+  if (!pkg.devDependencies) pkg.devDependencies = {};
+  if (!pkg.devDependencies[pkgName]) {
+    pkg.devDependencies[pkgName] = "latest";
+    await fs.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+    relinka("log", `Added ${pkgName} to devDependencies in ${pkgPath}`);
+  } else {
+    relinka("log", `${pkgName} already present in devDependencies in ${pkgPath}`);
+  }
+}
+import { injectSectionComments } from "./cfg-comments.js";
+import { generateDefaultRulesForProject, getDefaultRseConfig } from "./cfg-def-utils.js";
+import { DEFAULT_CONFIG_RSE } from "./cfg-default.js";
+import { detectFeatures, getPackageJson } from "./cfg-detect.js";
+import { getRseConfigPath } from "./cfg-path.js";
+import { readRseConfig } from "./cfg-read.js";
+import { rseSchema } from "./cfg-schema.js";
+import {
+  atomicWriteFile,
+  cleanGitHubUrl,
+  getBackupAndTempPaths,
+  objectToCodeString,
+  updateTsConfigInclude
+} from "./cfg-utils.js";
+import {
+  cliDomainDocs,
+  DEFAULT_DOMAIN,
+  RSE_SCHEMA_DEV,
+  rseName,
+  UNKNOWN_VALUE
+} from "./constants.js";
+export async function writeRseConfig(configPath, config, isDev, skipInstallPrompt = false, customPathToTypes) {
+  if (await fs.pathExists(configPath)) {
+    relinka("verbose", `Config file already exists at ${configPath}, skipping creation`);
+    return;
+  }
+  const configDir = path.dirname(configPath);
+  if (!await fs.pathExists(configDir)) {
+    await fs.mkdir(configDir, { recursive: true });
+  }
+  if (configPath.endsWith(".ts")) {
+    const { backupPath: backupPath2, tempPath: tempPath2 } = getBackupAndTempPaths(configPath);
+    try {
+      relinka("verbose", `Starting config write process for: ${configPath}`);
+      relinka("verbose", `Backup path: ${backupPath2}`);
+      relinka("verbose", `Temp path: ${tempPath2}`);
+      for (const file of [backupPath2, tempPath2]) {
+        if (await fs.pathExists(file)) {
+          relinka("verbose", `Removing existing file: ${file}`);
+          await fs.remove(file);
+        }
+      }
+      if (await fs.pathExists(configPath)) {
+        relinka("verbose", `Creating backup of existing config at: ${backupPath2}`);
+        await fs.copy(configPath, backupPath2);
+      } else {
+        relinka("verbose", "No existing config found, skipping backup creation");
+      }
+      const objectLiteral = objectToCodeString(config, 0);
+      const objectLiteralWithComments = injectSectionComments(objectLiteral);
+      let importPath;
+      if (customPathToTypes) {
+        importPath = customPathToTypes;
+      } else if (isDev) {
+        importPath = "~/libs/cfg/cfg-impl/cfg-define";
+      } else {
+        importPath = "@reliverse/rse-cfg";
+      }
+      const fileContent2 = `import { defineConfig } from "${importPath}";
+export default defineConfig(${objectLiteralWithComments});
+`;
+      await atomicWriteFile(configPath, fileContent2, backupPath2, tempPath2);
+      await updateTsConfigInclude(path.dirname(configPath));
+      if (!isDev && !skipInstallPrompt) {
+        await addDevDependency("~/app/types/mod", {
+          cwd: path.dirname(configPath)
+        });
+        relinka("verbose", "TS config written successfully");
+        const shouldRunInstall = await confirmPrompt({
+          title: "Run `bun install` now to install '~/app/types/mod'?",
+          defaultValue: true
+        });
+        if (shouldRunInstall) {
+          await execaCommand("bun install", {
+            cwd: path.dirname(configPath),
+            stdio: "inherit"
+          });
+        } else {
+          relinka(
+            "success",
+            "Please run `bun install` later, then use `rse cli` again to continue."
+          );
+          process.exit(0);
+        }
+      } else {
+        relinka("verbose", "TS config written successfully");
+      }
+      return;
+    } catch (error) {
+      relinka("error", "Failed to write TS config:", String(error));
+      if (await fs.pathExists(backupPath2) && !await fs.pathExists(configPath)) {
+        try {
+          await fs.copy(backupPath2, configPath);
+          relinka("warn", "Restored TS config from backup after failed write");
+        } catch (restoreError) {
+          relinka("error", "Failed to restore TS config from backup:", String(restoreError));
+        }
+      }
+      if (await fs.pathExists(tempPath2)) {
+        await fs.remove(tempPath2);
+      }
+      throw error;
+    }
+  }
+  if (!Value.Check(rseSchema, config)) {
+    const issues = [...Value.Errors(rseSchema, config)].map(
+      (err) => `Path "${err.path}": ${err.message}`
+    );
+    relinka("error", "Invalid config:", issues.join("; "));
+    throw new Error(`Invalid config: ${issues.join("; ")}`);
+  }
+  let fileContent = JSON.stringify(config, null, 2);
+  fileContent = injectSectionComments(fileContent);
+  const { backupPath, tempPath } = getBackupAndTempPaths(configPath);
+  if (await fs.pathExists(configPath)) {
+    await fs.copy(configPath, backupPath);
+  }
+  await atomicWriteFile(configPath, fileContent, backupPath, tempPath);
+  relinka("verbose", "Config written successfully");
+}
+export async function createRseConfig(projectPath, githubUsername, isDev, overrides) {
+  const defaultRules = await generateDefaultRulesForProject(projectPath, isDev);
+  const effectiveProjectName = defaultRules?.projectName ?? path.basename(projectPath);
+  let effectiveAuthorName = defaultRules?.projectAuthor ?? UNKNOWN_VALUE;
+  const effectiveDomain = defaultRules?.projectDomain ?? (effectiveProjectName === rseName ? cliDomainDocs : DEFAULT_DOMAIN);
+  if (effectiveAuthorName === "blefnk" && isDev) {
+    effectiveAuthorName = "rse";
+  }
+  await generateRseConfig({
+    projectName: effectiveProjectName,
+    frontendUsername: effectiveAuthorName,
+    deployService: "vercel",
+    primaryDomain: effectiveDomain,
+    projectPath,
+    githubUsername,
+    isDev,
+    overrides
+  });
+  relinka(
+    "verbose",
+    defaultRules ? "Created config based on detected project settings." : "Created initial config. Please review and adjust as needed."
+  );
+}
+export async function generateRseConfig({
+  projectName,
+  frontendUsername,
+  deployService,
+  primaryDomain,
+  projectPath,
+  githubUsername,
+  enableI18n = false,
+  overwrite = false,
+  isDev,
+  configInfo,
+  customOutputPath,
+  customFilename,
+  skipInstallPrompt = false,
+  customPathToTypes,
+  overrides
+}) {
+  const packageJson = await getPackageJson(projectPath);
+  if (frontendUsername === "blefnk" && isDev) {
+    frontendUsername = "rse";
+  }
+  const defaultConfig = await getDefaultRseConfig(
+    projectPath,
+    isDev,
+    projectName,
+    frontendUsername
+  );
+  defaultConfig.projectName = projectName;
+  defaultConfig.projectAuthor = frontendUsername;
+  defaultConfig.projectDescription = packageJson?.description ?? defaultConfig.projectDescription ?? UNKNOWN_VALUE;
+  defaultConfig.version = packageJson?.version ?? defaultConfig.version;
+  defaultConfig.projectLicense = packageJson?.license ?? defaultConfig.projectLicense;
+  const projectNameWithoutAt = projectName?.replace("@", "");
+  defaultConfig.projectRepository = packageJson?.repository ? typeof packageJson.repository === "string" ? cleanGitHubUrl(packageJson.repository) : cleanGitHubUrl(packageJson.repository.url) : githubUsername && projectName ? `https://github.com/${projectNameWithoutAt}` : DEFAULT_DOMAIN;
+  defaultConfig.projectGitService = "github";
+  defaultConfig.projectDeployService = deployService;
+  defaultConfig.projectDomain = primaryDomain ? `https://${primaryDomain.replace(/^https?:\/\//, "")}` : projectName ? `https://${projectName}.vercel.app` : UNKNOWN_VALUE;
+  defaultConfig.features = await detectFeatures(projectPath, packageJson);
+  defaultConfig.features.i18n = enableI18n ?? false;
+  defaultConfig.multipleRepoCloneMode = false;
+  defaultConfig.customUserFocusedRepos = [];
+  defaultConfig.customDevsFocusedRepos = [];
+  defaultConfig.hideRepoSuggestions = false;
+  defaultConfig.customReposOnNewProject = false;
+  defaultConfig.envComposerOpenBrowser = true;
+  defaultConfig.gitBehavior = "prompt";
+  defaultConfig.deployBehavior = "prompt";
+  defaultConfig.depsBehavior = "prompt";
+  defaultConfig.i18nBehavior = "prompt";
+  defaultConfig.scriptsBehavior = "prompt";
+  defaultConfig.skipPromptsUseAutoBehavior = false;
+  defaultConfig.codeStyle = {
+    ...defaultConfig.codeStyle,
+    dontRemoveComments: true,
+    shouldAddComments: true,
+    typeOrInterface: "type",
+    importOrRequire: "import",
+    quoteMark: "double",
+    semicolons: true,
+    lineWidth: 80,
+    indentStyle: "space",
+    indentSize: 2,
+    importSymbol: "~",
+    trailingComma: "all",
+    bracketSpacing: true,
+    arrowParens: "always",
+    tabWidth: 2,
+    jsToTs: false,
+    cjsToEsm: false,
+    modernize: {
+      replaceFs: false,
+      replacePath: false,
+      replaceHttp: false,
+      replaceProcess: false,
+      replaceConsole: false,
+      replaceEvents: false
+    }
+  };
+  let effectiveConfigPath;
+  if (customOutputPath && customFilename) {
+    effectiveConfigPath = path.join(customOutputPath, customFilename);
+  } else {
+    const configPathInfo = configInfo ?? await getRseConfigPath(projectPath, isDev, skipInstallPrompt);
+    effectiveConfigPath = configPathInfo.configPath;
+  }
+  let existingContent = null;
+  if (!overwrite && await fs.pathExists(effectiveConfigPath)) {
+    try {
+      existingContent = await readRseConfig(effectiveConfigPath, isDev);
+    } catch {
+    }
+  }
+  const effectiveConfig = {
+    ...DEFAULT_CONFIG_RSE,
+    ...existingContent,
+    ...defaultConfig,
+    ...overrides
+  };
+  if (isDev) {
+    effectiveConfig.$schema = RSE_SCHEMA_DEV;
+  }
+  await writeRseConfig(
+    effectiveConfigPath,
+    effectiveConfig,
+    isDev,
+    skipInstallPrompt,
+    customPathToTypes
+  );
+}

package/bin/app/config/cfg-def-utils.d.ts

@@ -0,0 +1,6 @@
+import type { RseConfig } from "../types/mod.js";
+/**
+ * Generating a Default Config and Merging with Detected Data
+ */
+export declare function getDefaultRseConfig(projectPath: string, isDev: boolean, projectName?: string, projectAuthor?: string): Promise<RseConfig>;
+export declare function generateDefaultRulesForProject(projectPath: string, isDev: boolean): Promise<RseConfig | null>;

package/bin/app/config/cfg-def-utils.js

@@ -0,0 +1,229 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { getUserPkgManager, runtimeInfo } from "@reliverse/runtime";
+import { safeDestr } from "destr";
+import { readPackageJSON } from "pkg-types";
+import { getBiomeConfig } from "./cfg-biome.js";
+import { DEFAULT_CONFIG_RSE } from "./cfg-default.js";
+import {
+  detectFeatures,
+  detectProjectFramework,
+  getPackageJsonSafe
+} from "./cfg-detect.js";
+import { cliDomainDocs, DEFAULT_DOMAIN, rseName, UNKNOWN_VALUE } from "./constants.js";
+export async function getDefaultRseConfig(projectPath, isDev, projectName, projectAuthor) {
+  const packageJson = await getPackageJsonSafe(projectPath);
+  const effectiveProjectName = packageJson?.name ?? projectName ?? UNKNOWN_VALUE;
+  let effectiveAuthorName = typeof packageJson?.author === "object" ? packageJson.author?.name ?? projectAuthor : packageJson?.author ?? projectAuthor ?? UNKNOWN_VALUE;
+  if (effectiveAuthorName === "blefnk" && isDev) {
+    effectiveAuthorName = "reliverse";
+  }
+  const biomeConfig = await getBiomeConfig(projectPath);
+  const detectedPkgManager = await getUserPkgManager(projectPath);
+  const packageJsonPath = path.join(projectPath, "package.json");
+  let packageData = {
+    name: effectiveProjectName,
+    author: effectiveAuthorName
+  };
+  if (await fs.pathExists(packageJsonPath)) {
+    try {
+      packageData = await readPackageJSON(projectPath);
+    } catch {
+    }
+  }
+  const detectedProjectFramework = await detectProjectFramework(projectPath);
+  return {
+    ...DEFAULT_CONFIG_RSE,
+    projectName: effectiveProjectName,
+    projectAuthor: effectiveAuthorName,
+    projectDescription: packageData.description ?? UNKNOWN_VALUE,
+    version: packageData.version ?? "0.1.0",
+    projectLicense: packageData.license ?? "MIT",
+    projectState: "creating",
+    projectRepository: typeof packageData.repository === "string" ? packageData.repository : packageData.repository?.url ?? DEFAULT_DOMAIN,
+    projectDomain: effectiveProjectName === rseName ? cliDomainDocs : DEFAULT_DOMAIN,
+    projectGitService: "github",
+    projectDeployService: "vercel",
+    repoBranch: "main",
+    projectFramework: detectedProjectFramework ?? UNKNOWN_VALUE,
+    projectPackageManager: detectedPkgManager.packageManager,
+    projectRuntime: ["node", "deno", "bun"].includes(runtimeInfo?.name ?? "") ? runtimeInfo?.name : "node",
+    codeStyle: {
+      ...DEFAULT_CONFIG_RSE.codeStyle,
+      lineWidth: biomeConfig?.lineWidth ?? 80,
+      indentSize: biomeConfig?.indentWidth ?? 2,
+      tabWidth: biomeConfig?.indentWidth ?? 2
+    }
+  };
+}
+export async function generateDefaultRulesForProject(projectPath, isDev) {
+  const projectCategory = await detectProjectFramework(projectPath);
+  const packageJsonPath = path.join(projectPath, "package.json");
+  let packageJson = {};
+  if (await fs.pathExists(packageJsonPath)) {
+    try {
+      packageJson = safeDestr(await fs.readFile(packageJsonPath, "utf-8"));
+    } catch {
+    }
+  }
+  const rules = await getDefaultRseConfig(projectPath, isDev);
+  if (!projectCategory) {
+    rules.features = {
+      ...DEFAULT_CONFIG_RSE.features,
+      language: ["typescript"],
+      themes: ["default"]
+    };
+    rules.preferredLibraries = {
+      ...DEFAULT_CONFIG_RSE.preferredLibraries,
+      databaseLibrary: "drizzle",
+      authentication: "better-auth"
+    };
+    return rules;
+  }
+  const deps = {
+    ...packageJson?.dependencies ?? {},
+    ...packageJson?.devDependencies ?? {}
+  };
+  const hasPrismaFile = await fs.pathExists(path.join(projectPath, "prisma/schema.prisma"));
+  const hasDrizzleFile = await fs.pathExists(path.join(projectPath, "drizzle.config.ts"));
+  const hasNextAuthDir = await fs.pathExists(
+    path.join(projectPath, "src/app/api/auth/[...nextauth]")
+  );
+  const hasBetterAuthFile = await fs.pathExists(
+    path.join(projectPath, "src/app/api/auth/[...all]/route.ts")
+  );
+  const hasShadcnUi = await fs.pathExists(path.join(projectPath, "components/ui"));
+  const hasClerk = "@clerk/nextjs" in deps;
+  const hasBetterAuth = "better-auth" in deps && hasBetterAuthFile;
+  const hasAuth0 = "@auth0/nextjs-auth0" in deps;
+  const hasSupabase = "@supabase/supabase-js" in deps;
+  const hasPrisma = "@prisma/client" in deps || hasPrismaFile;
+  const hasDrizzle = "drizzle-orm" in deps || hasDrizzleFile;
+  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 _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 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 hasZod = "zod" in deps;
+  const hasTypebox = "@sinclair/typebox" in deps;
+  const hasValibot = "valibot" in deps;
+  rules.features = await detectFeatures(projectPath, packageJson);
+  if (!rules.preferredLibraries) {
+    rules.preferredLibraries = { ...DEFAULT_CONFIG_RSE.preferredLibraries };
+  }
+  if (hasDrizzle) {
+    rules.preferredLibraries.databaseLibrary = "drizzle";
+  } else if (hasPrisma) {
+    rules.preferredLibraries.databaseLibrary = "prisma";
+  } else if (hasSupabase) {
+    rules.preferredLibraries.databaseLibrary = "supabase";
+  }
+  if (hasDrizzleFile) {
+    const drizzleConfigPath = path.join(projectPath, "drizzle.config.ts");
+    const content = await fs.readFile(drizzleConfigPath, "utf-8");
+    if (content.includes("postgres")) {
+      rules.preferredLibraries.databaseProvider = "pg";
+    } else if (content.includes("sqlite")) {
+      rules.preferredLibraries.databaseProvider = "sqlite";
+    } else if (content.includes("mysql")) {
+      rules.preferredLibraries.databaseProvider = "mysql";
+    }
+  } else if (hasPg) {
+    rules.preferredLibraries.databaseProvider = "pg";
+  } else if (hasMysql) {
+    rules.preferredLibraries.databaseProvider = "mysql";
+  } else if (hasSqlite) {
+    rules.preferredLibraries.databaseProvider = "sqlite";
+  } else if (hasMongo) {
+    rules.preferredLibraries.databaseProvider = "mongodb";
+  }
+  if (hasNextAuthDir) {
+    rules.preferredLibraries.authentication = "next-auth";
+  } else if (hasClerk) {
+    rules.preferredLibraries.authentication = "clerk";
+  } else if (hasBetterAuth) {
+    rules.preferredLibraries.authentication = "better-auth";
+  } else if (hasAuth0) {
+    rules.preferredLibraries.authentication = "auth0";
+  } else if (hasSupabase) {
+    rules.preferredLibraries.authentication = "supabase-auth";
+  }
+  if (hasZustand) {
+    rules.preferredLibraries.stateManagement = "zustand";
+  } else if (hasJotai) {
+    rules.preferredLibraries.stateManagement = "jotai";
+  } else if (hasRedux) {
+    rules.preferredLibraries.stateManagement = "redux-toolkit";
+  }
+  if (hasReactHookForm) {
+    rules.preferredLibraries.formManagement = "react-hook-form";
+    rules.preferredLibraries.forms = "react-hook-form";
+  } else if (hasFormik) {
+    rules.preferredLibraries.formManagement = "formik";
+  }
+  if (hasTailwind) {
+    rules.preferredLibraries.styling = "tailwind";
+  } else if (hasStyledComponents) {
+    rules.preferredLibraries.styling = "styled-components";
+  } else if (hasCssModules) {
+    rules.preferredLibraries.styling = "css-modules";
+  } else if (hasSass) {
+    rules.preferredLibraries.styling = "sass";
+  }
+  if (hasShadcnUi) {
+    rules.preferredLibraries.uiComponents = "shadcn-ui";
+  } else if (_hasChakraUi) {
+    rules.preferredLibraries.uiComponents = "chakra-ui";
+  } else if (_hasMaterialUi) {
+    rules.preferredLibraries.uiComponents = "material-ui";
+  }
+  if (_hasBunTest) {
+    rules.preferredLibraries.testing = "bun";
+  } else if (_hasVitest) {
+    rules.preferredLibraries.testing = "vitest";
+  } else if (hasJest) {
+    rules.preferredLibraries.testing = "jest";
+  } else if (_hasPlaywright) {
+    rules.preferredLibraries.testing = "playwright";
+  } else if (_hasCypress) {
+    rules.preferredLibraries.testing = "cypress";
+  }
+  if (hasHono) {
+    rules.preferredLibraries.api = "hono";
+  } else if (hasTrpc) {
+    rules.preferredLibraries.api = "trpc";
+  } else if (hasGraphql) {
+    rules.preferredLibraries.api = "graphql";
+  } else if (hasRest) {
+    rules.preferredLibraries.api = "rest";
+  }
+  if (hasZod) {
+    rules.preferredLibraries.validation = "zod";
+  } else if (hasTypebox) {
+    rules.preferredLibraries.validation = "typebox";
+  } else if (hasValibot) {
+    rules.preferredLibraries.validation = "valibot";
+  }
+  return rules;
+}

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

@@ -0,0 +1,3 @@
+import type { ProjectFramework, RseConfig } from "../types/mod.js";
+export declare const DEFAULT_CONFIG_RSE: RseConfig;
+export declare const PROJECT_FRAMEWORK_FILES: Record<ProjectFramework, string[]>;

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

@@ -0,0 +1,155 @@
+import { isBunPM, runtimeInfo } from "@reliverse/runtime";
+import { DEFAULT_DOMAIN, RSE_SCHEMA_URL, UNKNOWN_VALUE } from "./constants.js";
+export const DEFAULT_CONFIG_RSE = {
+  $schema: RSE_SCHEMA_URL,
+  projectName: UNKNOWN_VALUE,
+  projectAuthor: UNKNOWN_VALUE,
+  projectDescription: UNKNOWN_VALUE,
+  version: "0.1.0",
+  projectLicense: "MIT",
+  projectState: "creating",
+  projectRepository: DEFAULT_DOMAIN,
+  projectDomain: DEFAULT_DOMAIN,
+  projectCategory: UNKNOWN_VALUE,
+  projectSubcategory: UNKNOWN_VALUE,
+  projectTemplate: UNKNOWN_VALUE,
+  projectTemplateDate: UNKNOWN_VALUE,
+  projectArchitecture: UNKNOWN_VALUE,
+  repoPrivacy: UNKNOWN_VALUE,
+  projectGitService: "github",
+  projectDeployService: "vercel",
+  repoBranch: "main",
+  projectFramework: "nextjs",
+  projectPackageManager: await isBunPM() ? "bun" : "npm",
+  projectRuntime: ["node", "deno", "bun"].includes(runtimeInfo?.name ?? "") ? runtimeInfo?.name : "node",
+  preferredLibraries: {
+    stateManagement: UNKNOWN_VALUE,
+    formManagement: UNKNOWN_VALUE,
+    styling: UNKNOWN_VALUE,
+    uiComponents: UNKNOWN_VALUE,
+    testing: UNKNOWN_VALUE,
+    authentication: UNKNOWN_VALUE,
+    databaseLibrary: UNKNOWN_VALUE,
+    databaseProvider: UNKNOWN_VALUE,
+    api: UNKNOWN_VALUE,
+    linting: UNKNOWN_VALUE,
+    formatting: UNKNOWN_VALUE,
+    payment: UNKNOWN_VALUE,
+    analytics: UNKNOWN_VALUE,
+    monitoring: UNKNOWN_VALUE,
+    logging: UNKNOWN_VALUE,
+    forms: UNKNOWN_VALUE,
+    notifications: UNKNOWN_VALUE,
+    search: UNKNOWN_VALUE,
+    uploads: UNKNOWN_VALUE,
+    validation: UNKNOWN_VALUE,
+    documentation: UNKNOWN_VALUE,
+    icons: UNKNOWN_VALUE,
+    mail: UNKNOWN_VALUE,
+    cache: UNKNOWN_VALUE,
+    storage: UNKNOWN_VALUE,
+    cdn: UNKNOWN_VALUE,
+    cms: UNKNOWN_VALUE,
+    i18n: UNKNOWN_VALUE,
+    seo: UNKNOWN_VALUE,
+    motion: UNKNOWN_VALUE,
+    charts: UNKNOWN_VALUE,
+    dates: UNKNOWN_VALUE,
+    markdown: UNKNOWN_VALUE,
+    security: UNKNOWN_VALUE,
+    routing: UNKNOWN_VALUE
+  },
+  monorepo: {
+    type: "none",
+    packages: [],
+    sharedPackages: []
+  },
+  ignoreDependencies: [],
+  customRules: {},
+  features: {
+    i18n: false,
+    analytics: false,
+    themeMode: "dark-light",
+    authentication: true,
+    api: true,
+    database: true,
+    testing: false,
+    docker: false,
+    ci: false,
+    commands: [],
+    webview: [],
+    language: [],
+    themes: []
+  },
+  codeStyle: {
+    dontRemoveComments: true,
+    shouldAddComments: true,
+    typeOrInterface: "type",
+    importOrRequire: "import",
+    quoteMark: "double",
+    semicolons: true,
+    lineWidth: 80,
+    indentStyle: "space",
+    indentSize: 2,
+    importSymbol: "~",
+    trailingComma: "all",
+    bracketSpacing: true,
+    arrowParens: "always",
+    tabWidth: 2,
+    jsToTs: false,
+    cjsToEsm: false,
+    modernize: {
+      replaceFs: false,
+      replacePath: false,
+      replaceHttp: false,
+      replaceProcess: false,
+      replaceConsole: false,
+      replaceEvents: false
+    }
+  },
+  multipleRepoCloneMode: false,
+  customUserFocusedRepos: [],
+  customDevsFocusedRepos: [],
+  hideRepoSuggestions: false,
+  customReposOnNewProject: false,
+  envComposerOpenBrowser: true,
+  skipPromptsUseAutoBehavior: false,
+  deployBehavior: "prompt",
+  depsBehavior: "prompt",
+  gitBehavior: "prompt",
+  i18nBehavior: "prompt",
+  scriptsBehavior: "prompt",
+  existingRepoBehavior: "prompt",
+  relinterConfirm: "promptOnce"
+};
+export const PROJECT_FRAMEWORK_FILES = {
+  unknown: [],
+  nextjs: ["next.config.js", "next.config.ts", "next.config.mjs"],
+  vite: ["vite.config.js", "vite.config.ts", "react.config.js"],
+  svelte: ["svelte.config.js", "svelte.config.ts"],
+  remix: ["remix.config.js", "remix.config.ts"],
+  astro: ["astro.config.js", "astro.config.ts", "astro.config.mjs"],
+  nuxt: ["nuxt.config.js", "nuxt.config.ts"],
+  solid: ["solid.config.js", "solid.config.ts"],
+  qwik: ["qwik.config.js", "qwik.config.ts"],
+  "react-native": ["App.js", "App.tsx", "App.ts"],
+  expo: ["app.json", "app.config.js"],
+  capacitor: ["capacitor.config.ts", "capacitor.config.json"],
+  ionic: ["ionic.config.json"],
+  electron: ["electron.config.js", "electron.config.ts"],
+  tauri: ["tauri.conf.json"],
+  neutralino: ["neutralino.config.json"],
+  rempts: ["package.json:@reliverse/rempts"],
+  citty: ["package.json:citty"],
+  commander: ["package.json:commander"],
+  cac: ["package.json:cac"],
+  meow: ["package.json:meow"],
+  yargs: ["package.json:yargs"],
+  vscode: ["vscode.config.js", "vscode.config.ts"],
+  webextension: ["manifest.json"],
+  "browser-extension": ["manifest.json"],
+  "npm-jsr": ["jsr.json", "jsr.jsonc"],
+  lynx: ["App.tsx", "App.css"],
+  vue: ["vue.config.js", "vite.config.ts"],
+  wxt: ["wxt.config.js", "wxt.config.ts"]
+};