@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/config/constants.js

@@ -1,60 +0,0 @@
-import os from "node:os";
-import path from "@reliverse/pathkit";
-export const PROJECT_ROOT = path.resolve(process.cwd());
-const version = "1.7.153";
-export const cliVersion = version;
-export const cliName = "@reliverse/rse";
-export const rseName = "@reliverse/rse";
-export const dlerName = "@reliverse/dler";
-export const tsconfigJson = "tsconfig.json";
-export const cliConfigJsonc = "reliverse.jsonc";
-export const cliConfigJsoncTmp = "reliverse.jsonc.tmp";
-export const cliConfigJsoncBak = "reliverse.jsonc.bak";
-export const cliConfigTs = "reliverse.ts";
-export const cliConfigTsTmp = "reliverse.ts.tmp";
-export const cliConfigTsBak = "reliverse.ts.bak";
-export const rseOrg = "https://reliverse.org";
-export const rseOrgBase = `reliverse.org`;
-export const cliDomainRoot = `https://docs.reliverse.org`;
-export const cliDomainDocs = `https://docs.reliverse.org/cli`;
-export const cliDomainEnv = `https://docs.reliverse.org/env`;
-export const homeDir = os.homedir();
-export const cliHomeDir = path.join(homeDir, ".reliverse", "rse");
-export const cliHomeTmp = path.join(cliHomeDir, "temp");
-export const cliHomeRepos = path.join(cliHomeDir, "repos");
-export const memoryPath = path.join(cliHomeDir, "memory.db");
-export const cliJsrPath = path.join(cliHomeDir, "cli");
-export const useLocalhost = false;
-export const DEFAULT_CLI_USERNAME = "johnny911";
-export const endTitle = `\u{1F4DA} Check the docs to learn more: ${cliDomainDocs}`;
-export const UNKNOWN_VALUE = "unknown";
-export const UNKNOWN_STRING = `"unknown"`;
-export const DEFAULT_DOMAIN = "https://example.com";
-export const RSE_SCHEMA_DEV = "./schema.json";
-export const RSE_SCHEMA_URL = `${rseOrg}/schema.json`;
-export const FALLBACK_ENV_EXAMPLE_URL = "https://raw.githubusercontent.com/blefnk/relivator/main/.env.example";
-export const CONFIG_CATEGORIES = {
-  core: [cliConfigJsonc, cliConfigTs],
-  linting: ["biome.json"],
-  ide: [".vscode/settings.json"],
-  git: [".gitignore"]
-};
-export const IGNORE_PATTERNS = [
-  "node_modules",
-  ".git",
-  ".next",
-  ".vercel",
-  "coverage",
-  ".nyc_output",
-  "dist",
-  "build",
-  ".cache",
-  ".temp",
-  ".tmp"
-];
-export const CONCURRENCY_DEFAULT = 1;
-export const validExtensions = ["cjs", "js", "mjs", "ts", "mts", "cts"];
-export const SHOW_VERBOSE = {
-  getDirectorySize: false,
-  readFileSafe: false
-};

package/bin/impl/config/content.d.ts

@@ -1,14 +0,0 @@
-export interface RequiredProjectContent {
-    fileReliverseConfig: boolean;
-    filePackageJson: boolean;
-}
-/**
- * Gets information about the project content, separating required and optional elements.
- */
-export declare function getProjectContent(projectPath: string): Promise<{
-    requiredContent: RequiredProjectContent;
-    optionalContent: {
-        dirNodeModules: boolean;
-        dirGit: boolean;
-    };
-}>;

package/bin/impl/config/content.js

@@ -1,15 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { cliConfigJsonc, cliConfigTs } from "./constants.js";
-export async function getProjectContent(projectPath) {
-  const configJSONC = path.join(projectPath, cliConfigJsonc);
-  const configTS = path.join(projectPath, cliConfigTs);
-  const fileReliverseConfig = await fs.pathExists(configJSONC) || await fs.pathExists(configTS);
-  const filePackageJson = await fs.pathExists(path.join(projectPath, "package.json"));
-  const dirNodeModules = await fs.pathExists(path.join(projectPath, "node_modules"));
-  const dirGit = await fs.pathExists(path.join(projectPath, ".git"));
-  return {
-    requiredContent: { fileReliverseConfig, filePackageJson },
-    optionalContent: { dirNodeModules, dirGit }
-  };
-}

