@reliverse/dler 1.7.153 → 2.0.0

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

@@ -1,669 +0,0 @@
-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)}`);
-  }
-}