@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/utils/resolve-cross-libs.js

@@ -1,641 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { relinka } from "@reliverse/relinka";
-import { createJiti } from "jiti";
-async function resolveCrossLibsViaInline(libBinDir, alias = "~", subFolders = ["npm", "jsr"], buildPreExtensions, buildTemplatesDir) {
-  const normalizedPath = libBinDir.replace(/\\/g, "/");
-  if (!normalizedPath.startsWith("dist-libs") && !normalizedPath.startsWith("dist-jsr") && !normalizedPath.startsWith("dist-npm")) {
-    throw new Error(
-      `[resolve-cross-libs] libBinDir must start with "dist-libs", "dist-jsr", or "dist-npm", got: ${libBinDir}`
-    );
-  }
-  if (normalizedPath.startsWith("dist-libs")) {
-    const pathParts = normalizedPath.replace(/\/$/, "").split("/");
-    if (pathParts.length < 4) {
-      throw new Error(
-        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, expected dist-libs/<lib>/<subfolder>/bin`
-      );
-    }
-    const currentLib = pathParts[1];
-    if (!currentLib) {
-      throw new Error(
-        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, could not extract library name`
-      );
-    }
-    const files = await findSourceFiles(libBinDir, buildPreExtensions, buildTemplatesDir);
-    const modifiedFiles = [];
-    await Promise.all(
-      files.map(async (filePath) => {
-        const content = await fs.readFile(filePath, "utf-8");
-        const processed = await processFileViaInline(
-          content,
-          currentLib,
-          alias,
-          subFolders,
-          filePath
-        );
-        if (processed !== content) {
-          relinka("verbose", `[resolve-cross-libs] File modified: ${filePath}`);
-          await fs.writeFile(filePath, processed, "utf-8");
-          modifiedFiles.push(path.resolve(filePath));
-        }
-      })
-    );
-    return modifiedFiles;
-  }
-  return [];
-}
-async function findSourceFiles(dir, buildPreExtensions, buildTemplatesDir) {
-  const files = [];
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  await Promise.all(
-    entries.map(async (entry) => {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const subFiles = await findSourceFiles(fullPath, buildPreExtensions, buildTemplatesDir);
-        files.push(...subFiles);
-      } else if (entry.isFile()) {
-        const ext = path.extname(entry.name).slice(1);
-        const isDts = entry.name.endsWith(".d.ts");
-        const isInTemplatesDir = fullPath.includes(`/${buildTemplatesDir}/`);
-        if (isInTemplatesDir) {
-          return;
-        }
-        if (isDts) {
-          files.push(fullPath);
-          return;
-        }
-        if (!buildPreExtensions.includes(ext)) {
-          return;
-        }
-        if (ext === "js" || ext === "ts") {
-          files.push(fullPath);
-        }
-      }
-    })
-  );
-  return files;
-}
-function escapeRegex(str) {
-  if (!str || typeof str !== "string") {
-    return "";
-  }
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function processFileViaInline(content, currentLib, alias, subFolders, currentFilePath) {
-  const lines = content.split("\n");
-  const result = [];
-  let insideInlined = false;
-  for (const line of lines) {
-    if (line.includes("/* inlined-start ")) {
-      insideInlined = true;
-      relinka("verbose", `[resolve-cross-libs] Entering inlined block: ${line.trim()}`);
-      result.push(line);
-      continue;
-    }
-    if (line.includes("/* inlined-end */")) {
-      insideInlined = false;
-      result.push(line);
-      continue;
-    }
-    if (insideInlined) {
-      result.push(line);
-      continue;
-    }
-    const pattern = new RegExp(
-      `^(\\s*)((?:export\\s+.*?\\s+from|import\\s+.*?\\s+from)\\s+(['"])${escapeRegex(alias)}/libs/([^/]+)/([^'"]*?)\\3[^;]*;?)(\\s*//.*)?\\s*$`
-    );
-    const match = line.match(pattern);
-    if (match) {
-      const [, indentation, fullStatement, quote, libName, rest, comment] = match;
-      relinka("verbose", `[resolve-cross-libs] Processing import/export: ${libName}/${rest}`);
-      if (fullStatement?.includes(`${quote}./`)) {
-        result.push(line);
-        continue;
-      }
-      if (libName === currentLib) {
-        const newStatement = fullStatement?.replace(`${quote}${alias}/libs/${libName}/`, `${quote}./`) ?? "";
-        result.push(`${indentation}${newStatement}${comment || ""}`);
-      } else {
-        try {
-          if (!libName || !rest) {
-            throw new Error("Library name or path is undefined");
-          }
-          relinka("verbose", `[resolve-cross-libs] Attempting to inline: ${libName}/${rest}`);
-          const targetPath = await resolveTargetFile(libName, rest, subFolders, currentFilePath);
-          const targetContent = await fs.readFile(targetPath, "utf-8");
-          result.push(`${indentation}/* inlined-start ${alias}/libs/${libName}/${rest} */`);
-          const targetLines = targetContent.split("\n");
-          relinka(
-            "log",
-            `[resolve-cross-libs] Inlining ${targetLines.length} lines from ${targetPath}`
-          );
-          for (const targetLine of targetLines) {
-            result.push(`${indentation}${targetLine}`);
-          }
-          result.push(`${indentation}/* inlined-end */`);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          relinka(
-            "error",
-            `[resolve-cross-libs] Failed to inline ${alias}/libs/${libName}/${rest}: ${errorMessage}`
-          );
-          throw error;
-        }
-      }
-    } else {
-      result.push(line);
-    }
-  }
-  return result.join("\n");
-}
-async function resolveTargetFile(libName, rest, subFolders, currentFilePath) {
-  relinka("verbose", `[resolve-cross-libs] Resolving target file for ${libName}/${rest}`);
-  const isCurrentFileDts = currentFilePath.endsWith(".d.ts");
-  const extensions = isCurrentFileDts ? [".d.ts", ".ts", ".js"] : [".ts", ".js", ".d.ts"];
-  for (const subFolder of subFolders) {
-    const basePath = path.join("dist-libs", libName, subFolder, "bin", rest);
-    for (const ext of extensions) {
-      const fullPath = `${basePath}${ext}`;
-      try {
-        await fs.access(fullPath);
-        return fullPath;
-      } catch {
-      }
-    }
-  }
-  throw new Error(
-    `Could not resolve target file for libs/${libName}/${rest} in any subfolder: ${subFolders.join(", ")}`
-  );
-}
-async function directoryExists(dirPath) {
-  try {
-    const stat = await fs.stat(dirPath);
-    return stat.isDirectory();
-  } catch (error) {
-    if (error instanceof Error && error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-async function resolveAllCrossLibsViaInline(alias = "~", subFolders = ["npm", "jsr"], buildPreExtensions, buildTemplatesDir) {
-  const distLibsDir = "dist-libs";
-  const allModifiedFiles = [];
-  const distLibsExists = await directoryExists(distLibsDir);
-  if (distLibsExists) {
-    const entries = await fs.readdir(distLibsDir, { withFileTypes: true });
-    const libDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    await Promise.all(
-      libDirs.map(async (libName) => {
-        for (const subFolder of subFolders) {
-          const binDir = path.join(distLibsDir, libName, subFolder, "bin");
-          const binDirExists = await directoryExists(binDir);
-          if (binDirExists) {
-            try {
-              const modifiedFiles = await resolveCrossLibsViaInline(
-                binDir,
-                alias,
-                subFolders,
-                buildPreExtensions,
-                buildTemplatesDir
-              );
-              allModifiedFiles.push(...modifiedFiles);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              relinka(
-                "error",
-                `[resolveAllCrossLibsViaInline] Error processing ${binDir}: ${errorMessage}`
-              );
-              throw error;
-            }
-          } else {
-          }
-        }
-      })
-    );
-  }
-  if (allModifiedFiles.length > 0) {
-    relinka("info", "[resolveAllCrossLibsViaInline] Cross libraries replacements done in:");
-    relinka("verbose", "[resolveAllCrossLibsViaInline] " + allModifiedFiles.join(", "));
-  }
-  return allModifiedFiles;
-}
-async function resolveCrossLibsViaCopy(libBinDir, alias = "~", subFolders = ["npm", "jsr"], buildPreExtensions, buildTemplatesDir) {
-  const normalizedPath = libBinDir.replace(/\\/g, "/");
-  if (!normalizedPath.startsWith("dist-libs") && !normalizedPath.startsWith("dist-jsr") && !normalizedPath.startsWith("dist-npm")) {
-    throw new Error(
-      `[resolve-cross-libs] libBinDir must start with "dist-libs", "dist-jsr", or "dist-npm", got: ${libBinDir}`
-    );
-  }
-  if (normalizedPath.startsWith("dist-libs")) {
-    const pathParts = normalizedPath.replace(/\/$/, "").split("/");
-    if (pathParts.length < 4) {
-      throw new Error(
-        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, expected dist-libs/<lib>/<subfolder>/bin`
-      );
-    }
-    const currentLib = pathParts[1];
-    const currentSubFolder = pathParts[2];
-    if (!currentLib || !currentSubFolder) {
-      throw new Error(
-        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, could not extract library name or subfolder`
-      );
-    }
-    const files = await findSourceFiles(libBinDir, buildPreExtensions, buildTemplatesDir);
-    const modifiedFiles = [];
-    const copiedLibs = /* @__PURE__ */ new Set();
-    await Promise.all(
-      files.map(async (filePath) => {
-        const content = await fs.readFile(filePath, "utf-8");
-        const { processed, copiedLibraries } = await processFileViaCopy(
-          content,
-          currentLib,
-          currentSubFolder,
-          alias,
-          subFolders,
-          filePath
-        );
-        if (processed !== content) {
-          relinka("verbose", `[resolveCrossLibsViaCopy] File modified: ${filePath}`);
-          await fs.writeFile(filePath, processed, "utf-8");
-          modifiedFiles.push(path.resolve(filePath));
-        }
-        copiedLibraries.forEach((lib) => copiedLibs.add(lib));
-      })
-    );
-    for (const libName of copiedLibs) {
-      await copyLibraryDirectory(libName, currentSubFolder, subFolders);
-    }
-    return modifiedFiles;
-  }
-  return [];
-}
-async function processFileViaCopy(content, currentLib, _currentSubFolder, alias, _subFolders, _currentFilePath) {
-  const lines = content.split("\n");
-  const result = [];
-  const copiedLibraries = /* @__PURE__ */ new Set();
-  for (const line of lines) {
-    const pattern = new RegExp(
-      `^(\\s*)((?:export\\s+.*?\\s+from|import\\s+.*?\\s+from)\\s+(['"])${escapeRegex(alias)}/libs/([^/]+)/([^'"]*?)\\3[^;]*;?)(\\s*//.*)?\\s*$`
-    );
-    const match = line.match(pattern);
-    if (match) {
-      const [, indentation, fullStatement, quote, libName, rest, comment] = match;
-      relinka("verbose", `[resolveCrossLibsViaCopy] Processing import/export: ${libName}/${rest}`);
-      if (fullStatement?.includes(`${quote}./`)) {
-        result.push(line);
-        continue;
-      }
-      if (libName === currentLib) {
-        const newStatement = fullStatement?.replace(`${quote}${alias}/libs/${libName}/`, `${quote}./`) ?? "";
-        result.push(`${indentation}${newStatement}${comment || ""}`);
-      } else {
-        try {
-          if (!libName || !rest) {
-            throw new Error("Library name or path is undefined");
-          }
-          relinka(
-            "verbose",
-            `[resolveCrossLibsViaCopy] Rewriting to copied path: ${libName}/${rest}`
-          );
-          copiedLibraries.add(libName);
-          const newStatement = fullStatement?.replace(
-            `${quote}${alias}/libs/${libName}/`,
-            `${quote}../#${libName}/`
-          ) ?? "";
-          result.push(`${indentation}${newStatement}${comment || ""}`);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          relinka(
-            "error",
-            `[resolveCrossLibsViaCopy] Failed to rewrite ${alias}/libs/${libName}/${rest}: ${errorMessage}`
-          );
-          throw error;
-        }
-      }
-    } else {
-      result.push(line);
-    }
-  }
-  return { processed: result.join("\n"), copiedLibraries };
-}
-async function copyLibraryDirectory(libName, _currentSubFolder, _subFolders) {
-  const sourceDir = path.join("dist-libs", libName);
-  const targetDir = path.join("dist-libs", `#${libName}`);
-  try {
-    await fs.access(targetDir);
-    relinka(
-      "verbose",
-      `[resolveCrossLibsViaCopy] Library ${libName} already copied to ${targetDir}`
-    );
-    return;
-  } catch {
-  }
-  try {
-    relinka(
-      "log",
-      `[resolveCrossLibsViaCopy] Copying library ${libName} from ${sourceDir} to ${targetDir}`
-    );
-    await copyDirectoryRecursive(sourceDir, targetDir);
-    relinka("verbose", `[resolveCrossLibsViaCopy] Successfully copied library ${libName}`);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    relinka(
-      "error",
-      `[resolveCrossLibsViaCopy] Failed to copy library ${libName}: ${errorMessage}`
-    );
-    throw error;
-  }
-}
-async function copyDirectoryRecursive(source, target) {
-  await fs.mkdir(target, { recursive: true });
-  const entries = await fs.readdir(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = path.join(source, entry.name);
-    const targetPath = path.join(target, entry.name);
-    if (entry.isDirectory()) {
-      await copyDirectoryRecursive(sourcePath, targetPath);
-    } else {
-      await fs.copyFile(sourcePath, targetPath);
-    }
-  }
-}
-async function resolveAllCrossLibsViaCopy(alias = "~", subFolders = ["npm", "jsr"], buildPreExtensions, buildTemplatesDir) {
-  const distLibsDir = "dist-libs";
-  const allModifiedFiles = [];
-  const distLibsExists = await directoryExists(distLibsDir);
-  if (distLibsExists) {
-    const entries = await fs.readdir(distLibsDir, { withFileTypes: true });
-    const libDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    await Promise.all(
-      libDirs.map(async (libName) => {
-        for (const subFolder of subFolders) {
-          const binDir = path.join(distLibsDir, libName, subFolder, "bin");
-          const binDirExists = await directoryExists(binDir);
-          if (binDirExists) {
-            try {
-              const modifiedFiles = await resolveCrossLibsViaCopy(
-                binDir,
-                alias,
-                subFolders,
-                buildPreExtensions,
-                buildTemplatesDir
-              );
-              allModifiedFiles.push(...modifiedFiles);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              relinka(
-                "error",
-                `[resolveAllCrossLibsViaCopy] Error processing ${binDir}: ${errorMessage}`
-              );
-              throw error;
-            }
-          } else {
-          }
-        }
-      })
-    );
-  }
-  if (allModifiedFiles.length > 0) {
-    relinka("info", "[resolveAllCrossLibsViaCopy] Cross libraries copy replacements done in:");
-    relinka("verbose", "[resolveAllCrossLibsViaCopy] " + allModifiedFiles.join(", "));
-  }
-  return allModifiedFiles;
-}
-export async function resolveAllCrossLibs(strategy = "inline", alias = "~", subFolders = ["npm", "jsr"], buildPreExtensions, buildTemplatesDir) {
-  switch (strategy) {
-    case "inline":
-      return await resolveAllCrossLibsViaInline(
-        alias,
-        subFolders,
-        buildPreExtensions,
-        buildTemplatesDir
-      );
-    case "copy":
-      return await resolveAllCrossLibsViaCopy(
-        alias,
-        subFolders,
-        buildPreExtensions,
-        buildTemplatesDir
-      );
-    case "package":
-      return await resolveAllCrossLibsViaPackage(
-        alias,
-        subFolders,
-        buildPreExtensions,
-        buildTemplatesDir
-      );
-    default:
-      throw new Error(
-        `[resolveAllCrossLibs] Unknown strategy: ${strategy}. Supported strategies: inline, copy, package`
-      );
-  }
-}
-async function loadReliverseConfig() {
-  try {
-    const jiti = createJiti(import.meta.url);
-    const config = await jiti.import("reliverse.ts", { default: true });
-    return { libsList: config?.libsList || {} };
-  } catch (error) {
-    relinka(
-      "error",
-      `[resolveCrossLibsViaPackage] Failed to load dler config: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return { libsList: {} };
-  }
-}
-function createLibDirToPackageMap(libsList) {
-  const mapping = {};
-  for (const [packageName, libConfig] of Object.entries(libsList)) {
-    if (libConfig?.libDirName) {
-      mapping[libConfig.libDirName] = packageName;
-    }
-  }
-  return mapping;
-}
-async function addDependencyToPackageJson(packageJsonPath, packageName, dependencyType = "dependencies") {
-  try {
-    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    if (!packageJson[dependencyType]) {
-      packageJson[dependencyType] = {};
-    }
-    if (!packageJson[dependencyType][packageName]) {
-      packageJson[dependencyType][packageName] = "*";
-      relinka(
-        "log",
-        `[resolveCrossLibsViaPackage] Added ${packageName} to ${dependencyType} in ${packageJsonPath}`
-      );
-      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
-    } else {
-      relinka(
-        "log",
-        `[resolveCrossLibsViaPackage] ${packageName} already exists in ${dependencyType} in ${packageJsonPath}`
-      );
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    relinka(
-      "error",
-      `[resolveCrossLibsViaPackage] Failed to add dependency ${packageName} to ${packageJsonPath}: ${errorMessage}`
-    );
-    throw error;
-  }
-}
-async function resolveCrossLibsViaPackage(libBinDir, alias = "~", buildPreExtensions, buildTemplatesDir) {
-  const normalizedPath = libBinDir.replace(/\\/g, "/");
-  if (!normalizedPath.startsWith("dist-libs") && !normalizedPath.startsWith("dist-jsr") && !normalizedPath.startsWith("dist-npm")) {
-    throw new Error(
-      `[resolve-cross-libs] libBinDir must start with "dist-libs", "dist-jsr", or "dist-npm", got: ${libBinDir}`
-    );
-  }
-  if (normalizedPath.startsWith("dist-libs")) {
-    const pathParts = normalizedPath.replace(/\/$/, "").split("/");
-    if (pathParts.length < 4) {
-      throw new Error(
-        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, expected dist-libs/<lib>/<subfolder>/bin`
-      );
-    }
-    const currentLib = pathParts[1];
-    const currentSubFolder = pathParts[2];
-    if (!currentLib || !currentSubFolder) {
-      throw new Error(
-        `[resolve-cross-libs] Invalid libBinDir structure: ${libBinDir}, could not extract library name or subfolder`
-      );
-    }
-    const { libsList } = await loadReliverseConfig();
-    const libDirToPackageMap = createLibDirToPackageMap(libsList);
-    const files = await findSourceFiles(libBinDir, buildPreExtensions, buildTemplatesDir);
-    const modifiedFiles = [];
-    const addedDependencies = /* @__PURE__ */ new Set();
-    await Promise.all(
-      files.map(async (filePath) => {
-        const content = await fs.readFile(filePath, "utf-8");
-        const { processed, dependencies } = await processFileViaPackage(
-          content,
-          currentLib,
-          alias,
-          libDirToPackageMap
-        );
-        if (processed !== content) {
-          relinka("verbose", `[resolveCrossLibsViaPackage] File modified: ${filePath}`);
-          await fs.writeFile(filePath, processed, "utf-8");
-          modifiedFiles.push(path.resolve(filePath));
-        }
-        dependencies.forEach((dep) => addedDependencies.add(dep));
-      })
-    );
-    const packageJsonPath = path.join(path.dirname(libBinDir), "package.json");
-    for (const packageName of addedDependencies) {
-      await addDependencyToPackageJson(packageJsonPath, packageName);
-    }
-    return modifiedFiles;
-  }
-  return [];
-}
-async function processFileViaPackage(content, currentLib, alias, libDirToPackageMap) {
-  const lines = content.split("\n");
-  const result = [];
-  const dependencies = /* @__PURE__ */ new Set();
-  for (const line of lines) {
-    const pattern = new RegExp(
-      `^(\\s*)((?:export\\s+.*?\\s+from|import\\s+.*?\\s+from)\\s+(['"])${escapeRegex(alias)}/libs/([^/]+)/([^'"]*?)\\3[^;]*;?)(\\s*//.*)?\\s*$`
-    );
-    const match = line.match(pattern);
-    if (match) {
-      const [, indentation, fullStatement, quote, libName, rest, comment] = match;
-      relinka(
-        "verbose",
-        `[resolveCrossLibsViaPackage] Processing import/export: ${libName}/${rest}`
-      );
-      if (fullStatement?.includes(`${quote}./`)) {
-        result.push(line);
-        continue;
-      }
-      if (libName === currentLib) {
-        const newStatement = fullStatement?.replace(`${quote}${alias}/libs/${libName}/`, `${quote}./`) ?? "";
-        result.push(`${indentation}${newStatement}${comment || ""}`);
-      } else {
-        try {
-          if (!libName || !rest) {
-            throw new Error("Library name or path is undefined");
-          }
-          const packageName = libDirToPackageMap[libName];
-          if (!packageName) {
-            relinka(
-              "warn",
-              `[resolveCrossLibsViaPackage] No package name found for libDirName: ${libName}`
-            );
-            result.push(line);
-            continue;
-          }
-          relinka(
-            "log",
-            `[resolveCrossLibsViaPackage] Rewriting to package name: ${libName}/${rest} -> ${packageName}`
-          );
-          dependencies.add(packageName);
-          const newStatement = fullStatement?.replace(
-            `${quote}${alias}/libs/${libName}/`,
-            `${quote}${packageName}/`
-          ) ?? "";
-          result.push(`${indentation}${newStatement}${comment || ""}`);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          relinka(
-            "error",
-            `[resolveCrossLibsViaPackage] Failed to rewrite ${alias}/libs/${libName}/${rest}: ${errorMessage}`
-          );
-          throw error;
-        }
-      }
-    } else {
-      result.push(line);
-    }
-  }
-  return { processed: result.join("\n"), dependencies };
-}
-async function resolveAllCrossLibsViaPackage(alias = "~", subFolders = ["npm", "jsr"], buildPreExtensions, buildTemplatesDir) {
-  const distLibsDir = "dist-libs";
-  const allModifiedFiles = [];
-  const distLibsExists = await directoryExists(distLibsDir);
-  if (distLibsExists) {
-    const entries = await fs.readdir(distLibsDir, { withFileTypes: true });
-    const libDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    await Promise.all(
-      libDirs.map(async (libName) => {
-        for (const subFolder of subFolders) {
-          const binDir = path.join(distLibsDir, libName, subFolder, "bin");
-          const binDirExists = await directoryExists(binDir);
-          if (binDirExists) {
-            try {
-              const modifiedFiles = await resolveCrossLibsViaPackage(
-                binDir,
-                alias,
-                buildPreExtensions,
-                buildTemplatesDir
-              );
-              allModifiedFiles.push(...modifiedFiles);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              relinka(
-                "error",
-                `[resolveAllCrossLibsViaPackage] Error processing ${binDir}: ${errorMessage}`
-              );
-              throw error;
-            }
-          } else {
-          }
-        }
-      })
-    );
-  }
-  if (allModifiedFiles.length > 0) {
-    relinka(
-      "info",
-      "[resolveAllCrossLibsViaPackage] Cross libraries package replacements done in:"
-    );
-    relinka("verbose", "[resolveAllCrossLibsViaPackage] " + allModifiedFiles.join(", "));
-  }
-  return allModifiedFiles;
-}

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

@@ -1,17 +0,0 @@
-export interface EncryptedDataMemoryShape {
-    code: string;
-    key: string;
-    githubKey?: string;
-    vercelKey?: string;
-    openaiKey?: string;
-}
-export interface UserDataMemoryShape {
-    name?: string;
-    email?: string;
-    githubUsername?: string;
-    vercelTeamId?: string;
-    vercelTeamSlug?: string;
-}
-export type ReliverseMemory = EncryptedDataMemoryShape & UserDataMemoryShape;
-export type EncryptedDataMemory = keyof EncryptedDataMemoryShape;
-export type UserDataMemory = keyof UserDataMemoryShape;

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

@@ -1,27 +0,0 @@
-export interface RepoInfo {
-    id: string;
-    author: string;
-    name: string;
-    description: string;
-    category: string;
-    lastUpdated: string;
-    localPath: string;
-    github: {
-        stars: number;
-        forks: number;
-        watchers: number;
-        createdAt: string;
-        updatedAt: string;
-        pushedAt: string;
-        defaultBranch: string;
-    };
-}
-export interface ReposConfig {
-    $schema: string;
-    version: string;
-    repos: RepoInfo[];
-}
-export declare const DEFAULT_REPOS_CONFIG: ReposConfig;
-export declare function isReposConfig(value: unknown): value is ReposConfig;
-export declare function generateReposJsonSchema(): Promise<void>;
-export declare function shouldRegenerateSchema(): Promise<boolean>;