@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/magic/cmd.js

@@ -1,6 +1,6 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { applyMagicSpells } from "../../libs/sdk/sdk-impl/magic/magic-apply.js";
-import { formatError } from "../../libs/sdk/sdk-impl/utils/utils-error-cwd.js";
+import { applyMagicSpells } from "./magic-apply.js";
+import { formatError } from "../utils/utils-error-cwd.js";
 export default defineCommand({
   meta: {
     name: "magic",

package/bin/app/magic/magic-apply.js

@@ -0,0 +1,669 @@
+import path, { join } from "@reliverse/pathkit";
+import fs, { readdir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import pMap from "p-map";
+import { isBinaryExt } from "../utils/binary.js";
+import { formatError } from "../utils/utils-error-cwd.js";
+import {
+  evaluateMagicDirective
+} from "./magic-spells.js";
+const DEBUG_MODE = true;
+const PROCESS_DTS_FILES = true;
+const DEFAULT_OPTIONS = {
+  concurrency: 4,
+  batchSize: 100,
+  stopOnError: false,
+  copyFileWithDirectivesFromSrcBeforeProcessing: true
+};
+const DEFAULT_OUTPUT_PATHS = {
+  "dist-jsr": "dist-jsr/bin",
+  "dist-npm": "dist-npm/bin",
+  "dist-libs": "dist-libs"
+};
+function validateTargets(targets, customOutputPaths) {
+  const outputDirs = /* @__PURE__ */ new Set();
+  const specificLibs = /* @__PURE__ */ new Set();
+  const customTargets = /* @__PURE__ */ new Set();
+  const allOutputPaths = { ...DEFAULT_OUTPUT_PATHS, ...customOutputPaths };
+  for (const target of targets) {
+    const [outputDir, lib] = target.split("/");
+    if (!outputDir) {
+      throw new Error(`Invalid output target: ${target}`);
+    }
+    const isCustomTarget = !["dist-npm", "dist-jsr", "dist-libs"].includes(outputDir);
+    if (isCustomTarget) {
+      if (customTargets.has(outputDir)) {
+        throw new Error(`Duplicate custom target: ${outputDir}`);
+      }
+      customTargets.add(outputDir);
+      const outputPath = allOutputPaths[outputDir] || outputDir;
+      const fullPath = path.isAbsolute(outputPath) ? outputPath : path.join(process.cwd(), outputPath);
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`Output directory does not exist: ${outputPath}`);
+      }
+      continue;
+    }
+    if (outputDir === "dist-libs") {
+      if (lib) {
+        if (specificLibs.has(lib)) {
+          throw new Error(`Duplicate library target: ${target}`);
+        }
+        specificLibs.add(lib);
+      } else {
+        if (outputDirs.has("dist-libs") || specificLibs.size > 0) {
+          throw new Error("Cannot mix 'dist-libs' with specific library targets");
+        }
+        outputDirs.add("dist-libs");
+      }
+    } else {
+      if (outputDirs.has(outputDir)) {
+        throw new Error(`Duplicate output target: ${outputDir}`);
+      }
+      outputDirs.add(outputDir);
+    }
+  }
+}
+export async function applyMagicSpells(targets, options = {}) {
+  const result = {
+    processedFiles: [],
+    totalSpellsProcessed: 0
+  };
+  try {
+    validateTargets(targets, options.customOutputPaths);
+    await pMap(
+      targets,
+      async (target) => {
+        const [outputDir, lib] = target.split("/");
+        if (outputDir && !["dist-npm", "dist-jsr", "dist-libs"].includes(outputDir)) {
+          const targetResult = await processCustomTarget(outputDir, options);
+          result.processedFiles.push(...targetResult.processedFiles);
+          result.totalSpellsProcessed += targetResult.totalSpellsProcessed;
+          return;
+        }
+        const srcRoot = path.resolve(process.cwd(), "src");
+        const sourceFilesWithDirectives = await scanSourceForMagicDirectives(srcRoot, options);
+        if (sourceFilesWithDirectives.length === 0) {
+          return;
+        }
+        if (DEBUG_MODE) {
+          relinka(
+            "verbose",
+            `[spells] Found ${sourceFilesWithDirectives.length} source files with magic directives`
+          );
+        }
+        if (outputDir === "dist-libs") {
+          if (!lib) {
+            const distLibsPath = DEFAULT_OUTPUT_PATHS["dist-libs"] ?? "dist-libs";
+            try {
+              if (await fs.pathExists(distLibsPath)) {
+                const libDirs = await readdir(distLibsPath, { withFileTypes: true });
+                await pMap(
+                  libDirs,
+                  async (libDir) => {
+                    if (libDir.isDirectory()) {
+                      const targetResult = await processOutputTarget(
+                        sourceFilesWithDirectives,
+                        "dist-libs",
+                        libDir.name,
+                        options
+                      );
+                      result.processedFiles.push(...targetResult.processedFiles);
+                      result.totalSpellsProcessed += targetResult.totalSpellsProcessed;
+                    }
+                  },
+                  {
+                    concurrency: options.concurrency ?? 4,
+                    stopOnError: options.stopOnError ?? true
+                  }
+                );
+              } else if (DEBUG_MODE) {
+                relinka("verbose", `[spells] \u2298 skipping non-existent target: ${distLibsPath}`);
+              }
+            } catch (error) {
+              if (DEBUG_MODE) {
+                relinka("warn", `Failed to process dist-libs: ${formatError(error)}`);
+              }
+            }
+          } else {
+            const targetResult = await processOutputTarget(
+              sourceFilesWithDirectives,
+              "dist-libs",
+              lib,
+              options
+            );
+            result.processedFiles.push(...targetResult.processedFiles);
+            result.totalSpellsProcessed += targetResult.totalSpellsProcessed;
+          }
+        } else if (outputDir) {
+          const targetResult = await processOutputTarget(
+            sourceFilesWithDirectives,
+            outputDir,
+            void 0,
+            options
+          );
+          result.processedFiles.push(...targetResult.processedFiles);
+          result.totalSpellsProcessed += targetResult.totalSpellsProcessed;
+        }
+      },
+      {
+        concurrency: options.concurrency ?? 3,
+        stopOnError: options.stopOnError ?? true
+      }
+    );
+    if (DEBUG_MODE) {
+      relinka(
+        "verbose",
+        `[spells] \u2713 Processed ${result.totalSpellsProcessed} magic spells in ${result.processedFiles.length} files`
+      );
+    }
+    return result;
+  } catch (error) {
+    throw new Error(`Failed to process output files: ${formatError(error)}`);
+  }
+}
+async function processCustomTarget(outputDir, options = {}) {
+  const { concurrency = DEFAULT_OPTIONS.concurrency, batchSize = DEFAULT_OPTIONS.batchSize } = options;
+  const result = {
+    processedFiles: [],
+    totalSpellsProcessed: 0
+  };
+  if (DEBUG_MODE) {
+    relinka("verbose", `[spells] \u21D2 processing custom target: ${outputDir}`);
+  }
+  const outputFilesToProcess = [];
+  const outputPath = options.customOutputPaths?.[outputDir] || outputDir;
+  const fullOutputPath = path.isAbsolute(outputPath) ? outputPath : path.join(process.cwd(), outputPath);
+  for await (const filePath of walkDirectoryTree(fullOutputPath)) {
+    if (await isBinaryExt(filePath)) {
+      continue;
+    }
+    try {
+      const content = await fs.readFile(filePath, "utf8");
+      if (containsMagicDirectives(content)) {
+        outputFilesToProcess.push(filePath);
+        if (DEBUG_MODE) {
+          relinka(
+            "verbose",
+            `[spells] \u21D2 found directives in ${path.relative(process.cwd(), filePath)}`
+          );
+        }
+      }
+    } catch (error) {
+      if (options.stopOnError) {
+        throw new Error(`Failed to read file ${filePath}: ${formatError(error)}`);
+      }
+      relinka("error", `Failed to read file ${filePath}: ${formatError(error)}`);
+    }
+  }
+  if (outputFilesToProcess.length === 0) {
+    if (DEBUG_MODE) {
+      relinka(
+        "verbose",
+        `[spells] No files with magic directives found in custom target: ${outputDir}`
+      );
+    }
+    return result;
+  }
+  for (let i = 0; i < outputFilesToProcess.length; i += batchSize) {
+    const batch = outputFilesToProcess.slice(i, i + batchSize);
+    await pMap(
+      batch,
+      async (outputFilePath) => {
+        try {
+          const wasProcessed = await processSingleOutputFile(outputFilePath, options);
+          if (wasProcessed) {
+            result.processedFiles.push(outputFilePath);
+            const content = await fs.readFile(outputFilePath, "utf8");
+            const spellCount = (content.match(/\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/gi) || []).length;
+            result.totalSpellsProcessed += spellCount;
+          }
+        } catch (error) {
+          const errorMessage = `Error processing ${outputFilePath}: ${formatError(error)}`;
+          if (options.stopOnError) {
+            throw new Error(errorMessage);
+          }
+          relinka("error", errorMessage);
+        }
+      },
+      { concurrency }
+    );
+  }
+  return result;
+}
+async function scanSourceForMagicDirectives(srcRoot, options = {}) {
+  const sourceFilesWithDirectives = [];
+  try {
+    for await (const filePath of walkDirectoryTree(srcRoot)) {
+      if (await isBinaryExt(filePath)) {
+        continue;
+      }
+      const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+      if (await isSpellImplementationFile(projectRel)) {
+        continue;
+      }
+      try {
+        const content = await fs.readFile(filePath, "utf8");
+        if (containsMagicDirectives(content)) {
+          sourceFilesWithDirectives.push(filePath);
+          if (DEBUG_MODE) {
+            relinka(
+              "verbose",
+              `[spells] \u21D2 found directives in ${path.relative(process.cwd(), filePath)}`
+            );
+          }
+        }
+      } catch (error) {
+        if (options.stopOnError) {
+          throw new Error(`Failed to read source file ${filePath}: ${formatError(error)}`);
+        }
+        relinka("error", `Failed to read source file ${filePath}: ${formatError(error)}`);
+      }
+    }
+  } catch (error) {
+    if (options.stopOnError) {
+      throw new Error(`Failed to scan source directory: ${formatError(error)}`);
+    }
+    relinka("error", `Failed to scan source directory: ${formatError(error)}`);
+  }
+  return sourceFilesWithDirectives;
+}
+async function processOutputTarget(sourceFilesWithDirectives, outputDir, libName, options = {}) {
+  const { concurrency = DEFAULT_OPTIONS.concurrency, batchSize = DEFAULT_OPTIONS.batchSize } = options;
+  const result = {
+    processedFiles: [],
+    totalSpellsProcessed: 0
+  };
+  const outputPath = options.customOutputPaths?.[outputDir] || outputDir;
+  const fullOutputPath = path.isAbsolute(outputPath) ? outputPath : path.join(process.cwd(), outputPath);
+  if (!await fs.pathExists(fullOutputPath)) {
+    if (DEBUG_MODE) {
+      const targetName = outputDir === "dist-libs" && libName ? `${outputDir}/${libName}` : outputDir;
+      relinka("verbose", `[spells] \u2298 skipping non-existent target: ${targetName}`);
+    }
+    return result;
+  }
+  if (DEBUG_MODE) {
+    const targetName = outputDir === "dist-libs" && libName ? `${outputDir}/${libName}` : outputDir;
+    relinka("verbose", `[spells] \u21D2 processing target: ${targetName}`);
+  }
+  const outputFilesToProcess = [];
+  for (const sourceFile of sourceFilesWithDirectives) {
+    const outputFiles = await findOutputFiles(
+      sourceFile,
+      outputDir,
+      libName,
+      options.customOutputPaths
+    );
+    outputFilesToProcess.push(...outputFiles);
+  }
+  if (outputFilesToProcess.length === 0) {
+    if (DEBUG_MODE) {
+      const targetName = outputDir === "dist-libs" && libName ? `${outputDir}/${libName}` : outputDir;
+      relinka("verbose", `[spells] No corresponding output files found for target: ${targetName}`);
+    }
+    return result;
+  }
+  for (let i = 0; i < outputFilesToProcess.length; i += batchSize) {
+    const batch = outputFilesToProcess.slice(i, i + batchSize);
+    await pMap(
+      batch,
+      async (outputFilePath) => {
+        try {
+          const wasProcessed = await processSingleOutputFile(outputFilePath, options);
+          if (wasProcessed) {
+            result.processedFiles.push(outputFilePath);
+            const content = await fs.readFile(outputFilePath, "utf8");
+            const spellCount = (content.match(/\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/gi) || []).length;
+            result.totalSpellsProcessed += spellCount;
+          }
+        } catch (error) {
+          const errorMessage = `Error processing ${outputFilePath}: ${formatError(error)}`;
+          if (options.stopOnError) {
+            throw new Error(errorMessage);
+          }
+          relinka("error", errorMessage);
+        }
+      },
+      { concurrency }
+    );
+  }
+  return result;
+}
+async function findSourceFile(distFilePath) {
+  const projectRel = path.relative(process.cwd(), distFilePath).replaceAll(path.sep, "/");
+  const ext = path.extname(distFilePath);
+  const baseName = path.basename(distFilePath, ext);
+  const dirName = path.dirname(projectRel);
+  let sourcePath;
+  if (dirName.startsWith("dist-libs/")) {
+    const match = dirName.match(/^dist-libs\/([^/]+)(?:\/(?:npm|jsr))?(?:\/bin)?\/?(.*)$/);
+    if (match) {
+      const [, libName, remainingPath] = match;
+      sourcePath = `src/libs/${libName}${remainingPath ? `/${remainingPath}` : ""}`;
+    } else {
+      sourcePath = dirName.replace(/^dist-libs\//, "src/libs/");
+    }
+  } else {
+    sourcePath = dirName.replace(/^dist-(?:jsr|npm)(?:\/bin)?\/?/, "src/");
+  }
+  const sourceDir = path.join(process.cwd(), sourcePath);
+  if (ext === ".js") {
+    const tsFile = path.join(sourceDir, `${baseName}.ts`);
+    if (await fs.pathExists(tsFile)) {
+      const isDts = tsFile.endsWith(".d.ts");
+      if (!isDts) {
+        return tsFile;
+      }
+    }
+    const jsFile = path.join(sourceDir, `${baseName}.js`);
+    if (await fs.pathExists(jsFile)) {
+      return jsFile;
+    }
+  } else if (ext === ".ts") {
+    const isDts = path.basename(distFilePath).endsWith(".d.ts");
+    if (isDts && !PROCESS_DTS_FILES) {
+      return null;
+    }
+    const sourceFile = path.join(sourceDir, `${baseName}${ext}`);
+    if (await fs.pathExists(sourceFile)) {
+      return sourceFile;
+    }
+  } else {
+    const sourceFile = path.join(sourceDir, `${baseName}${ext}`);
+    if (await fs.pathExists(sourceFile)) {
+      return sourceFile;
+    }
+  }
+  return null;
+}
+export async function processSingleOutputFile(filePath, options = {}) {
+  const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+  if (await isBinaryExt(filePath)) {
+    if (DEBUG_MODE) relinka("verbose", `[spells] \u2298 binary  ${projectRel}`);
+    return false;
+  }
+  let copiedFromSource = false;
+  if (options.copyFileWithDirectivesFromSrcBeforeProcessing ?? DEFAULT_OPTIONS.copyFileWithDirectivesFromSrcBeforeProcessing) {
+    const sourceFile = await findSourceFile(filePath);
+    if (sourceFile && sourceFile !== filePath) {
+      try {
+        await fs.copyFile(sourceFile, filePath);
+        copiedFromSource = true;
+        if (DEBUG_MODE)
+          relinka("verbose", `[spells] \u21B3 copied from ${path.relative(process.cwd(), sourceFile)}`);
+      } catch (error) {
+        relinka("error", `Failed to copy from source: ${formatError(error)}`);
+      }
+    }
+  }
+  if (copiedFromSource || await fs.pathExists(filePath)) {
+    const source = await fs.readFile(filePath, "utf8");
+    const ctx = { filePath: projectRel };
+    let removeFile = false;
+    const allLines = source.split(/\r?\n/);
+    const processedLines = [];
+    for (let i = allLines.length - 1; i >= 0; i--) {
+      const line = allLines[i];
+      const outcome = evaluateMagicDirective(line, ctx);
+      if (outcome.removeFile) {
+        removeFile = true;
+        break;
+      }
+      if (!outcome.removeLine) {
+        processedLines.unshift(outcome.replacement ?? line);
+      }
+    }
+    if (removeFile) {
+      await fs.unlink(filePath);
+      if (DEBUG_MODE) relinka("verbose", `[spells] \u2716 removed ${projectRel}`);
+      return false;
+    }
+    const newContent = processedLines.join("\n");
+    if (newContent !== source) {
+      await fs.writeFile(filePath, newContent, "utf8");
+      if (DEBUG_MODE) relinka("verbose", `[spells] \u2713 updated ${projectRel}`);
+    }
+    return true;
+  }
+  return false;
+}
+async function findOutputFiles(sourceFilePath, outputDir, libName, customOutputPaths) {
+  const projectRel = path.relative(process.cwd(), sourceFilePath).replaceAll(path.sep, "/");
+  const srcRelativePath = projectRel.replace(/^src\//, "");
+  const ext = path.extname(sourceFilePath);
+  const baseName = path.basename(sourceFilePath, ext);
+  const dirPath = path.dirname(srcRelativePath);
+  const isDts = sourceFilePath.endsWith(".d.ts");
+  const outputFiles = [];
+  const allOutputPaths = { ...DEFAULT_OUTPUT_PATHS, ...customOutputPaths };
+  if (outputDir === "dist-libs" && libName) {
+    const targets = await getAvailableRegistries(libName);
+    for (const target of targets) {
+      const outputPath = join("dist-libs", libName, target, "bin", dirPath === "." ? "" : dirPath);
+      let extensions;
+      if (isDts && PROCESS_DTS_FILES) {
+        extensions = [".d.ts"];
+      } else if (ext === ".ts" && !isDts) {
+        extensions = [".js", ".ts"];
+      } else {
+        extensions = [ext];
+      }
+      for (const outputExt of extensions) {
+        const outputFile = path.isAbsolute(outputPath) ? path.join(outputPath, `${baseName}${outputExt}`) : path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
+        if (await fs.pathExists(outputFile)) {
+          outputFiles.push(outputFile);
+        }
+      }
+    }
+  } else {
+    const basePath = allOutputPaths[outputDir] || outputDir;
+    const outputPath = path.join(basePath, dirPath === "." ? "" : dirPath);
+    let extensions;
+    if (isDts && PROCESS_DTS_FILES) {
+      extensions = [".d.ts"];
+    } else if (ext === ".ts" && !isDts) {
+      extensions = [".js", ".ts"];
+    } else {
+      extensions = [ext];
+    }
+    for (const outputExt of extensions) {
+      const outputFile = path.isAbsolute(basePath) ? path.join(basePath, dirPath === "." ? "" : dirPath, `${baseName}${outputExt}`) : path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
+      if (await fs.pathExists(outputFile)) {
+        outputFiles.push(outputFile);
+      }
+    }
+  }
+  return outputFiles;
+}
+const SPELL_REGEX = /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i;
+let spellImplementationPaths = null;
+async function getSpellImplementationPaths() {
+  if (spellImplementationPaths !== null) {
+    return spellImplementationPaths;
+  }
+  const paths = [];
+  const distLibsPath = path.join(process.cwd(), "dist-libs");
+  try {
+    if (await fs.pathExists(distLibsPath)) {
+      const libDirs = await fs.readdir(distLibsPath, { withFileTypes: true });
+      for (const libDir of libDirs) {
+        if (libDir.isDirectory()) {
+          const libName = libDir.name;
+          paths.push(`/libs/${libName}/app/spell/`);
+          paths.push(`/${libName}/app/spell/`);
+          const libPath = path.join(distLibsPath, libName);
+          try {
+            const registryDirs = await fs.readdir(libPath, { withFileTypes: true });
+            for (const registryDir of registryDirs) {
+              if (registryDir.isDirectory() && (registryDir.name === "npm" || registryDir.name === "jsr")) {
+                const registryName = registryDir.name;
+                paths.push(`/libs/${libName}/${registryName}/app/spell/`);
+                paths.push(`/${libName}/${registryName}/app/spell/`);
+              }
+            }
+          } catch (error) {
+            if (DEBUG_MODE) {
+              relinka("warn", `Failed to read library directory ${libPath}: ${formatError(error)}`);
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (DEBUG_MODE) {
+      relinka("warn", `Failed to read dist-libs directory: ${formatError(error)}`);
+    }
+  }
+  if (paths.length === 0) {
+    paths.push("/app/spell/");
+  }
+  spellImplementationPaths = paths;
+  return paths;
+}
+async function isSpellImplementationFile(projectRelPath) {
+  const fileName = path.basename(projectRelPath);
+  if (fileName === "magic-apply.ts" || fileName === "magic-apply.js" || fileName === "magic-apply.d.ts" || fileName === "magic-spells.ts" || fileName === "magic-spells.js" || fileName === "magic-spells.d.ts") {
+    return true;
+  }
+  const spellPaths = await getSpellImplementationPaths();
+  return spellPaths.some((spellPath) => projectRelPath.includes(spellPath));
+}
+const libraryRegistriesCache = /* @__PURE__ */ new Map();
+async function getAvailableRegistries(libName) {
+  const cached = libraryRegistriesCache.get(libName);
+  if (cached) {
+    return cached;
+  }
+  const registries = [];
+  const libPath = path.join(process.cwd(), "dist-libs", libName);
+  try {
+    if (await fs.pathExists(libPath)) {
+      const entries = await fs.readdir(libPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && (entry.name === "npm" || entry.name === "jsr")) {
+          registries.push(entry.name);
+        }
+      }
+    }
+  } catch (error) {
+    if (DEBUG_MODE) {
+      relinka("warn", `Failed to read library registries for ${libName}: ${formatError(error)}`);
+    }
+  }
+  if (registries.length === 0) {
+    registries.push("npm", "jsr");
+  }
+  libraryRegistriesCache.set(libName, registries);
+  return registries;
+}
+let allAvailableRegistriesCache = null;
+export async function getAllAvailableRegistries() {
+  if (allAvailableRegistriesCache !== null) {
+    return allAvailableRegistriesCache;
+  }
+  const allRegistries = /* @__PURE__ */ new Set();
+  const distLibsPath = path.join(process.cwd(), "dist-libs");
+  try {
+    if (await fs.pathExists(distLibsPath)) {
+      const libDirs = await fs.readdir(distLibsPath, { withFileTypes: true });
+      for (const libDir of libDirs) {
+        if (libDir.isDirectory()) {
+          const registries = await getAvailableRegistries(libDir.name);
+          for (const registry of registries) {
+            allRegistries.add(registry);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (DEBUG_MODE) {
+      relinka("warn", `Failed to scan all registries: ${formatError(error)}`);
+    }
+  }
+  if (allRegistries.size === 0) {
+    allRegistries.add("npm");
+    allRegistries.add("jsr");
+  }
+  allAvailableRegistriesCache = Array.from(allRegistries);
+  return allAvailableRegistriesCache;
+}
+function containsMagicDirectives(content) {
+  const lines = content.split(/\r?\n/);
+  return lines.some((line) => SPELL_REGEX.test(line));
+}
+async function* walkDirectoryTree(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        yield* walkDirectoryTree(full);
+      } else if (entry.isFile()) {
+        yield full;
+      }
+    }
+  } catch (error) {
+    const errorMessage = `Error walking directory ${dir}: ${formatError(error)}`;
+    relinka("error", errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+export async function getFilesWithMagicSpells(dirs, options = {}) {
+  const { stopOnError = false, excludeSpellImplementation = true } = options;
+  const filesWithSpells = [];
+  try {
+    await pMap(
+      dirs,
+      async (dir) => {
+        const fullPath = path.isAbsolute(dir) ? dir : path.join(process.cwd(), dir);
+        if (!await fs.pathExists(fullPath)) {
+          const error = `Directory does not exist: ${dir}`;
+          if (stopOnError) {
+            throw new Error(error);
+          }
+          relinka("warn", error);
+          return;
+        }
+        for await (const filePath of walkDirectoryTree(fullPath)) {
+          if (await isBinaryExt(filePath)) {
+            continue;
+          }
+          const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+          if (excludeSpellImplementation && await isSpellImplementationFile(projectRel)) {
+            continue;
+          }
+          try {
+            const content = await fs.readFile(filePath, "utf8");
+            const lines = content.split(/\r?\n/);
+            const spellLines = [];
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i];
+              if (line && /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i.test(line)) {
+                spellLines.push(i + 1);
+              }
+            }
+            if (spellLines.length > 0) {
+              filesWithSpells.push({
+                path: filePath,
+                spellLines
+              });
+            }
+          } catch (error) {
+            const errorMessage = `Failed to read file ${filePath}: ${formatError(error)}`;
+            if (stopOnError) {
+              throw new Error(errorMessage);
+            }
+            relinka("error", errorMessage);
+          }
+        }
+      },
+      {
+        concurrency: 4,
+        stopOnError
+      }
+    );
+    return filesWithSpells;
+  } catch (error) {
+    throw new Error(`Failed to scan directories: ${formatError(error)}`);
+  }
+}

package/bin/app/memory/cmd.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;