@reliverse/dler 1.7.152 → 2.0.0

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

@@ -1,5 +0,0 @@
-/**
- * Prompts the user to select a config file type (JSONC or TS)
- * @returns The selected config type ('jsonc' or 'ts')
- */
-export declare function askReliverseConfigType(): Promise<"jsonc" | "ts">;

package/bin/impl/config/prompts.js

@@ -1,12 +0,0 @@
-import { selectPrompt } from "@reliverse/rempts";
-export async function askReliverseConfigType() {
-  return await selectPrompt({
-    title: "Please select a configuration file kind.",
-    content: "TypeScript is recommended for most projects.",
-    options: [
-      { label: "TypeScript (recommended)", value: "ts" },
-      { label: "JSONC", value: "jsonc" }
-    ],
-    defaultValue: "ts"
-  });
-}

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

@@ -1,11 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-/**
- * Helper for TS config reading.
- * Uses jiti for TypeScript module loading.
- */
-export declare function readRseTs(configPath: string): Promise<ReliverseConfig | null>;
-/**
- * Reads and validates the config file.
- * If errors are detected, it attempts to merge missing or invalid fields with defaults.
- */
-export declare function readReliverseConfig(configPath: string, isDev: boolean): Promise<ReliverseConfig | null>;

package/bin/impl/config/read.js

