@reliverse/dler 1.7.153 → 2.0.0

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

@@ -1,148 +0,0 @@
-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/impl/build/providers/validate.d.ts

@@ -1,4 +0,0 @@
-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/impl/build/providers/validate.js

@@ -1,52 +0,0 @@
-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/impl/build/regular-flow.d.ts

@@ -1,10 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-import type { 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: ReliverseConfig): Promise<void>;
-/**
- * Publishes the main project based on commonPubRegistry.
- */
-export declare function regular_pubFlow(timer: PerfTimer, isDev: boolean, config: ReliverseConfig): Promise<void>;

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

@@ -1,246 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { createSpinnerGroup } from "@reliverse/rempts";
-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.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.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 shouldShowSpinner = config.displayBuildPubLogs === false;
-      let buildSpinnerGroup = null;
-      if (shouldShowSpinner) {
-        buildSpinnerGroup = createSpinnerGroup({
-          items: ["Building for NPM", "Building for JSR"],
-          concurrent: true,
-          color: "cyan"
-        });
-        for (const spinner of buildSpinnerGroup.spinners) {
-          spinner.start();
-        }
-      }
-      const buildTasks = [
-        async () => {
-          try {
-            await regular_buildJsrDist(
-              isDev,
-              true,
-              config.coreIsCLI,
-              config.coreEntrySrcDir,
-              config.distJsrDirName,
-              config.distJsrBuilder,
-              config.coreEntryFile,
-              config.transpileTarget,
-              config.transpileFormat,
-              config.transpileMinify,
-              config.transpileSourcemap,
-              config.transpilePublicPath,
-              config.distNpmOutFilesExt,
-              config,
-              timer,
-              config.transpileStub,
-              config.transpileWatch,
-              config.distJsrGenTsconfig,
-              config.coreDeclarations
-            );
-            if (buildSpinnerGroup?.spinners[1]) {
-              buildSpinnerGroup.spinners[1].succeed("JSR build completed");
-            }
-          } catch (error) {
-            if (buildSpinnerGroup?.spinners[1]) {
-              buildSpinnerGroup.spinners[1].fail("JSR build failed");
-            }
-            throw error;
-          }
-        },
-        async () => {
-          try {
-            await regular_buildNpmDist(
-              isDev,
-              config.coreIsCLI,
-              config.coreEntrySrcDir,
-              config.distNpmDirName,
-              config.distNpmBuilder,
-              config.coreEntryFile,
-              config.distNpmOutFilesExt,
-              config,
-              config.transpileTarget,
-              config.transpileFormat,
-              config.transpileMinify,
-              config.transpileSourcemap,
-              config.transpilePublicPath,
-              config.transpileStub,
-              config.transpileWatch,
-              timer,
-              config.coreDeclarations
-            );
-            if (buildSpinnerGroup?.spinners[0]) {
-              buildSpinnerGroup.spinners[0].succeed("NPM build completed");
-            }
-          } catch (error) {
-            if (buildSpinnerGroup?.spinners[0]) {
-              buildSpinnerGroup.spinners[0].fail("NPM build failed");
-            }
-            throw error;
-          }
-        }
-      ];
-      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;
-  }
-  const shouldShowSpinner = config.displayBuildPubLogs === false;
-  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,
-        shouldShowSpinner
-      );
-      break;
-    case "npm":
-      relinka("verbose", "Publishing main project to NPM...");
-      await regular_pubToNpm(
-        config.distJsrDryRun,
-        isDev,
-        config.commonPubPause,
-        config.distNpmDirName,
-        timer,
-        shouldShowSpinner
-      );
-      break;
-    case "npm-jsr": {
-      relinka("verbose", "Publishing main project to both NPM and JSR...");
-      let pubSpinnerGroup = null;
-      if (shouldShowSpinner) {
-        pubSpinnerGroup = createSpinnerGroup({
-          items: ["Publishing to NPM", "Publishing to JSR"],
-          concurrent: true,
-          color: "magenta"
-        });
-        for (const spinner of pubSpinnerGroup.spinners) {
-          spinner.start();
-        }
-      }
-      const publishTasks = [
-        async () => {
-          try {
-            await regular_pubToJsr(
-              config.distJsrDryRun,
-              config.distJsrFailOnWarn,
-              isDev,
-              config.commonPubPause,
-              config.distJsrDirName,
-              config.distJsrAllowDirty,
-              config.distJsrSlowTypes,
-              timer,
-              shouldShowSpinner
-            );
-            if (pubSpinnerGroup?.spinners[1]) {
-              pubSpinnerGroup.spinners[1].succeed("JSR publish completed");
-            }
-          } catch (error) {
-            if (pubSpinnerGroup?.spinners[1]) {
-              pubSpinnerGroup.spinners[1].fail("JSR publish failed");
-            }
-            throw error;
-          }
-        },
-        async () => {
-          try {
-            await regular_pubToNpm(
-              config.distJsrDryRun,
-              isDev,
-              config.commonPubPause,
-              config.distNpmDirName,
-              timer,
-              shouldShowSpinner
-            );
-            if (pubSpinnerGroup?.spinners[0]) {
-              pubSpinnerGroup.spinners[0].succeed("NPM publish completed");
-            }
-          } catch (error) {
-            if (pubSpinnerGroup?.spinners[0]) {
-              pubSpinnerGroup.spinners[0].fail("NPM publish failed");
-            }
-            throw error;
-          }
-        }
-      ];
-      await pAll(publishTasks, { concurrency: CONCURRENCY_DEFAULT });
-      break;
-    }
-    default:
-      relinka("error", `Invalid commonPubRegistry: ${config.commonPubRegistry}`);
-      throw new Error(`Invalid commonPubRegistry: ${config.commonPubRegistry}`);
-  }
-}