package/bin/impl/config/core.d.ts

@@ -1,14 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-/**
- * Retrieves or creates the main rseg (and any 'mrse' configs).
- * Allows an optional custom path to the TS config file.
- */
-export declare function getOrCreateReliverseConfig({ projectPath, isDev, overrides, customTsconfigPath, }: {
-    projectPath: string;
-    isDev: boolean;
-    overrides: Partial<ReliverseConfig>;
-    customTsconfigPath?: string;
-}): Promise<{
-    config: ReliverseConfig;
-    mrse: ReliverseConfig[];
-}>;

package/bin/impl/config/core.js

@@ -1,79 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import {
-  cliConfigJsonc,
-  cliConfigTs,
-  RSE_SCHEMA_DEV,
-  UNKNOWN_VALUE
-} from "./constants.js";
-import { createReliverseConfig } from "./create.js";
-import { getReliverseConfigPath } from "./path.js";
-import { readReliverseConfig } from "./read.js";
-import { parseAndFixReliverseConfig } from "./repair.js";
-import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
-export async function getOrCreateReliverseConfig({
-  projectPath,
-  isDev,
-  overrides,
-  customTsconfigPath
-}) {
-  const githubUsername = UNKNOWN_VALUE;
-  const mrseFolderPath = path.join(projectPath, "mrse");
-  const results = [];
-  if (await fs.pathExists(mrseFolderPath)) {
-    const dirItems = await fs.readdir(mrseFolderPath);
-    const rseFiles = dirItems.filter((item) => item === cliConfigJsonc || item === cliConfigTs);
-    const configs = await Promise.all(
-      rseFiles.map(async (file) => {
-        const filePath = path.join(mrseFolderPath, file);
-        let foundConfig = await readReliverseConfig(filePath, isDev);
-        if (!foundConfig) {
-          foundConfig = await parseAndFixReliverseConfig(filePath, isDev);
-        }
-        if (!foundConfig) {
-          relinka("warn", `Skipping invalid config file: ${filePath}`);
-        }
-        return foundConfig;
-      })
-    );
-    results.push(
-      ...configs.filter((cfg) => cfg !== null)
-    );
-  }
-  const { configPath } = await getReliverseConfigPath(
-    projectPath,
-    isDev,
-    false,
-    customTsconfigPath
-  );
-  if (!await fs.pathExists(configPath)) {
-    await createReliverseConfig(projectPath, githubUsername, isDev, overrides);
-  } else {
-    const content = (await fs.readFile(configPath, "utf-8")).trim();
-    if (!content || content === "{}") {
-      await createReliverseConfig(projectPath, githubUsername, isDev, overrides);
-    } else {
-      const validConfig = await readReliverseConfig(configPath, isDev);
-      if (!validConfig) {
-        const fixed = await parseAndFixReliverseConfig(configPath, isDev);
-        if (!fixed) {
-          relinka("warn", "Could not fix existing config. Using fallback defaults.");
-        }
-      }
-    }
-  }
-  const mainConfig = await readReliverseConfig(configPath, isDev);
-  if (!mainConfig) {
-    relinka("warn", "Using fallback default config due to validation failure.");
-    const fallbackConfig = { ...DEFAULT_CONFIG_RELIVERSE };
-    if (isDev) {
-      fallbackConfig.$schema = RSE_SCHEMA_DEV;
-    }
-    return { config: fallbackConfig, mrse: results };
-  }
-  if (isDev) {
-    mainConfig.$schema = RSE_SCHEMA_DEV;
-  }
-  return { config: mainConfig, mrse: results };
-}

package/bin/impl/config/create.d.ts