@@ -1,62 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { parseJSONC } from "confbox";
-import { createJiti } from "jiti";
-import { writeReliverseConfig } from "./create.js";
-import { repairAndParseJSON } from "./repair.js";
-import { mergeWithDefaults } from "./update.js";
-import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
-const jiti = createJiti(import.meta.url);
-async function parseReliverseConfig(configPath) {
-  try {
-    const content = (await fs.readFile(configPath, "utf-8")).trim();
-    if (!content || content === "{}") return null;
-    let parsed = parseJSONC(content);
-    if (!parsed || typeof parsed !== "object") {
-      const repaired = repairAndParseJSON(content);
-      if (!repaired) return null;
-      parsed = repaired;
-      relinka("info", "Config JSON was repaired.");
-      relinka("verbose", "Used tool: jsonrepair.");
-    }
-    const schemaProperties = Object.keys(
-      DEFAULT_CONFIG_RELIVERSE
-    );
-    const filteredParsed = Object.fromEntries(
-      Object.entries(parsed).filter(
-        ([key]) => schemaProperties.includes(key)
-      )
-    );
-    return { parsed: filteredParsed, errors: null };
-  } catch {
-    return null;
-  }
-}
-export async function readRseTs(configPath) {
-  try {
-    const config = await jiti.import(configPath, { default: true });
-    return config;
-  } catch (error) {
-    relinka(
-      "error",
-      "Failed to import TS config:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return null;
-  }
-}
-export async function readReliverseConfig(configPath, isDev) {
-  if (configPath.endsWith(".ts")) {
-    return await readRseTs(configPath);
-  }
-  if (!await fs.pathExists(configPath)) return null;
-  const parseResult = await parseReliverseConfig(configPath);
-  if (!parseResult) return null;
-  if (!parseResult.errors) return parseResult.parsed;
-  const errors = [...parseResult.errors].map((err) => `Path "${err.path}": ${err.message}`);
-  relinka("verbose", "Detected invalid fields in config:", errors.join("; "));
-  const merged = mergeWithDefaults(parseResult.parsed);
-  await writeReliverseConfig(configPath, merged, isDev);
-  relinka("info", "Merged missing or invalid fields into config");
-  return merged;
-}

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

@@ -1,15 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-export declare function repairAndParseJSON(raw: string): any;
-/**
- * Recursively fixes each property in the object. Returns the fixed config and
- * an array of property paths that were changed.
- */
-export declare function fixLineByLine(userConfig: unknown, defaultConfig: unknown): {
-    fixedConfig: unknown;
-    changedKeys: string[];
-};
-/**
- * Reads the config file, fixes invalid lines based on the schema,
- * writes back the fixed config, and returns the fixed config.
- */
-export declare function parseAndFixReliverseConfig(configPath: string, isDev: boolean): Promise<ReliverseConfig | null>;

package/bin/impl/config/repair.js

@@ -1,101 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { parseJSONC } from "confbox";
-import { jsonrepair } from "jsonrepair";
-import { writeReliverseConfig } from "./create.js";
-import { cleanGitHubUrl } from "./utils.js";
-import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
-export function repairAndParseJSON(raw) {
-  try {
-    const repaired = jsonrepair(raw);
-    return JSON.parse(repaired);
-  } catch (_error) {
-    return null;
-  }
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function fixLineByLine(userConfig, defaultConfig) {
-  if (!isPlainObject(defaultConfig)) {
-    return {
-      fixedConfig: userConfig === void 0 ? defaultConfig : userConfig,
-      changedKeys: userConfig === void 0 ? ["<entire_object>"] : []
-    };
-  }
-  const result = { ...defaultConfig };
-  const changedKeys = [];
-  const missingKeys = [];
-  const userObj = isPlainObject(userConfig) ? userConfig : {};
-  for (const propName of Object.keys(defaultConfig)) {
-    const userValue = userObj[propName];
-    const defaultValue = defaultConfig[propName];
-    if (!(propName in userObj)) {
-      missingKeys.push(propName);
-      result[propName] = defaultValue;
-      continue;
-    }
-    if (propName === "customUserFocusedRepos" || propName === "customDevsFocusedRepos") {
-      if (Array.isArray(userValue)) {
-        result[propName] = userValue.map((url) => cleanGitHubUrl(String(url)));
-        continue;
-      }
-    }
-    if (isPlainObject(defaultValue)) {
-      const { fixedConfig, changedKeys: nested } = fixLineByLine(userValue, defaultValue);
-      result[propName] = fixedConfig;
-      if (nested.length > 0) changedKeys.push(...nested.map((n) => `${propName}.${n}`));
-    } else if (userValue === void 0) {
-      result[propName] = defaultValue;
-      changedKeys.push(propName);
-    } else {
-      result[propName] = userValue;
-    }
-  }
-  if (missingKeys.length > 0) {
-    relinka("verbose", "Missing fields injected from default config:", missingKeys.join(", "));
-  }
-  return { fixedConfig: result, changedKeys };
-}
-export async function parseAndFixReliverseConfig(configPath, isDev) {
-  try {
-    const raw = await fs.readFile(configPath, "utf-8");
-    let parsed = parseJSONC(raw);
-    if (!parsed || typeof parsed !== "object") {
-      const repaired = repairAndParseJSON(raw);
-      if (repaired) {
-        relinka("info", "Config JSON was repaired.");
-        relinka("verbose", "Used tool: jsonrepair.");
-      }
-      parsed = repaired;
-    }
-    if (parsed && typeof parsed === "object") {
-      const originalErrors = [];
-      if (originalErrors.length === 0) return parsed;
-      const { fixedConfig, changedKeys } = fixLineByLine(parsed, DEFAULT_CONFIG_RELIVERSE);
-      if (fixedConfig && typeof fixedConfig === "object") {
-        await writeReliverseConfig(configPath, fixedConfig, isDev);
-        const originalInvalidPaths = originalErrors.map((err) => err.path);
-        relinka(
-          "info",
-          "Your config has been fixed. Please ensure it aligns with your project.",
-          `Changed keys: ${changedKeys.join(", ") || "(none)"}`
-        );
-        relinka(
-          "verbose",
-          `Originally invalid paths were: ${originalInvalidPaths.join(", ") || "(none)"}`
-        );
-        return fixedConfig;
-      }
-      relinka("warn", "Could not validate all config lines. Applied best-effort fixes.");
-      return null;
-    }
-  } catch (error) {
-    relinka(
-      "warn",
-      "Failed to parse/fix config line-by-line:",
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-  return null;
-}

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

@@ -1,11 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-/**
- * Loads the rse config using c12. Merges:
- * 1) File named `rse.*`
- * 2) Optional overrides
- */
-export declare function loadrse(projectPath: string): Promise<ReliverseConfig>;
-/**
- * Watches the rse config for changes and reloads on each update.
- */
-export declare function watchrse(projectPath: string, onUpdate: (newconfig: ReliverseConfig) => void): Promise<void>;

package/bin/impl/config/unstable.js

@@ -1,29 +0,0 @@
-import { loadConfig, watchConfig } from "c12";
-import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
-export async function loadrse(projectPath) {
-  const { config } = await loadConfig({
-    cwd: projectPath,
-    name: "reliverse",
-    configFile: "reliverse",
-    // will look for files like `reliverse.{ts,jsonc}`
-    rcFile: false,
-    packageJson: false,
-    dotenv: false,
-    // disable loading .env
-    defaults: DEFAULT_CONFIG_RELIVERSE
-    // merged first
-    // overrides: overrides || {}, // highest priority
-  });
-  return config;
-}
-export async function watchrse(projectPath, onUpdate) {
-  const watcher = await watchConfig({
-    cwd: projectPath,
-    name: "reliverse",
-    onUpdate({ newConfig, getDiff }) {
-      onUpdate(newConfig);
-      console.log("Diff:", getDiff());
-    }
-  });
-  console.log("Watching config:", watcher.watchingFiles);
-}

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

@@ -1,10 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-/**
- * Updates project configuration by merging new updates with the existing config.
- * Creates a backup before overwriting and attempts to restore from backup on error.
- */
-export declare function updateReliverseConfig(projectPath: string, updates: Partial<ReliverseConfig>, isDev: boolean): Promise<boolean>;
-/**
- * Merges a partial config with the default config.
- */
-export declare function mergeWithDefaults(partial: Partial<ReliverseConfig>): ReliverseConfig;

package/bin/impl/config/update.js

@@ -1,145 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { parseJSONC } from "confbox";
-import { writeReliverseConfig } from "./create.js";
-import { getReliverseConfigPath } from "./path.js";
-import { getBackupAndTempPaths } from "./utils.js";
-import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key in source) {
-    if (!Object.hasOwn(source, key)) continue;
-    const sourceValue = source[key];
-    const targetValue = target[key];
-    if (sourceValue !== void 0) {
-      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-        result[key] = deepMerge(
-          targetValue,
-          sourceValue
-        );
-      } else {
-        result[key] = sourceValue;
-      }
-    }
-  }
-  return result;
-}
-function findObjectDifferences(obj1, obj2, path = "") {
-  const differences = [];
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
-  for (const key of allKeys) {
-    const currentPath = path ? `${path}.${key}` : key;
-    const val1 = obj1[key];
-    const val2 = obj2[key];
-    if (val1 === void 0 || val2 === void 0) {
-      differences.push(`${currentPath}: ${val1 === void 0 ? "removed" : "added"}`);
-      continue;
-    }
-    if (typeof val1 === "object" && val1 !== null && typeof val2 === "object" && val2 !== null) {
-      if (Array.isArray(val1) && Array.isArray(val2)) {
-        if (JSON.stringify(val1) !== JSON.stringify(val2)) {
-          differences.push(`${currentPath}: array values differ`);
-        }
-      } else {
-        differences.push(
-          ...findObjectDifferences(
-            val1,
-            val2,
-            currentPath
-          )
-        );
-      }
-    } else if (val1 !== val2) {
-      differences.push(`${currentPath}: ${JSON.stringify(val1)} \u2192 ${JSON.stringify(val2)}`);
-    }
-  }
-  return differences;
-}
-function filterMemoryFields(config) {
-  const { code, key, ...rest } = config;
-  return rest;
-}
-export async function updateReliverseConfig(projectPath, updates, isDev) {
-  const { configPath } = await getReliverseConfigPath(projectPath, isDev, false);
-  const { backupPath, tempPath } = getBackupAndTempPaths(configPath);
-  try {
-    let existingConfig = {};
-    if (await fs.pathExists(configPath)) {
-      const existingContent = await fs.readFile(configPath, "utf-8");
-      const parsed = parseJSONC(existingContent);
-      if (parsed && typeof parsed === "object") existingConfig = parsed;
-    }
-    const filteredUpdates = filterMemoryFields(updates);
-    const mergedConfig = deepMerge(
-      existingConfig,
-      filteredUpdates
-    );
-    const differences = findObjectDifferences(
-      existingConfig,
-      mergedConfig
-    );
-    if (differences.length === 0) {
-      relinka("verbose", "No changes detected in config, skipping update");
-      return true;
-    }
-    relinka("info", "Config changes detected:");
-    for (const diff of differences) {
-      relinka("info", `  ${diff}`);
-    }
-    if (await fs.pathExists(configPath)) {
-      await fs.copy(configPath, backupPath);
-    }
-    await writeReliverseConfig(configPath, mergedConfig, isDev);
-    if (await fs.pathExists(backupPath)) {
-      await fs.remove(backupPath);
-    }
-    relinka("null", "");
-    relinka("success", "rse config updated successfully");
-    return true;
-  } catch (error) {
-    relinka("error", "Failed to update config:", String(error));
-    if (await fs.pathExists(backupPath) && !await fs.pathExists(configPath)) {
-      try {
-        await fs.copy(backupPath, configPath);
-        relinka("warn", "Restored config from backup after failed update");
-      } catch (restoreError) {
-        relinka("error", "Failed to restore config from backup:", String(restoreError));
-      }
-    }
-    if (await fs.pathExists(tempPath)) {
-      await fs.remove(tempPath);
-    }
-    return false;
-  }
-}
-export function mergeWithDefaults(partial) {
-  return {
-    ...DEFAULT_CONFIG_RELIVERSE,
-    ...partial,
-    features: partial.features ? {
-      ...DEFAULT_CONFIG_RELIVERSE.features,
-      ...partial.features
-    } : DEFAULT_CONFIG_RELIVERSE.features,
-    codeStyle: partial.codeStyle ? {
-      ...DEFAULT_CONFIG_RELIVERSE.codeStyle ?? {},
-      ...partial.codeStyle,
-      modernize: partial.codeStyle.modernize ? {
-        ...DEFAULT_CONFIG_RELIVERSE.codeStyle?.modernize ?? {},
-        ...partial.codeStyle.modernize
-      } : DEFAULT_CONFIG_RELIVERSE.codeStyle?.modernize
-    } : DEFAULT_CONFIG_RELIVERSE.codeStyle,
-    preferredLibraries: partial.preferredLibraries ? {
-      ...DEFAULT_CONFIG_RELIVERSE.preferredLibraries,
-      ...partial.preferredLibraries
-    } : DEFAULT_CONFIG_RELIVERSE.preferredLibraries,
-    monorepo: partial.monorepo ? {
-      ...DEFAULT_CONFIG_RELIVERSE.monorepo,
-      ...partial.monorepo
-    } : DEFAULT_CONFIG_RELIVERSE.monorepo,
-    customRules: partial.customRules ? {
-      ...DEFAULT_CONFIG_RELIVERSE.customRules,
-      ...partial.customRules
-    } : DEFAULT_CONFIG_RELIVERSE.customRules,
-    ignoreDependencies: partial.ignoreDependencies ?? DEFAULT_CONFIG_RELIVERSE.ignoreDependencies
-  };
-}

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

@@ -1,17 +0,0 @@
-/**
- * Cleans GitHub repository URLs by removing git+ prefix and .git suffix.
- */
-export declare function cleanGitHubUrl(url: string): string;
-export declare function objectToCodeString(obj: any, indentLevel?: number): string;
-export declare function updateTsConfigInclude(projectPath: string): Promise<void>;
-/**
- * Returns the backup and temporary file paths for a given config file.
- */
-export declare function getBackupAndTempPaths(configPath: string): {
-    backupPath: string;
-    tempPath: string;
-};
-/**
- * Helper to atomically write a file with backup and temporary file handling.
- */
-export declare function atomicWriteFile(filePath: string, content: string, backupPath: string, tempPath: string): Promise<void>;

package/bin/impl/config/utils.js

@@ -1,85 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { readTSConfig, writeTSConfig } from "pkg-types";
-import { cliConfigTs, tsconfigJson } from "./constants.js";
-export function cleanGitHubUrl(url) {
-  return url.trim().replace(/^git\+/, "").replace(/^https?:\/\/(www\.)?(github|gitlab|bitbucket|sourcehut)\.com\//i, "").replace(/^(github|gitlab|bitbucket|sourcehut)\.com\//i, "").replace(/\.git$/i, "");
-}
-function isValidIdentifier(key) {
-  const identifierRegex = /^[A-Za-z_$][0-9A-Za-z_$]*$/;
-  return identifierRegex.test(key);
-}
-export function objectToCodeString(obj, indentLevel = 0) {
-  const indent = "  ".repeat(indentLevel);
-  const indentNext = "  ".repeat(indentLevel + 1);
-  if (obj === null) return "null";
-  if (typeof obj === "string") return JSON.stringify(obj);
-  if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
-  if (Array.isArray(obj)) {
-    if (obj.length === 0) return "[]";
-    const items = obj.map((item) => objectToCodeString(item, indentLevel + 1));
-    return `[
-${items.map((item) => `${indentNext}${item}`).join(",\n")}
-${indent}]`;
-  }
-  if (typeof obj === "object") {
-    const keys = Object.keys(obj);
-    if (keys.length === 0) return "{}";
-    const lines = keys.map((key) => {
-      const formattedKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-      const valueStr = objectToCodeString(obj[key], indentLevel + 1);
-      return `${indentNext}${formattedKey}: ${valueStr}`;
-    });
-    return `{
-${lines.join(",\n")}
-${indent}}`;
-  }
-  return String(obj);
-}
-export async function updateTsConfigInclude(projectPath) {
-  const tsconfigPath = path.join(projectPath, tsconfigJson);
-  if (!await fs.pathExists(tsconfigPath)) return;
-  try {
-    const tsconfig = await readTSConfig(projectPath);
-    tsconfig.include = Array.isArray(tsconfig.include) ? tsconfig.include : [];
-    if (!tsconfig.include.includes(cliConfigTs)) {
-      tsconfig.include.push(cliConfigTs);
-      await writeTSConfig(tsconfigPath, tsconfig);
-      relinka("verbose", "Updated tsconfig.json to include reliverse.ts");
-    }
-  } catch (err) {
-    relinka(
-      "warn",
-      "Failed to update tsconfig.json:",
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-}
-export function getBackupAndTempPaths(configPath) {
-  const configDir = path.dirname(configPath);
-  const baseName = path.basename(configPath);
-  if (configPath.endsWith(".ts")) {
-    return {
-      backupPath: path.join(configDir, `${baseName}.bak`),
-      tempPath: path.join(configDir, `${baseName}.tmp`)
-    };
-  }
-  return {
-    backupPath: path.join(configDir, `${baseName}.bak`),
-    tempPath: path.join(configDir, `${baseName}.tmp`)
-  };
-}
-export async function atomicWriteFile(filePath, content, backupPath, tempPath) {
-  if (await fs.pathExists(backupPath)) {
-    await fs.remove(backupPath);
-  }
-  if (await fs.pathExists(filePath)) {
-    await fs.copy(filePath, backupPath);
-  }
-  await fs.writeFile(tempPath, content, "utf-8");
-  await fs.rename(tempPath, filePath);
-  if (await fs.pathExists(backupPath)) {
-    await fs.remove(backupPath);
-  }
-}

package/bin/impl/conv/mod.d.ts

@@ -1,26 +0,0 @@
-/**
- * Validates that the alias is properly configured in tsconfig.json
- * @throws Error if alias is not configured in tsconfig.json
- */
-export declare function validateAliasConfig(alias: string): Promise<void>;
-/**
- * Recursively inlines (or rewrites) aliased import / re-export statements for all libraries.
- *
- * @param alias     Prefix used in module specifiers (default: "~")
- * @param subFolders Ordered sub-folder candidates to look for when chasing other libs
- * @returns Absolute paths of files that were modified
- */
-export declare function resolveCrossLibs(alias?: string, subFolders?: ("npm" | "jsr")[]): Promise<string[]>;
-/**
- * Recursively inlines (or rewrites) aliased import / re-export statements.
- *
- * @param libBinDir Folder that must start with "dist-libs/<lib>/<subFolder>/bin"
- * @param alias     Prefix used in module specifiers (default: "~")
- * @param subFolders Ordered sub-folder candidates to look for when chasing other libs
- * @returns Absolute paths of files that were modified
- */
-export declare function resolveCrossLibsInternal(libBinDir: string, alias?: string, subFolders?: ("npm" | "jsr")[]): Promise<string[]>;
-/** Per-file transformation – now multi-line aware & idempotent */
-export declare function transformFile(source: string | undefined, _filePath: string, currentLib: string, alias: string, subFolders: ("npm" | "jsr")[]): Promise<string>;
-/** Resolve: dist-libs/<lib>/<sub>/bin/<rest>.ts  (pref)  or .js */
-export declare function resolveTargetFile(lib: string, rest: string, subFolders: ("npm" | "jsr")[]): Promise<string>;