package/bin/impl/clone/firecrawl/firecrawl-mod.d.ts

@@ -1 +0,0 @@
-export declare function useFirecrawl(url: string): Promise<void>;

package/bin/impl/clone/firecrawl/firecrawl-mod.js

@@ -1,11 +0,0 @@
-import FirecrawlApp from "@mendable/firecrawl-js";
-export async function useFirecrawl(url) {
-  const app = new FirecrawlApp({ apiKey: process.env.FIRECRAWL_API_KEY });
-  const crawlResponse = await app.crawl(url, {
-    limit: 100,
-    scrapeOptions: {
-      formats: ["markdown", "html"]
-    }
-  });
-  console.log(crawlResponse);
-}

package/bin/impl/cmod/cmod-impl.d.ts

@@ -1,9 +0,0 @@
-/**
- * Runs each codemod one by one using `codemod <name> <optional-flags>`.
- */
-export declare function runCodemods(names: string[], options: {
-    dry?: boolean;
-    format?: boolean;
-    include?: string;
-    exclude?: string;
-}): Promise<void>;

package/bin/impl/cmod/cmod-impl.js

@@ -1,21 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { execaCommand } from "execa";
-export async function runCodemods(names, options) {
-  for (const name of names) {
-    relinka("info", `
-Applying codemod: ${name}`);
-    const cmdArgs = [name];
-    if (options.dry) cmdArgs.push("--dry");
-    if (options.format) cmdArgs.push("--format");
-    if (options.include) cmdArgs.push("-i", options.include);
-    if (options.exclude) cmdArgs.push("-e", options.exclude);
-    try {
-      await execaCommand(`codemod ${cmdArgs}`, { stdio: "inherit" });
-      relinka("info", `Successfully ran codemod: ${name}
-`);
-    } catch (error) {
-      relinka("error", `Failed to run codemod: ${name}`, String(error));
-      process.exit(1);
-    }
-  }
-}

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

@@ -1,2 +0,0 @@
-import type { BiomeConfigResult } from "../types/mod.js";
-export declare function getBiomeConfig(projectPath: string): Promise<BiomeConfigResult>;

package/bin/impl/config/biome.js