@@ -1,35 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-import type { DeploymentService } from "../types/mod.js";
-/**
- * Writes the given rseConfig to the specified config file (TypeScript or JSONC).
- * Performs an atomic write (using a temp file) and creates a backup of any existing config.
- * In dev mode, automatically builds a relative path to `sdk-mod.ts`.
- */
-export declare function writeReliverseConfig(configPath: string, config: ReliverseConfig, isDev: boolean, skipInstallPrompt?: boolean): Promise<void>;
-/**
- * rse Config Creation (wrapper around config generator and fixer)
- */
-export declare function createReliverseConfig(projectPath: string, githubUsername: string, isDev: boolean, overrides: Partial<ReliverseConfig>): Promise<void>;
-/**
- * Generates a rse config (rseConfig) by merging defaults, existing config, and overrides.
- * Writes the resulting config to disk (TypeScript or JSONC), optionally skipping install prompts in non-dev mode.
- */
-export declare function generateReliverseConfig({ projectName, frontendUsername, deployService, primaryDomain, projectPath, githubUsername, enableI18n, overwrite, isDev, configInfo, customOutputPath, customFilename, skipInstallPrompt, overrides, }: {
-    projectName: string;
-    frontendUsername: string;
-    deployService: DeploymentService;
-    primaryDomain: string;
-    projectPath: string;
-    githubUsername: string;
-    enableI18n?: boolean;
-    overwrite?: boolean;
-    isDev: boolean;
-    configInfo?: {
-        configPath: string;
-        isTS: boolean;
-    };
-    customOutputPath?: string;
-    customFilename?: string;
-    skipInstallPrompt?: boolean;
-    overrides: Partial<ReliverseConfig>;
-}): Promise<void>;

package/bin/impl/config/create.js

@@ -1,274 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt } from "@reliverse/rempts";
-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 "./comments.js";
-import {
-  cliDomainDocs,
-  DEFAULT_DOMAIN,
-  RSE_SCHEMA_DEV,
-  rseName,
-  UNKNOWN_VALUE
-} from "./constants.js";
-import { generateDefaultRulesForProject, getDefaultReliverseConfig } from "./def-utils.js";
-import { detectFeatures, getPackageJson } from "./detect.js";
-import { getReliverseConfigPath } from "./path.js";
-import { readReliverseConfig } from "./read.js";
-import {
-  atomicWriteFile,
-  cleanGitHubUrl,
-  getBackupAndTempPaths,
-  objectToCodeString,
-  updateTsConfigInclude
-} from "./utils.js";
-import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
-export async function writeReliverseConfig(configPath, config, isDev, skipInstallPrompt = false) {
-  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 defineImport = "./reltypes";
-      try {
-        const pkgPath = path.join(path.dirname(configPath), "package.json");
-        if (await fs.pathExists(pkgPath)) {
-          const pkgRaw = await fs.readFile(pkgPath, "utf8");
-          const pkg = JSON.parse(pkgRaw);
-          if (pkg.name === "@reliverse/dler") {
-            defineImport = "./src/mod.ts";
-          } else {
-            const hasDler = Boolean(
-              pkg.dependencies && pkg.dependencies["@reliverse/dler"] || pkg.devDependencies && pkg.devDependencies["@reliverse/dler"]
-            );
-            if (hasDler) defineImport = "@reliverse/dler";
-          }
-        }
-      } catch {
-      }
-      const fileContent2 = `import { defineConfig } from "${defineImport}";
-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;
-    }
-  }
-  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 createReliverseConfig(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 = "reliverse";
-  }
-  await generateReliverseConfig({
-    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 generateReliverseConfig({
-  projectName,
-  frontendUsername,
-  deployService,
-  primaryDomain,
-  projectPath,
-  githubUsername,
-  enableI18n = false,
-  overwrite = false,
-  isDev,
-  configInfo,
-  customOutputPath,
-  customFilename,
-  skipInstallPrompt = false,
-  overrides
-}) {
-  const packageJson = await getPackageJson(projectPath);
-  if (frontendUsername === "blefnk" && isDev) {
-    frontendUsername = "reliverse";
-  }
-  const defaultConfig = await getDefaultReliverseConfig(
-    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: "~",
-    trailingCommas: "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 getReliverseConfigPath(projectPath, isDev, skipInstallPrompt);
-    effectiveConfigPath = configPathInfo.configPath;
-  }
-  let existingContent = null;
-  if (!overwrite && await fs.pathExists(effectiveConfigPath)) {
-    try {
-      existingContent = await readReliverseConfig(effectiveConfigPath, isDev);
-    } catch {
-    }
-  }
-  const effectiveConfig = {
-    ...DEFAULT_CONFIG_RELIVERSE,
-    ...existingContent,
-    ...defaultConfig,
-    ...overrides
-  };
-  if (isDev) {
-    effectiveConfig.$schema = RSE_SCHEMA_DEV;
-  }
-  await writeReliverseConfig(effectiveConfigPath, effectiveConfig, isDev, skipInstallPrompt);
-}

package/bin/impl/config/def-utils.d.ts

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