@reverse-craft/smart-fs 1.0.6 → 2.0.0

package/dist/index.js

@@ -0,0 +1,1267 @@
+// src/index.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+
+// src/languageDetector.ts
+import * as path from "path";
+var LANGUAGE_CONFIG = {
+  javascript: {
+    language: "javascript",
+    supportsAST: true,
+    supportsBeautify: true,
+    supportsSourceMap: true
+  },
+  typescript: {
+    language: "typescript",
+    supportsAST: true,
+    supportsBeautify: true,
+    supportsSourceMap: true
+  },
+  json: {
+    language: "json",
+    supportsAST: false,
+    supportsBeautify: true,
+    supportsSourceMap: false
+  },
+  html: {
+    language: "html",
+    supportsAST: false,
+    supportsBeautify: true,
+    supportsSourceMap: false
+  },
+  xml: {
+    language: "xml",
+    supportsAST: false,
+    supportsBeautify: true,
+    supportsSourceMap: false
+  },
+  css: {
+    language: "css",
+    supportsAST: false,
+    supportsBeautify: true,
+    supportsSourceMap: false
+  },
+  unknown: {
+    language: "unknown",
+    supportsAST: false,
+    supportsBeautify: false,
+    supportsSourceMap: false
+  }
+};
+var EXTENSION_MAP = {
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascript",
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".json": "json",
+  ".html": "html",
+  ".htm": "html",
+  ".xml": "xml",
+  ".svg": "xml",
+  ".css": "css"
+};
+function detectLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const language = EXTENSION_MAP[ext] ?? "unknown";
+  return LANGUAGE_CONFIG[language];
+}
+function getLanguageInfo(language) {
+  return LANGUAGE_CONFIG[language];
+}
+function isFullySupportedLanguage(language) {
+  const info = LANGUAGE_CONFIG[language];
+  return info.supportsAST && info.supportsBeautify && info.supportsSourceMap;
+}
+function getSupportedExtensions() {
+  return Object.keys(EXTENSION_MAP);
+}
+function isExtensionSupported(ext) {
+  const normalizedExt = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+  return normalizedExt in EXTENSION_MAP;
+}
+
+// src/beautifier.ts
+import * as esbuild from "esbuild";
+import * as crypto from "crypto";
+import * as fs from "fs/promises";
+import * as path2 from "path";
+import * as os from "os";
+var TEMP_DIR = path2.join(os.tmpdir(), "smart-fs-mcp-cache");
+async function ensureCacheDir() {
+  await fs.mkdir(TEMP_DIR, { recursive: true });
+}
+function calculateCacheKey(originalPath, mtimeMs) {
+  const fileKey = `${originalPath}-${mtimeMs}`;
+  return crypto.createHash("md5").update(fileKey).digest("hex");
+}
+function getCachePaths(originalPath, hash) {
+  const fileName = path2.basename(originalPath, ".js");
+  const beautifiedPath = path2.join(TEMP_DIR, `${fileName}.${hash}.beautified.js`);
+  const mapPath = `${beautifiedPath}.map`;
+  return { beautifiedPath, mapPath };
+}
+function getLocalPaths(originalPath) {
+  const absolutePath = path2.resolve(originalPath);
+  const dir = path2.dirname(absolutePath);
+  const ext = path2.extname(absolutePath);
+  const baseName = path2.basename(absolutePath, ext);
+  const beautifiedPath = path2.join(dir, `${baseName}.beautified.js`);
+  const mapPath = `${beautifiedPath}.map`;
+  return { beautifiedPath, mapPath };
+}
+async function isCacheValid(beautifiedPath, mapPath) {
+  try {
+    await Promise.all([
+      fs.access(beautifiedPath),
+      fs.access(mapPath)
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isLocalCacheValid(originalPath) {
+  const absolutePath = path2.resolve(originalPath);
+  const { beautifiedPath } = getLocalPaths(absolutePath);
+  let originalStats;
+  try {
+    originalStats = await fs.stat(absolutePath);
+  } catch {
+    return {
+      originalMtime: 0,
+      beautifiedExists: false,
+      beautifiedMtime: 0,
+      isValid: false
+    };
+  }
+  const originalMtime = originalStats.mtimeMs;
+  let beautifiedStats;
+  try {
+    beautifiedStats = await fs.stat(beautifiedPath);
+  } catch {
+    return {
+      originalMtime,
+      beautifiedExists: false,
+      beautifiedMtime: 0,
+      isValid: false
+    };
+  }
+  const beautifiedMtime = beautifiedStats.mtimeMs;
+  const isValid = beautifiedMtime >= originalMtime;
+  return {
+    originalMtime,
+    beautifiedExists: true,
+    beautifiedMtime,
+    isValid
+  };
+}
+function beautifyJson(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return { code: JSON.stringify(parsed, null, 2), parseFailed: false };
+  } catch {
+    return { code: content, parseFailed: true };
+  }
+}
+function beautifyHtml(content) {
+  try {
+    let formatted = "";
+    let indent = 0;
+    const indentStr = "  ";
+    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const tokens = normalized.split(/(<[^>]+>)/g).filter((token) => token.trim() !== "");
+    for (const token of tokens) {
+      const trimmedToken = token.trim();
+      if (!trimmedToken) continue;
+      if (trimmedToken.startsWith("<")) {
+        if (trimmedToken.startsWith("<!") || trimmedToken.startsWith("<?") || trimmedToken.endsWith("/>")) {
+          formatted += indentStr.repeat(indent) + trimmedToken + "\n";
+        } else if (trimmedToken.startsWith("</")) {
+          indent = Math.max(0, indent - 1);
+          formatted += indentStr.repeat(indent) + trimmedToken + "\n";
+        } else {
+          formatted += indentStr.repeat(indent) + trimmedToken + "\n";
+          indent++;
+        }
+      } else {
+        const textLines = trimmedToken.split("\n");
+        for (const line of textLines) {
+          const trimmedLine = line.trim();
+          if (trimmedLine) {
+            formatted += indentStr.repeat(indent) + trimmedLine + "\n";
+          }
+        }
+      }
+    }
+    return formatted.trimEnd();
+  } catch {
+    return content;
+  }
+}
+function beautifyCss(content) {
+  try {
+    let formatted = content;
+    formatted = formatted.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    formatted = formatted.replace(/\{/g, " {\n");
+    formatted = formatted.replace(/\}/g, "\n}\n");
+    formatted = formatted.replace(/;/g, ";\n");
+    formatted = formatted.replace(/\n\s*\n/g, "\n");
+    const lines = formatted.split("\n");
+    let indent = 0;
+    const indentStr = "  ";
+    const result = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("}")) {
+        indent = Math.max(0, indent - 1);
+      }
+      result.push(indentStr.repeat(indent) + trimmed);
+      if (trimmed.endsWith("{")) {
+        indent++;
+      }
+    }
+    return result.join("\n");
+  } catch {
+    return content;
+  }
+}
+function beautifyCode(code, language) {
+  const langInfo = getLanguageInfo(language);
+  if (!langInfo.supportsBeautify) {
+    return { code, usedFallback: true };
+  }
+  switch (language) {
+    case "json": {
+      const result = beautifyJson(code);
+      return { code: result.code, usedFallback: result.parseFailed };
+    }
+    case "html":
+    case "xml":
+      return { code: beautifyHtml(code), usedFallback: false };
+    case "css":
+      return { code: beautifyCss(code), usedFallback: false };
+    case "javascript":
+    case "typescript":
+      return { code, usedFallback: true };
+    default:
+      return { code, usedFallback: true };
+  }
+}
+async function ensureBeautified(originalPath, options) {
+  const absolutePath = path2.resolve(originalPath);
+  let stats;
+  try {
+    stats = await fs.stat(absolutePath);
+  } catch {
+    throw new Error(`File not found: ${originalPath}`);
+  }
+  const langInfo = options?.language ? getLanguageInfo(options.language) : detectLanguage(absolutePath);
+  const language = langInfo.language;
+  const localPaths = getLocalPaths(absolutePath);
+  if (language !== "javascript" && language !== "typescript") {
+    const content = await fs.readFile(absolutePath, "utf-8");
+    const beautified = beautifyCode(content, language);
+    return {
+      code: beautified.code,
+      rawMap: null,
+      // No source map for non-JS/TS
+      localPath: localPaths.beautifiedPath,
+      localMapPath: localPaths.mapPath,
+      usedFallback: beautified.usedFallback
+    };
+  }
+  const localCacheCheck = await isLocalCacheValid(absolutePath);
+  if (localCacheCheck.isValid) {
+    try {
+      const [code2, mapContent] = await Promise.all([
+        fs.readFile(localPaths.beautifiedPath, "utf-8"),
+        fs.readFile(localPaths.mapPath, "utf-8")
+      ]);
+      return {
+        code: code2,
+        rawMap: JSON.parse(mapContent),
+        localPath: localPaths.beautifiedPath,
+        localMapPath: localPaths.mapPath,
+        usedFallback: false
+      };
+    } catch {
+    }
+  }
+  await ensureCacheDir();
+  const hash = calculateCacheKey(absolutePath, stats.mtimeMs);
+  const { beautifiedPath, mapPath } = getCachePaths(absolutePath, hash);
+  if (await isCacheValid(beautifiedPath, mapPath)) {
+    const [code2, mapContent] = await Promise.all([
+      fs.readFile(beautifiedPath, "utf-8"),
+      fs.readFile(mapPath, "utf-8")
+    ]);
+    const result2 = {
+      code: code2,
+      rawMap: JSON.parse(mapContent),
+      localPath: localPaths.beautifiedPath,
+      localMapPath: localPaths.mapPath,
+      usedFallback: false
+    };
+    await saveToLocal(result2, localPaths, mapContent);
+    return result2;
+  }
+  let esbuildResult;
+  try {
+    esbuildResult = await esbuild.build({
+      entryPoints: [absolutePath],
+      bundle: false,
+      write: false,
+      format: "esm",
+      sourcemap: "external",
+      sourcesContent: false,
+      outfile: "out.js",
+      // Beautify settings
+      minify: false,
+      keepNames: true,
+      treeShaking: false
+    });
+  } catch (err) {
+    const content = await fs.readFile(absolutePath, "utf-8");
+    return {
+      code: content,
+      rawMap: null,
+      localPath: localPaths.beautifiedPath,
+      localMapPath: localPaths.mapPath,
+      usedFallback: true
+    };
+  }
+  const codeFile = esbuildResult.outputFiles?.find((f) => f.path.endsWith(".js"));
+  const mapFile = esbuildResult.outputFiles?.find((f) => f.path.endsWith(".map"));
+  if (!codeFile || !mapFile) {
+    const content = await fs.readFile(absolutePath, "utf-8");
+    return {
+      code: content,
+      rawMap: null,
+      localPath: localPaths.beautifiedPath,
+      localMapPath: localPaths.mapPath,
+      usedFallback: true
+    };
+  }
+  const code = codeFile.text;
+  const rawMap = JSON.parse(mapFile.text);
+  const mapText = mapFile.text;
+  await Promise.all([
+    fs.writeFile(beautifiedPath, code, "utf-8"),
+    fs.writeFile(mapPath, mapText, "utf-8")
+  ]);
+  const result = {
+    code,
+    rawMap,
+    localPath: localPaths.beautifiedPath,
+    localMapPath: localPaths.mapPath,
+    usedFallback: false
+  };
+  await saveToLocal(result, localPaths, mapText);
+  return result;
+}
+async function saveToLocal(result, localPaths, mapText) {
+  try {
+    await Promise.all([
+      fs.writeFile(localPaths.beautifiedPath, result.code, "utf-8"),
+      fs.writeFile(localPaths.mapPath, mapText, "utf-8")
+    ]);
+    result.localPath = localPaths.beautifiedPath;
+    result.localMapPath = localPaths.mapPath;
+  } catch (err) {
+    const error = err;
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      result.localSaveError = `Permission denied: Cannot write to ${path2.dirname(localPaths.beautifiedPath)}`;
+    } else if (error.code === "ENOSPC") {
+      result.localSaveError = `Insufficient disk space: Cannot write to ${path2.dirname(localPaths.beautifiedPath)}`;
+    } else {
+      result.localSaveError = `Failed to save locally: ${error.message || String(err)}`;
+    }
+  }
+}
+
+// src/truncator.ts
+import { parse } from "meriyah";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+function countNewlines(str) {
+  let count = 0;
+  for (const char of str) {
+    if (char === "\n") count++;
+  }
+  return count;
+}
+function createTruncatedString(original, previewLength) {
+  const newlineCount = countNewlines(original);
+  const start = original.slice(0, previewLength);
+  const end = original.slice(-previewLength);
+  const marker = `...[TRUNCATED ${original.length} CHARS]...`;
+  const startNewlines = countNewlines(start);
+  const endNewlines = countNewlines(end);
+  const preservedNewlines = Math.max(0, newlineCount - startNewlines - endNewlines);
+  const newlineStr = "\n".repeat(preservedNewlines);
+  return `${start}${marker}${newlineStr}${end}`;
+}
+function truncateCodeAST(sourceCode, limit = 200, previewLength = 50) {
+  let ast;
+  try {
+    ast = parse(sourceCode, {
+      module: true,
+      next: true,
+      ranges: true,
+      loc: true,
+      raw: true
+    });
+  } catch {
+    return { code: sourceCode, parseFailed: true };
+  }
+  const magicString = new MagicString(sourceCode);
+  walk(ast, {
+    enter(node) {
+      if (node.type === "Literal" && typeof node.value === "string") {
+        const literal = node;
+        const value = literal.value;
+        if (value.length > limit && literal.start !== void 0 && literal.end !== void 0) {
+          const truncated = createTruncatedString(value, previewLength);
+          const originalText = sourceCode.slice(literal.start, literal.end);
+          const quote = originalText[0];
+          magicString.overwrite(literal.start, literal.end, `${quote}${truncated}${quote}`);
+        }
+      }
+      if (node.type === "TemplateLiteral") {
+        const template = node;
+        for (const quasi of template.quasis) {
+          const value = quasi.value.raw;
+          if (value.length > limit && quasi.start !== void 0 && quasi.end !== void 0) {
+            const truncated = createTruncatedString(value, previewLength);
+            magicString.overwrite(quasi.start, quasi.end, truncated);
+          }
+        }
+      }
+    }
+  });
+  return { code: magicString.toString(), parseFailed: false };
+}
+function truncateCodeHighPerf(sourceCode, limit = 200, previewLength = 50) {
+  return truncateCodeAST(sourceCode, limit, previewLength).code;
+}
+function truncateFallback(code, maxLineChars = 500, previewLength = 50) {
+  if (!code) {
+    return code;
+  }
+  const lines = code.split("\n");
+  const processedLines = lines.map((line) => {
+    if (line.length <= maxLineChars) {
+      return line;
+    }
+    const start = line.slice(0, previewLength);
+    const end = line.slice(-previewLength);
+    const truncatedChars = line.length - previewLength * 2;
+    const marker = `...[LINE TRUNCATED ${truncatedChars} CHARS]...`;
+    return `${start}${marker}${end}`;
+  });
+  return processedLines.join("\n");
+}
+function truncateCode(code, options) {
+  const {
+    language,
+    charLimit = 200,
+    maxLineChars = 500,
+    previewLength = 50
+  } = options ?? {};
+  const langInfo = language ? getLanguageInfo(language) : null;
+  const supportsAST = langInfo?.supportsAST ?? false;
+  if (supportsAST && (language === "javascript" || language === "typescript")) {
+    const astResult = truncateCodeAST(code, charLimit, previewLength);
+    if (astResult.parseFailed) {
+      const truncatedCode3 = truncateFallback(code, maxLineChars, previewLength);
+      return {
+        code: truncatedCode3,
+        usedFallback: true
+      };
+    }
+    const truncatedCode2 = truncateLongLines(astResult.code, maxLineChars, previewLength / maxLineChars);
+    return {
+      code: truncatedCode2,
+      usedFallback: false
+    };
+  }
+  const truncatedCode = truncateFallback(code, maxLineChars, previewLength);
+  return {
+    code: truncatedCode,
+    usedFallback: true
+  };
+}
+function truncateCodeFromFile(filePath, code, options) {
+  const language = options?.language ?? detectLanguage(filePath).language;
+  return truncateCode(code, {
+    ...options,
+    language
+  });
+}
+function truncateLongLines(code, maxLineChars = 500, previewRatio = 0.2) {
+  if (!code) {
+    return code;
+  }
+  const lines = code.split("\n");
+  const previewLength = Math.floor(maxLineChars * previewRatio);
+  const processedLines = lines.map((line) => {
+    if (line.length <= maxLineChars) {
+      return line;
+    }
+    const start = line.slice(0, previewLength);
+    const end = line.slice(-previewLength);
+    const truncatedChars = line.length - previewLength * 2;
+    const marker = `...[LINE TRUNCATED ${truncatedChars} CHARS]...`;
+    return `${start}${marker}${end}`;
+  });
+  return processedLines.join("\n");
+}
+
+// src/searcher.ts
+import { SourceMapConsumer } from "source-map-js";
+function unescapeBackslashes(str) {
+  return str.replace(/\\\\/g, "\\");
+}
+function escapeRegex(str) {
+  return str.replace(/[()[\]{}.*+?^$|\\]/g, "\\$&");
+}
+function createRegex(query, caseSensitive = false, isRegex = false) {
+  try {
+    const flags = caseSensitive ? "g" : "gi";
+    const pattern = isRegex ? query : escapeRegex(query);
+    return new RegExp(pattern, flags);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid regex: ${message}`);
+  }
+}
+function getOriginalPosition(consumer, lineNumber) {
+  const pos = consumer.originalPositionFor({
+    line: lineNumber,
+    column: 0
+  });
+  return {
+    line: pos.line,
+    column: pos.column
+  };
+}
+function buildLineOffsets(code) {
+  let capacity = Math.max(16, Math.ceil(code.length / 40));
+  let offsets = new Int32Array(capacity);
+  let lineCount = 0;
+  offsets[0] = 0;
+  for (let i = 0; i < code.length; i++) {
+    if (code[i] === "\n") {
+      lineCount++;
+      if (lineCount >= capacity) {
+        capacity *= 2;
+        const newArr = new Int32Array(capacity);
+        newArr.set(offsets);
+        offsets = newArr;
+      }
+      offsets[lineCount] = i + 1;
+    }
+  }
+  return {
+    offsets: offsets.subarray(0, lineCount + 1),
+    totalLines: lineCount + 1
+  };
+}
+function getLineNumberFromIndex(offsets, totalLines, index) {
+  let low = 0;
+  let high = totalLines - 1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    if (offsets[mid] <= index) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return low;
+}
+function getLineContent(code, offsets, totalLines, lineNo) {
+  if (lineNo < 1 || lineNo > totalLines) return "";
+  const start = offsets[lineNo - 1];
+  let end;
+  if (lineNo < totalLines) {
+    end = offsets[lineNo] - 1;
+  } else {
+    end = code.length;
+  }
+  if (end > start && code[end - 1] === "\r") {
+    end--;
+  }
+  return code.slice(start, end);
+}
+function searchInCode(code, rawMap, options) {
+  const {
+    query,
+    contextLines = 2,
+    caseSensitive = false,
+    maxMatches = 10,
+    isRegex = false,
+    timeoutMs = 500
+  } = options;
+  const { offsets, totalLines } = buildLineOffsets(code);
+  const flags = (caseSensitive ? "g" : "gi") + "m";
+  const patternStr = isRegex ? unescapeBackslashes(query) : escapeRegex(query);
+  let regex;
+  try {
+    regex = new RegExp(patternStr, flags);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid regex: ${message}`);
+  }
+  const consumer = new SourceMapConsumer({
+    ...rawMap,
+    version: String(rawMap.version)
+  });
+  const matches = [];
+  let lastMatchedLine = -1;
+  let totalMatchesFound = 0;
+  let match;
+  const startTime = Date.now();
+  while ((match = regex.exec(code)) !== null) {
+    if (match.index === regex.lastIndex) {
+      regex.lastIndex++;
+    }
+    const lineNumber = getLineNumberFromIndex(offsets, totalLines, match.index);
+    if (lineNumber === lastMatchedLine) {
+      continue;
+    }
+    lastMatchedLine = lineNumber;
+    totalMatchesFound++;
+    if (matches.length < maxMatches) {
+      const contextBefore = [];
+      for (let i = Math.max(1, lineNumber - contextLines); i < lineNumber; i++) {
+        contextBefore.push({
+          lineNumber: i,
+          content: getLineContent(code, offsets, totalLines, i),
+          originalPosition: getOriginalPosition(consumer, i)
+        });
+      }
+      const contextAfter = [];
+      for (let i = lineNumber + 1; i <= Math.min(totalLines, lineNumber + contextLines); i++) {
+        contextAfter.push({
+          lineNumber: i,
+          content: getLineContent(code, offsets, totalLines, i),
+          originalPosition: getOriginalPosition(consumer, i)
+        });
+      }
+      matches.push({
+        lineNumber,
+        lineContent: getLineContent(code, offsets, totalLines, lineNumber),
+        originalPosition: getOriginalPosition(consumer, lineNumber),
+        contextBefore,
+        contextAfter
+      });
+    }
+    if (Date.now() - startTime > timeoutMs) {
+      break;
+    }
+  }
+  return {
+    matches,
+    totalMatches: totalMatchesFound,
+    truncated: totalMatchesFound > maxMatches
+  };
+}
+function formatSourcePosition(line, column) {
+  if (line !== null && column !== null) {
+    return `L${line}:${column}`;
+  }
+  return "";
+}
+function formatCodeLine(lineNumber, sourcePos, code, maxLineNumWidth, prefix = "  ") {
+  const lineNumStr = String(lineNumber).padStart(maxLineNumWidth, " ");
+  const srcPosPadded = sourcePos ? sourcePos.padEnd(10, " ") : "          ";
+  return `${prefix}${lineNumStr} ${srcPosPadded} ${code}`;
+}
+function formatSearchResult(filePath, query, caseSensitive, result, maxMatches = 50, isRegex = false) {
+  const { matches, totalMatches, truncated } = result;
+  const outputParts = [];
+  const caseInfo = caseSensitive ? "case-sensitive" : "case-insensitive";
+  const modeInfo = isRegex ? "regex" : "literal";
+  outputParts.push(`${filePath}`);
+  outputParts.push(`Query="${query}" (${modeInfo}, ${caseInfo})`);
+  outputParts.push(`Src=original position for breakpoints`);
+  if (totalMatches === 0) {
+    outputParts.push("Matches: None");
+    return outputParts.join("\n");
+  }
+  const matchInfo = truncated ? `Matches: ${totalMatches} (showing first ${maxMatches})` : `Matches: ${totalMatches}`;
+  outputParts.push(matchInfo);
+  for (const match of matches) {
+    outputParts.push(`--- Line ${match.lineNumber} ---`);
+    const allLineNumbers = [
+      ...match.contextBefore.map((c) => c.lineNumber),
+      match.lineNumber,
+      ...match.contextAfter.map((c) => c.lineNumber)
+    ];
+    const maxLineNumWidth = Math.max(...allLineNumbers.map((n) => String(n).length));
+    for (const ctx of match.contextBefore) {
+      const srcPos = formatSourcePosition(ctx.originalPosition.line, ctx.originalPosition.column);
+      outputParts.push(formatCodeLine(ctx.lineNumber, srcPos, ctx.content, maxLineNumWidth, "  "));
+    }
+    const matchSrcPos = formatSourcePosition(match.originalPosition.line, match.originalPosition.column);
+    outputParts.push(formatCodeLine(match.lineNumber, matchSrcPos, match.lineContent, maxLineNumWidth, ">>"));
+    for (const ctx of match.contextAfter) {
+      const srcPos = formatSourcePosition(ctx.originalPosition.line, ctx.originalPosition.column);
+      outputParts.push(formatCodeLine(ctx.lineNumber, srcPos, ctx.content, maxLineNumWidth, "  "));
+    }
+  }
+  if (truncated) {
+    outputParts.push(`
+... (${totalMatches - maxMatches} more matches not shown)`);
+  }
+  return outputParts.join("\n");
+}
+
+// src/analyzer.ts
+import { SourceMapConsumer as SourceMapConsumer2 } from "source-map-js";
+import { parse as parse2 } from "@babel/parser";
+var traverse = null;
+async function getTraverse() {
+  if (!traverse) {
+    const mod = await import("@babel/traverse");
+    traverse = mod.default?.default ?? mod.default;
+  }
+  return traverse;
+}
+var DEFAULT_PARSER_OPTIONS = {
+  sourceType: "unambiguous",
+  plugins: [
+    "jsx",
+    "typescript",
+    "classProperties",
+    "classPrivateProperties",
+    "classPrivateMethods",
+    "dynamicImport",
+    "optionalChaining",
+    "nullishCoalescingOperator",
+    "objectRestSpread"
+  ],
+  errorRecovery: true
+};
+function parseCode(code) {
+  try {
+    return parse2(code, DEFAULT_PARSER_OPTIONS);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Parse error: ${message}`);
+  }
+}
+function getOriginalPosition2(consumer, line, column) {
+  const pos = consumer.originalPositionFor({ line, column });
+  return {
+    line: pos.line,
+    column: pos.column
+  };
+}
+function getLineContent2(lines, lineNumber) {
+  if (lineNumber < 1 || lineNumber > lines.length) {
+    return "";
+  }
+  return lines[lineNumber - 1];
+}
+function createLocationInfo(line, column, lines, consumer) {
+  return {
+    line,
+    column,
+    originalPosition: getOriginalPosition2(consumer, line, column),
+    lineContent: getLineContent2(lines, line)
+  };
+}
+async function analyzeBindings(code, rawMap, identifier, options) {
+  const targetLine = options?.targetLine;
+  const isTargeted = targetLine !== void 0;
+  const maxReferences = options?.maxReferences ?? (isTargeted ? 15 : 10);
+  const ast = parseCode(code);
+  const lines = code.split("\n");
+  const consumer = new SourceMapConsumer2({
+    ...rawMap,
+    version: String(rawMap.version)
+  });
+  const bindings = [];
+  const processedScopes = /* @__PURE__ */ new Set();
+  const traverse2 = await getTraverse();
+  try {
+    traverse2(ast, {
+      Identifier(path5) {
+        if (path5.node.name !== identifier) {
+          return;
+        }
+        if (isTargeted) {
+          const nodeLoc = path5.node.loc;
+          if (!nodeLoc || nodeLoc.start.line !== targetLine) {
+            return;
+          }
+        }
+        const binding = path5.scope.getBinding(identifier);
+        if (!binding) {
+          return;
+        }
+        const scopeUid = binding.scope.uid;
+        if (processedScopes.has(scopeUid)) {
+          return;
+        }
+        processedScopes.add(scopeUid);
+        const defNode = binding.identifier;
+        const defLoc = defNode.loc;
+        if (!defLoc) {
+          return;
+        }
+        const definition = createLocationInfo(
+          defLoc.start.line,
+          defLoc.start.column,
+          lines,
+          consumer
+        );
+        const allReferences = [];
+        for (const refPath of binding.referencePaths) {
+          const refLoc = refPath.node.loc;
+          if (!refLoc) {
+            continue;
+          }
+          allReferences.push(
+            createLocationInfo(
+              refLoc.start.line,
+              refLoc.start.column,
+              lines,
+              consumer
+            )
+          );
+        }
+        const totalReferences = allReferences.length;
+        const limitedReferences = allReferences.slice(0, maxReferences);
+        let hitLocation;
+        if (isTargeted) {
+          const nodeLoc = path5.node.loc;
+          hitLocation = createLocationInfo(
+            nodeLoc.start.line,
+            nodeLoc.start.column,
+            lines,
+            consumer
+          );
+        }
+        bindings.push({
+          scopeUid,
+          kind: binding.kind,
+          definition,
+          references: limitedReferences,
+          totalReferences,
+          hitLocation
+        });
+        if (isTargeted) {
+          path5.stop();
+        }
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Analysis error: ${message}`);
+  }
+  return {
+    bindings,
+    identifier,
+    isTargeted,
+    targetLine
+  };
+}
+function formatSourcePosition2(line, column) {
+  if (line !== null && column !== null) {
+    return `L${line}:${column}`;
+  }
+  return "";
+}
+function formatCodeLine2(lineNumber, sourcePos, code, prefix = "  ") {
+  const lineNumStr = String(lineNumber).padStart(5, " ");
+  const srcPosPadded = sourcePos ? sourcePos.padEnd(10, " ") : "          ";
+  return `${prefix}${lineNumStr} ${srcPosPadded} ${code}`;
+}
+function locationsMatch(loc1, loc2) {
+  return loc1.line === loc2.line && loc1.column === loc2.column;
+}
+function formatAnalysisResult(filePath, result, maxReferences = 10) {
+  const { bindings, identifier, isTargeted, targetLine } = result;
+  const outputParts = [];
+  outputParts.push(`${filePath}`);
+  outputParts.push(`Identifier="${identifier}"`);
+  outputParts.push(`Src=original position for breakpoints`);
+  if (bindings.length === 0) {
+    if (isTargeted && targetLine !== void 0) {
+      outputParts.push(`Bindings: None at line ${targetLine}`);
+      outputParts.push(`The variable may be global, externally defined, or not present at this line.`);
+    } else {
+      outputParts.push("Bindings: None");
+    }
+    return outputParts.join("\n");
+  }
+  if (isTargeted) {
+    outputParts.push(`Bindings: 1 (Targeted at line ${targetLine})`);
+  } else {
+    const scopeInfo = bindings.length > 1 ? " (different scopes)" : "";
+    outputParts.push(`Bindings: ${bindings.length}${scopeInfo}`);
+  }
+  for (let i = 0; i < bindings.length; i++) {
+    const binding = bindings[i];
+    if (isTargeted) {
+      outputParts.push(`--- Targeted Scope (${binding.kind}) ---`);
+    } else {
+      outputParts.push(`--- Scope #${i + 1} (${binding.kind}) ---`);
+    }
+    const defIsHit = isTargeted && binding.hitLocation && locationsMatch(binding.definition, binding.hitLocation);
+    const defPrefix = defIsHit ? "\u{1F4CD} Definition (hit):" : "\u{1F4CD} Definition:";
+    outputParts.push(defPrefix);
+    const defSrcPos = formatSourcePosition2(
+      binding.definition.originalPosition.line,
+      binding.definition.originalPosition.column
+    );
+    const defMarker = defIsHit ? " \u25C0\u2500\u2500 hit" : "";
+    outputParts.push(formatCodeLine2(binding.definition.line, defSrcPos, binding.definition.lineContent + defMarker, "  "));
+    const totalRefs = binding.totalReferences;
+    if (totalRefs === 0) {
+      outputParts.push("\u{1F50E} References: None");
+    } else {
+      outputParts.push(`\u{1F50E} References (${totalRefs}):`);
+      for (const ref of binding.references) {
+        const refIsHit = isTargeted && binding.hitLocation && locationsMatch(ref, binding.hitLocation);
+        const refSrcPos = formatSourcePosition2(
+          ref.originalPosition.line,
+          ref.originalPosition.column
+        );
+        const refMarker = refIsHit ? " \u25C0\u2500\u2500 hit" : "";
+        outputParts.push(formatCodeLine2(ref.line, refSrcPos, ref.lineContent + refMarker, "  "));
+      }
+      if (totalRefs > maxReferences) {
+        const remaining = totalRefs - maxReferences;
+        outputParts.push(`  ... (${remaining} more references not shown)`);
+      }
+    }
+  }
+  return outputParts.join("\n");
+}
+
+// src/transformer.ts
+import * as path3 from "path";
+import * as fs2 from "fs/promises";
+import { transformSync } from "@babel/core";
+function cleanBasename(filename) {
+  const base = path3.basename(filename);
+  let name = base.endsWith(".js") ? base.slice(0, -3) : base;
+  name = name.replace(/_deob[^/]*$/, "");
+  if (name.endsWith(".beautified")) {
+    name = name.slice(0, -".beautified".length);
+  }
+  return name;
+}
+function getOutputPaths(targetFile, outputSuffix = "_deob") {
+  const absolutePath = path3.resolve(targetFile);
+  const dir = path3.dirname(absolutePath);
+  const basename3 = cleanBasename(absolutePath);
+  const outputPath = path3.join(dir, `${basename3}${outputSuffix}.js`);
+  const mapPath = `${outputPath}.map`;
+  return { outputPath, mapPath };
+}
+async function loadBabelPlugin(scriptPath) {
+  const absolutePath = path3.resolve(scriptPath);
+  try {
+    await fs2.access(absolutePath);
+  } catch {
+    throw new Error(`Script not found: ${absolutePath}`);
+  }
+  const fileUrl = `file://${absolutePath}?t=${Date.now()}`;
+  let module;
+  try {
+    module = await import(fileUrl);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load script: ${message}`);
+  }
+  const plugin = module.default ?? module;
+  if (typeof plugin !== "function") {
+    throw new Error(
+      `Invalid Babel plugin: Script must export a function that returns a visitor object. Got ${typeof plugin} instead.`
+    );
+  }
+  return plugin;
+}
+function runBabelTransform(code, inputSourceMap, plugin, filename) {
+  let result;
+  try {
+    result = transformSync(code, {
+      filename,
+      plugins: [plugin],
+      // Source map configuration for cascade
+      // @ts-expect-error - SourceMap is compatible with InputSourceMap at runtime
+      inputSourceMap,
+      sourceMaps: true,
+      // Readability settings
+      retainLines: false,
+      compact: false,
+      minified: false,
+      // Preserve code structure
+      parserOpts: {
+        sourceType: "unambiguous"
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Babel Error: ${message}`);
+  }
+  if (!result || !result.code) {
+    throw new Error("Babel Error: Transform produced no output");
+  }
+  if (!result.map) {
+    throw new Error("Babel Error: Transform produced no source map");
+  }
+  return {
+    code: result.code,
+    map: result.map
+  };
+}
+async function applyCustomTransform(targetFile, options) {
+  const { scriptPath, outputSuffix = "_deob" } = options;
+  const absoluteTargetPath = path3.resolve(targetFile);
+  try {
+    await fs2.access(absoluteTargetPath);
+  } catch {
+    throw new Error(`File not found: ${targetFile}`);
+  }
+  const plugin = await loadBabelPlugin(scriptPath);
+  const beautifyResult = await ensureBeautified(absoluteTargetPath);
+  const { code: beautifiedCode, rawMap: inputSourceMap } = beautifyResult;
+  const transformResult = runBabelTransform(
+    beautifiedCode,
+    inputSourceMap,
+    plugin,
+    absoluteTargetPath
+  );
+  const { outputPath, mapPath } = getOutputPaths(absoluteTargetPath, outputSuffix);
+  const mapFileName = path3.basename(mapPath);
+  const outputCode = `${transformResult.code}
+//# sourceMappingURL=${mapFileName}`;
+  const outputMap = {
+    ...transformResult.map,
+    file: path3.basename(outputPath)
+  };
+  try {
+    await Promise.all([
+      fs2.writeFile(outputPath, outputCode, "utf-8"),
+      fs2.writeFile(mapPath, JSON.stringify(outputMap, null, 2), "utf-8")
+    ]);
+  } catch (err) {
+    const error = err;
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      throw new Error(`Permission denied: Cannot write to ${path3.dirname(outputPath)}`);
+    }
+    throw new Error(`Failed to write output files: ${error.message || String(err)}`);
+  }
+  return {
+    code: outputCode,
+    map: outputMap,
+    outputPath,
+    mapPath
+  };
+}
+
+// src/index.ts
+async function smartRead(filePath, options) {
+  const absolutePath = path4.resolve(filePath);
+  try {
+    await fs3.access(absolutePath);
+  } catch {
+    return {
+      code: "",
+      sourceMap: null,
+      language: "unknown",
+      usedFallback: true,
+      error: `File not found: ${filePath}`
+    };
+  }
+  const langInfo = options?.language ? getLanguageInfo(options.language) : detectLanguage(absolutePath);
+  try {
+    const beautifyResult = await ensureBeautified(absolutePath, {
+      language: options?.language,
+      saveLocal: options?.saveLocal
+    });
+    let code = beautifyResult.code;
+    if (options?.startLine !== void 0 || options?.endLine !== void 0) {
+      const lines = code.split("\n");
+      const startLine = Math.max(1, options?.startLine ?? 1);
+      const endLine = Math.min(lines.length, options?.endLine ?? lines.length);
+      code = lines.slice(startLine - 1, endLine).join("\n");
+    }
+    const truncateResult = truncateCodeFromFile(absolutePath, code, {
+      language: options?.language,
+      charLimit: options?.charLimit,
+      maxLineChars: options?.maxLineChars,
+      previewLength: options?.previewLength
+    });
+    return {
+      code: truncateResult.code,
+      sourceMap: beautifyResult.rawMap,
+      language: langInfo.language,
+      usedFallback: beautifyResult.usedFallback || truncateResult.usedFallback,
+      localPath: beautifyResult.localPath
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      code: "",
+      sourceMap: null,
+      language: langInfo.language,
+      usedFallback: true,
+      error: message
+    };
+  }
+}
+async function smartSearch(filePath, query, options) {
+  const absolutePath = path4.resolve(filePath);
+  try {
+    await fs3.access(absolutePath);
+  } catch {
+    return {
+      matches: [],
+      totalMatches: 0,
+      truncated: false,
+      formatted: `File not found: ${filePath}`,
+      error: `File not found: ${filePath}`
+    };
+  }
+  try {
+    const beautifyResult = await ensureBeautified(absolutePath);
+    if (!beautifyResult.rawMap) {
+      return {
+        matches: [],
+        totalMatches: 0,
+        truncated: false,
+        formatted: `Search not supported for this file type (no source map available)`,
+        error: `Search requires source map support`
+      };
+    }
+    const searchResult = searchInCode(
+      beautifyResult.code,
+      beautifyResult.rawMap,
+      options ?? { query }
+    );
+    const formatted = formatSearchResult(
+      filePath,
+      query,
+      options?.caseSensitive ?? false,
+      searchResult,
+      options?.maxMatches ?? 50,
+      options?.isRegex ?? false
+    );
+    return {
+      ...searchResult,
+      formatted
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      matches: [],
+      totalMatches: 0,
+      truncated: false,
+      formatted: `Search error: ${message}`,
+      error: message
+    };
+  }
+}
+async function findUsage(filePath, identifier, options) {
+  const absolutePath = path4.resolve(filePath);
+  try {
+    await fs3.access(absolutePath);
+  } catch {
+    return {
+      bindings: [],
+      identifier,
+      isTargeted: options?.targetLine !== void 0,
+      targetLine: options?.targetLine,
+      formatted: `File not found: ${filePath}`,
+      error: `File not found: ${filePath}`
+    };
+  }
+  try {
+    const beautifyResult = await ensureBeautified(absolutePath);
+    if (!beautifyResult.rawMap) {
+      return {
+        bindings: [],
+        identifier,
+        isTargeted: options?.targetLine !== void 0,
+        targetLine: options?.targetLine,
+        formatted: `Analysis not supported for this file type (no source map available)`,
+        error: `Analysis requires source map support`
+      };
+    }
+    const analysisResult = await analyzeBindings(
+      beautifyResult.code,
+      beautifyResult.rawMap,
+      identifier,
+      options
+    );
+    const formatted = formatAnalysisResult(
+      filePath,
+      analysisResult,
+      options?.maxReferences ?? 10
+    );
+    return {
+      ...analysisResult,
+      formatted
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      bindings: [],
+      identifier,
+      isTargeted: options?.targetLine !== void 0,
+      targetLine: options?.targetLine,
+      formatted: `Analysis error: ${message}`,
+      error: message
+    };
+  }
+}
+export {
+  analyzeBindings,
+  applyCustomTransform,
+  beautifyCode,
+  beautifyCss,
+  beautifyHtml,
+  beautifyJson,
+  cleanBasename,
+  createRegex,
+  detectLanguage,
+  ensureBeautified,
+  escapeRegex,
+  findUsage,
+  formatAnalysisResult,
+  formatSourcePosition2 as formatAnalyzeSourcePosition,
+  formatSearchResult,
+  formatSourcePosition as formatSearchSourcePosition,
+  getLanguageInfo,
+  getLocalPaths,
+  getOutputPaths,
+  getSupportedExtensions,
+  isExtensionSupported,
+  isFullySupportedLanguage,
+  isLocalCacheValid,
+  loadBabelPlugin,
+  parseCode,
+  runBabelTransform,
+  searchInCode,
+  smartRead,
+  smartSearch,
+  truncateCode,
+  truncateCodeFromFile,
+  truncateCodeHighPerf,
+  truncateFallback,
+  truncateLongLines,
+  unescapeBackslashes
+};
+//# sourceMappingURL=index.js.map