@@ -1,34 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { parseJSONC } from "confbox";
-let cachedBiomeConfig = null;
-export async function getBiomeConfig(projectPath) {
-  if (cachedBiomeConfig !== null) {
-    return cachedBiomeConfig;
-  }
-  try {
-    const biomePath = path.join(projectPath, "biome.jsonc");
-    if (await fs.pathExists(biomePath)) {
-      const content = await fs.readFile(biomePath, "utf-8");
-      const config = parseJSONC(content);
-      cachedBiomeConfig = {
-        lineWidth: config.formatter?.lineWidth ?? 80,
-        indentStyle: config.formatter?.indentStyle ?? "space",
-        indentWidth: config.formatter?.indentWidth ?? 2,
-        quoteMark: config.javascript?.formatter?.quoteStyle ?? "double",
-        semicolons: config.javascript?.formatter?.semicolons === "always",
-        trailingCommas: config.javascript?.formatter?.trailingCommas === "all"
-      };
-      return cachedBiomeConfig;
-    }
-  } catch (error) {
-    relinka(
-      "verbose",
-      "Error reading biome config:",
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-  cachedBiomeConfig = null;
-  return null;
-}

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

@@ -1 +0,0 @@
-export declare function injectSectionComments(fileContent: string): string;

package/bin/impl/config/comments.js

@@ -1,57 +0,0 @@
-import MagicString from "magic-string";
-import { cliDomainDocs } from "./constants.js";
-export function injectSectionComments(fileContent) {
-  const ms = new MagicString(fileContent);
-  const comment = (text) => text ? `// ${text}` : "";
-  const commentSections = {
-    $schema: [
-      comment(`RSE CONFIG (${cliDomainDocs})`),
-      comment("Restart the CLI to apply your config changes")
-    ],
-    projectName: [comment("General project information")],
-    skipPromptsUseAutoBehavior: [
-      comment("Enable auto-answering for prompts to skip manual confirmations."),
-      comment("Make sure you have unknown values configured above.")
-    ],
-    features: [comment("Project features")],
-    projectFramework: [comment("Primary tech stack/framework")],
-    codeStyle: [comment("Code style preferences")],
-    multipleRepoCloneMode: [comment("Settings for cloning an existing repo")],
-    envComposerOpenBrowser: [
-      comment("Set to false to disable opening the browser during env composing")
-    ],
-    ignoreDependencies: [comment("List dependencies to exclude from checks")],
-    customRules: [
-      comment("Provide custom rules for Rse AI"),
-      comment("You can use any json type here in {}")
-    ],
-    deployBehavior: [
-      comment("Prompt behavior for deployment"),
-      comment("Options: prompt | autoYes | autoNo")
-    ],
-    existingRepoBehavior: [
-      comment("Behavior for existing GitHub repos during project creation"),
-      comment("Options: prompt | autoYes | autoYesSkipCommit | autoNo")
-    ],
-    relinterConfirm: [
-      comment("Behavior for Rse AI chat and agent mode"),
-      comment("Options: promptOnce | promptEachFile | autoYes")
-    ]
-  };
-  for (const [section, lines] of Object.entries(commentSections)) {
-    if (!lines?.length) continue;
-    const combinedComments = lines.map((line, idx) => idx === 0 ? line : `  ${line}`).join("\n");
-    const regex = new RegExp(`(\\s+)(["']?)${section.replace("$", "\\$")}(\\2):`, "g");
-    let match = regex.exec(fileContent);
-    while (match !== null) {
-      const insertPos = match.index;
-      const insertion = `
-  ${combinedComments}`;
-      ms.prependLeft(insertPos, insertion);
-      match = regex.exec(fileContent);
-    }
-  }
-  let result = ms.toString();
-  result = result.replace(/\n{3,}/g, "\n\n").replace(/{\n\n/g, "{\n").replace(/\n\n}/g, "\n}");
-  return result.trim().concat("\n");
-}

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

@@ -1,45 +0,0 @@
-export declare const PROJECT_ROOT: string;
-export declare const cliVersion = "1.7.153";
-export declare const cliName = "@reliverse/rse";
-export declare const rseName = "@reliverse/rse";
-export declare const dlerName = "@reliverse/dler";
-export declare const tsconfigJson = "tsconfig.json";
-export declare const cliConfigJsonc = "reliverse.jsonc";
-export declare const cliConfigJsoncTmp = "reliverse.jsonc.tmp";
-export declare const cliConfigJsoncBak = "reliverse.jsonc.bak";
-export declare const cliConfigTs = "reliverse.ts";
-export declare const cliConfigTsTmp = "reliverse.ts.tmp";
-export declare const cliConfigTsBak = "reliverse.ts.bak";
-export declare const rseOrg = "https://reliverse.org";
-export declare const rseOrgBase = "reliverse.org";
-export declare const cliDomainRoot = "https://docs.reliverse.org";
-export declare const cliDomainDocs = "https://docs.reliverse.org/cli";
-export declare const cliDomainEnv = "https://docs.reliverse.org/env";
-export declare const homeDir: any;
-export declare const cliHomeDir: string;
-export declare const cliHomeTmp: string;
-export declare const cliHomeRepos: string;
-export declare const memoryPath: string;
-export declare const cliJsrPath: string;
-export declare const useLocalhost = false;
-export declare const DEFAULT_CLI_USERNAME = "johnny911";
-export declare const endTitle = "\uD83D\uDCDA Check the docs to learn more: https://docs.reliverse.org/cli";
-export declare const UNKNOWN_VALUE = "unknown";
-export declare const UNKNOWN_STRING = "\"unknown\"";
-export declare const DEFAULT_DOMAIN = "https://example.com";
-export declare const RSE_SCHEMA_DEV = "./schema.json";
-export declare const RSE_SCHEMA_URL = "https://reliverse.org/schema.json";
-export declare const FALLBACK_ENV_EXAMPLE_URL = "https://raw.githubusercontent.com/blefnk/relivator/main/.env.example";
-export declare const CONFIG_CATEGORIES: {
-    readonly core: readonly ["reliverse.jsonc", "reliverse.ts"];
-    readonly linting: readonly ["biome.json"];
-    readonly ide: readonly [".vscode/settings.json"];
-    readonly git: readonly [".gitignore"];
-};
-export declare const IGNORE_PATTERNS: readonly ["node_modules", ".git", ".next", ".vercel", "coverage", ".nyc_output", "dist", "build", ".cache", ".temp", ".tmp"];
-export declare const CONCURRENCY_DEFAULT = 1;
-export declare const validExtensions: string[];
-export declare const SHOW_VERBOSE: {
-    getDirectorySize: boolean;
-    readFileSafe: boolean;
-};