@reliverse/dler 1.7.92 → 1.7.94

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

@@ -0,0 +1,641 @@
+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 loadDlerConfig() {
+  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 loadDlerConfig();
+    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/app/utils/schemaMemory.d.ts

@@ -0,0 +1,31 @@
+import { type Static } from "@sinclair/typebox";
+declare const encryptedDataSchema: import("@sinclair/typebox").TObject<{
+    code: import("@sinclair/typebox").TString;
+    key: import("@sinclair/typebox").TString;
+    githubKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    vercelKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    openaiKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+declare const userDataSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    email: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    githubUsername: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    vercelTeamId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    vercelTeamSlug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const memorySchema: import("@sinclair/typebox").TObject<{
+    code: import("@sinclair/typebox").TString;
+    key: import("@sinclair/typebox").TString;
+    githubKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    vercelKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    openaiKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    githubUsername: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    email: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    vercelTeamId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    vercelTeamSlug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type ReliverseMemory = Static<typeof memorySchema>;
+export type EncryptedDataMemory = keyof Static<typeof encryptedDataSchema>;
+export type UserDataMemory = keyof Static<typeof userDataSchema>;
+export {};

package/bin/app/utils/schemaMemory.js

@@ -0,0 +1,16 @@
+import { Type } from "@sinclair/typebox";
+const encryptedDataSchema = Type.Object({
+  code: Type.String(),
+  key: Type.String(),
+  githubKey: Type.Optional(Type.String()),
+  vercelKey: Type.Optional(Type.String()),
+  openaiKey: Type.Optional(Type.String())
+});
+const userDataSchema = Type.Object({
+  name: Type.Optional(Type.String()),
+  email: Type.Optional(Type.String()),
+  githubUsername: Type.Optional(Type.String()),
+  vercelTeamId: Type.Optional(Type.String()),
+  vercelTeamSlug: Type.Optional(Type.String())
+});
+export const memorySchema = Type.Composite([encryptedDataSchema, userDataSchema]);