@reverse-craft/smart-fs 1.0.2 → 1.0.4

package/dist/server.js

@@ -1,22 +1,26 @@
 #!/usr/bin/env node
 
 // src/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { z as z5 } from "zod";
+
+// src/tools/readCodeSmart.ts
 import { z } from "zod";
 import { SourceMapConsumer } from "source-map-js";
 
+// src/tools/ToolDefinition.ts
+function defineTool(definition) {
+  return definition;
+}
+
 // src/beautifier.ts
 import * as esbuild from "esbuild";
 import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
-var TEMP_DIR = path.join(os.tmpdir(), "jsvmp-mcp-cache");
+var TEMP_DIR = path.join(os.tmpdir(), "smart-fs-mcp-cache");
 async function ensureCacheDir() {
   await fs.mkdir(TEMP_DIR, { recursive: true });
 }
@@ -30,6 +34,15 @@ function getCachePaths(originalPath, hash) {
   const mapPath = `${beautifiedPath}.map`;
   return { beautifiedPath, mapPath };
 }
+function getLocalPaths(originalPath) {
+  const absolutePath = path.resolve(originalPath);
+  const dir = path.dirname(absolutePath);
+  const ext = path.extname(absolutePath);
+  const baseName = path.basename(absolutePath, ext);
+  const beautifiedPath = path.join(dir, `${baseName}.beautified.js`);
+  const mapPath = `${beautifiedPath}.map`;
+  return { beautifiedPath, mapPath };
+}
 async function isCacheValid(beautifiedPath, mapPath) {
   try {
     await Promise.all([
@@ -41,14 +54,69 @@ async function isCacheValid(beautifiedPath, mapPath) {
     return false;
   }
 }
-async function ensureBeautified(originalPath) {
+async function isLocalCacheValid(originalPath) {
   const absolutePath = path.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
+  };
+}
+async function ensureBeautified(originalPath, options) {
+  const absolutePath = path.resolve(originalPath);
+  const saveLocal = options?.saveLocal ?? false;
   let stats;
   try {
     stats = await fs.stat(absolutePath);
   } catch {
     throw new Error(`File not found: ${originalPath}`);
   }
+  const localPaths = getLocalPaths(absolutePath);
+  if (saveLocal) {
+    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
+        };
+      } catch {
+      }
+    }
+  }
   await ensureCacheDir();
   const hash = calculateCacheKey(absolutePath, stats.mtimeMs);
   const { beautifiedPath, mapPath } = getCachePaths(absolutePath, hash);
@@ -57,14 +125,18 @@ async function ensureBeautified(originalPath) {
       fs.readFile(beautifiedPath, "utf-8"),
       fs.readFile(mapPath, "utf-8")
     ]);
-    return {
+    const result2 = {
       code: code2,
       rawMap: JSON.parse(mapContent)
     };
+    if (saveLocal) {
+      await saveToLocal(result2, localPaths, mapContent);
+    }
+    return result2;
   }
-  let result;
+  let esbuildResult;
   try {
-    result = await esbuild.build({
+    esbuildResult = await esbuild.build({
       entryPoints: [absolutePath],
       bundle: false,
       write: false,
@@ -81,18 +153,42 @@ async function ensureBeautified(originalPath) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Esbuild processing failed: ${message}`);
   }
-  const codeFile = result.outputFiles?.find((f) => f.path.endsWith(".js"));
-  const mapFile = result.outputFiles?.find((f) => f.path.endsWith(".map"));
+  const codeFile = esbuildResult.outputFiles?.find((f) => f.path.endsWith(".js"));
+  const mapFile = esbuildResult.outputFiles?.find((f) => f.path.endsWith(".map"));
   if (!codeFile || !mapFile) {
     throw new Error("Esbuild processing failed: Missing output files");
   }
   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, mapFile.text, "utf-8")
+    fs.writeFile(mapPath, mapText, "utf-8")
   ]);
-  return { code, rawMap };
+  const result = { code, rawMap };
+  if (saveLocal) {
+    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 ${path.dirname(localPaths.beautifiedPath)}`;
+    } else if (error.code === "ENOSPC") {
+      result.localSaveError = `Insufficient disk space: Cannot write to ${path.dirname(localPaths.beautifiedPath)}`;
+    } else {
+      result.localSaveError = `Failed to save locally: ${error.message || String(err)}`;
+    }
+  }
 }
 
 // src/truncator.ts
@@ -157,25 +253,26 @@ function truncateCodeHighPerf(sourceCode, limit = 200, previewLength = 50) {
   });
   return magicString.toString();
 }
-
-// src/server.ts
-var ReadCodeSmartInputSchema = z.object({
-  file_path: z.string().describe("Path to the JavaScript file"),
-  start_line: z.number().int().min(1).describe("Start line number (1-based)"),
-  end_line: z.number().int().min(1).describe("End line number (1-based)"),
-  char_limit: z.number().int().min(50).default(300).describe("Character limit for string truncation")
-});
-var server = new Server(
-  {
-    name: "jsvmp-smart-fs",
-    version: "1.0.0"
-  },
-  {
-    capabilities: {
-      tools: {}
-    }
+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/tools/readCodeSmart.ts
 function formatSourcePosition(line, column) {
   if (line !== null && column !== null) {
     return `L${line}:${column}`;
@@ -200,95 +297,716 @@ function formatPaginationHint(nextStartLine) {
   return `
 ... (Use next start_line=${nextStartLine} to read more)`;
 }
-async function handleReadCodeSmart(input) {
-  const { file_path, start_line, end_line, char_limit } = input;
-  const { code, rawMap } = await ensureBeautified(file_path);
-  const truncatedCode = truncateCodeHighPerf(code, char_limit);
-  const lines = truncatedCode.split("\n");
-  const totalLines = lines.length;
-  const effectiveStartLine = Math.max(1, start_line);
-  const effectiveEndLine = Math.min(totalLines, end_line);
-  if (effectiveStartLine > totalLines) {
-    throw new Error(`Start line ${start_line} exceeds total lines ${totalLines}`);
+var readCodeSmart = defineTool({
+  name: "read_code_smart",
+  description: "Read and beautify minified/obfuscated JavaScript code with source map coordinates. Returns formatted code with original file positions for setting breakpoints. Optionally saves the beautified file locally alongside the original file.",
+  schema: {
+    file_path: z.string().describe("Path to the JavaScript file"),
+    start_line: z.number().int().min(1).describe("Start line number (1-based)"),
+    end_line: z.number().int().min(1).describe("End line number (1-based)"),
+    char_limit: z.number().int().min(50).default(300).describe("Character limit for string truncation"),
+    max_line_chars: z.number().int().min(80).default(500).describe("Maximum characters per line"),
+    save_local: z.boolean().optional().default(false).describe("Save beautified file to the same directory as the original file")
+  },
+  handler: async (params) => {
+    const { file_path, start_line, end_line, char_limit, max_line_chars, save_local } = params;
+    const beautifyResult = await ensureBeautified(file_path, { saveLocal: save_local });
+    const { code, rawMap, localPath, localMapPath, localSaveError } = beautifyResult;
+    const truncatedCode = truncateCodeHighPerf(code, char_limit);
+    const lineTruncatedCode = truncateLongLines(truncatedCode, max_line_chars);
+    const lines = lineTruncatedCode.split("\n");
+    const totalLines = lines.length;
+    const effectiveStartLine = Math.max(1, start_line);
+    const effectiveEndLine = Math.min(totalLines, end_line);
+    if (effectiveStartLine > totalLines) {
+      throw new Error(`Start line ${start_line} exceeds total lines ${totalLines}`);
+    }
+    const consumer = new SourceMapConsumer({
+      ...rawMap,
+      version: String(rawMap.version)
+    });
+    const outputParts = [];
+    outputParts.push(formatHeader(file_path, effectiveStartLine, effectiveEndLine, totalLines));
+    if (save_local) {
+      if (localPath) {
+        outputParts.push(`LOCAL: ${localPath}`);
+        if (localMapPath) {
+          outputParts.push(`LOCAL_MAP: ${localMapPath}`);
+        }
+      }
+      if (localSaveError) {
+        outputParts.push(`LOCAL_SAVE_ERROR: ${localSaveError}`);
+      }
+      outputParts.push("-".repeat(85));
+    }
+    const maxLineNumWidth = String(effectiveEndLine).length;
+    for (let lineNum = effectiveStartLine; lineNum <= effectiveEndLine; lineNum++) {
+      const lineIndex = lineNum - 1;
+      const lineContent = lines[lineIndex] ?? "";
+      const originalPos = consumer.originalPositionFor({
+        line: lineNum,
+        column: 0
+      });
+      const sourcePos = formatSourcePosition(originalPos.line, originalPos.column);
+      outputParts.push(formatCodeLine(lineNum, sourcePos, lineContent, maxLineNumWidth));
+    }
+    if (effectiveEndLine < totalLines) {
+      outputParts.push(formatPaginationHint(effectiveEndLine + 1));
+    }
+    return outputParts.join("\n");
   }
-  const consumer = new SourceMapConsumer({
+});
+
+// src/tools/applyCustomTransform.ts
+import { z as z2 } from "zod";
+
+// src/transformer.ts
+import * as path2 from "path";
+import * as fs2 from "fs/promises";
+import { transformSync } from "@babel/core";
+function cleanBasename(filename) {
+  const base = path2.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 = path2.resolve(targetFile);
+  const dir = path2.dirname(absolutePath);
+  const basename3 = cleanBasename(absolutePath);
+  const outputPath = path2.join(dir, `${basename3}${outputSuffix}.js`);
+  const mapPath = `${outputPath}.map`;
+  return { outputPath, mapPath };
+}
+async function loadBabelPlugin(scriptPath) {
+  const absolutePath = path2.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 = path2.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 = path2.basename(mapPath);
+  const outputCode = `${transformResult.code}
+//# sourceMappingURL=${mapFileName}`;
+  const outputMap = {
+    ...transformResult.map,
+    file: path2.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 ${path2.dirname(outputPath)}`);
+    }
+    throw new Error(`Failed to write output files: ${error.message || String(err)}`);
+  }
+  return {
+    code: outputCode,
+    map: outputMap,
+    outputPath,
+    mapPath
+  };
+}
+
+// src/tools/applyCustomTransform.ts
+var ApplyCustomTransformInputSchema = z2.object({
+  target_file: z2.string().describe("Path to the JavaScript file to transform"),
+  script_path: z2.string().describe("Path to a JS file exporting a Babel Plugin function"),
+  output_suffix: z2.string().default("_deob").describe("Suffix for output file name")
+});
+var applyCustomTransform2 = defineTool({
+  name: "apply_custom_transform",
+  description: "Apply a custom Babel transformation to deobfuscate JavaScript code. Takes a target JS file and a Babel plugin script, runs the transformation, and outputs the deobfuscated code with a cascaded source map that traces back to the original minified file. The plugin script should export a function that returns a Babel visitor object.",
+  schema: {
+    target_file: z2.string().describe("Path to the JavaScript file to transform"),
+    script_path: z2.string().describe("Path to a JS file exporting a Babel Plugin function"),
+    output_suffix: z2.string().default("_deob").describe("Suffix for output file name")
+  },
+  handler: async (params) => {
+    const { target_file, script_path, output_suffix } = params;
+    const result = await applyCustomTransform(target_file, {
+      scriptPath: script_path,
+      outputSuffix: output_suffix
+    });
+    const successMessage = [
+      "Transform completed successfully!",
+      "",
+      `Output file: ${result.outputPath}`,
+      `Source map: ${result.mapPath}`
+    ].join("\n");
+    return successMessage;
+  }
+});
+
+// src/tools/searchCodeSmart.ts
+import { z as z3 } from "zod";
+
+// src/searcher.ts
+import { SourceMapConsumer as SourceMapConsumer2 } from "source-map-js";
+function createRegex(query, caseSensitive = false) {
+  try {
+    const flags = caseSensitive ? "g" : "gi";
+    return new RegExp(query, 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 createContextLine(lineNumber, content, consumer) {
+  return {
+    lineNumber,
+    content,
+    originalPosition: getOriginalPosition(consumer, lineNumber)
+  };
+}
+function searchInCode(code, rawMap, options) {
+  const {
+    query,
+    contextLines = 2,
+    caseSensitive = false,
+    maxMatches = 50
+  } = options;
+  const regex = createRegex(query, caseSensitive);
+  const lines = code.split("\n");
+  const totalLines = lines.length;
+  const consumer = new SourceMapConsumer2({
     ...rawMap,
     version: String(rawMap.version)
   });
+  const matchingLineNumbers = [];
+  for (let i = 0; i < totalLines; i++) {
+    const line = lines[i];
+    regex.lastIndex = 0;
+    if (regex.test(line)) {
+      matchingLineNumbers.push(i + 1);
+    }
+  }
+  const totalMatches = matchingLineNumbers.length;
+  const truncated = totalMatches > maxMatches;
+  const limitedLineNumbers = matchingLineNumbers.slice(0, maxMatches);
+  const matches = limitedLineNumbers.map((lineNumber) => {
+    const lineIndex = lineNumber - 1;
+    const lineContent = lines[lineIndex];
+    const contextBefore = [];
+    for (let i = Math.max(0, lineIndex - contextLines); i < lineIndex; i++) {
+      contextBefore.push(createContextLine(i + 1, lines[i], consumer));
+    }
+    const contextAfter = [];
+    for (let i = lineIndex + 1; i <= Math.min(totalLines - 1, lineIndex + contextLines); i++) {
+      contextAfter.push(createContextLine(i + 1, lines[i], consumer));
+    }
+    return {
+      lineNumber,
+      lineContent,
+      originalPosition: getOriginalPosition(consumer, lineNumber),
+      contextBefore,
+      contextAfter
+    };
+  });
+  return {
+    matches,
+    totalMatches,
+    truncated
+  };
+}
+function formatSourcePosition2(line, column) {
+  if (line !== null && column !== null) {
+    return `L${line}:${column}`;
+  }
+  return "";
+}
+function formatSearchResult(filePath, query, caseSensitive, result, maxMatches = 50) {
+  const { matches, totalMatches, truncated } = result;
   const outputParts = [];
-  outputParts.push(formatHeader(file_path, effectiveStartLine, effectiveEndLine, totalLines));
-  const maxLineNumWidth = String(effectiveEndLine).length;
-  for (let lineNum = effectiveStartLine; lineNum <= effectiveEndLine; lineNum++) {
-    const lineIndex = lineNum - 1;
-    const lineContent = lines[lineIndex] ?? "";
-    const originalPos = consumer.originalPositionFor({
-      line: lineNum,
-      column: 0
-    });
-    const sourcePos = formatSourcePosition(originalPos.line, originalPos.column);
-    outputParts.push(formatCodeLine(lineNum, sourcePos, lineContent, maxLineNumWidth));
+  const caseInfo = caseSensitive ? "case-sensitive" : "case-insensitive";
+  outputParts.push(`FILE: ${filePath}`);
+  outputParts.push(`QUERY: "${query}" (${caseInfo})`);
+  if (totalMatches === 0) {
+    outputParts.push("MATCHES: No matches found");
+    return outputParts.join("\n");
+  }
+  const matchInfo = truncated ? `MATCHES: ${totalMatches} found (showing first ${maxMatches})` : `MATCHES: ${totalMatches} found`;
+  outputParts.push(matchInfo);
+  outputParts.push("-".repeat(85));
+  for (const match of matches) {
+    outputParts.push(`--- Match at 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 lineNumStr = String(ctx.lineNumber).padStart(maxLineNumWidth, " ");
+      const srcPos = formatSourcePosition2(ctx.originalPosition.line, ctx.originalPosition.column);
+      const srcPosPadded = srcPos ? `Src ${srcPos}` : "";
+      outputParts.push(`    ${lineNumStr} | [${srcPosPadded.padEnd(14, " ")}] | ${ctx.content}`);
+    }
+    const matchLineNumStr = String(match.lineNumber).padStart(maxLineNumWidth, " ");
+    const matchSrcPos = formatSourcePosition2(match.originalPosition.line, match.originalPosition.column);
+    const matchSrcPosPadded = matchSrcPos ? `Src ${matchSrcPos}` : "";
+    outputParts.push(`>>  ${matchLineNumStr} | [${matchSrcPosPadded.padEnd(14, " ")}] | ${match.lineContent}`);
+    for (const ctx of match.contextAfter) {
+      const lineNumStr = String(ctx.lineNumber).padStart(maxLineNumWidth, " ");
+      const srcPos = formatSourcePosition2(ctx.originalPosition.line, ctx.originalPosition.column);
+      const srcPosPadded = srcPos ? `Src ${srcPos}` : "";
+      outputParts.push(`    ${lineNumStr} | [${srcPosPadded.padEnd(14, " ")}] | ${ctx.content}`);
+    }
+    outputParts.push("");
   }
-  if (effectiveEndLine < totalLines) {
-    outputParts.push(formatPaginationHint(effectiveEndLine + 1));
+  if (truncated) {
+    outputParts.push(`... (${totalMatches - maxMatches} more matches not shown)`);
   }
   return outputParts.join("\n");
 }
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+
+// src/tools/searchCodeSmart.ts
+var SearchCodeSmartInputSchema = z3.object({
+  file_path: z3.string().describe("Path to the JavaScript file"),
+  query: z3.string().describe("Regex pattern or text to search"),
+  context_lines: z3.number().int().min(0).default(2).describe("Number of context lines"),
+  case_sensitive: z3.boolean().default(false).describe("Case sensitive search"),
+  char_limit: z3.number().int().min(50).default(300).describe("Character limit for string truncation"),
+  max_line_chars: z3.number().int().min(80).default(500).describe("Maximum characters per line")
+});
+var searchCodeSmart = defineTool({
+  name: "search_code_smart",
+  description: "Search for text or regex patterns in beautified JavaScript code. Returns matching lines with context and original source coordinates for setting breakpoints. Useful for finding code patterns in minified/obfuscated files.",
+  schema: {
+    file_path: z3.string().describe("Path to the JavaScript file"),
+    query: z3.string().describe("Regex pattern or text to search"),
+    context_lines: z3.number().int().min(0).default(2).describe("Number of context lines"),
+    case_sensitive: z3.boolean().default(false).describe("Case sensitive search"),
+    char_limit: z3.number().int().min(50).default(300).describe("Character limit for string truncation"),
+    max_line_chars: z3.number().int().min(80).default(500).describe("Maximum characters per line")
+  },
+  handler: async (params) => {
+    const { file_path, query, context_lines, case_sensitive, char_limit, max_line_chars } = params;
+    const beautifyResult = await ensureBeautified(file_path);
+    const { code, rawMap } = beautifyResult;
+    const truncatedCode = truncateCodeHighPerf(code, char_limit);
+    const searchResult = searchInCode(truncatedCode, rawMap, {
+      query,
+      contextLines: context_lines,
+      caseSensitive: case_sensitive,
+      maxMatches: 50
+    });
+    let output = formatSearchResult(file_path, query, case_sensitive, searchResult, 50);
+    output = truncateLongLines(output, max_line_chars);
+    return output;
+  }
+});
+
+// src/tools/findUsageSmart.ts
+import { z as z4 } from "zod";
+
+// src/analyzer.ts
+import { SourceMapConsumer as SourceMapConsumer3 } 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 getLineContent(lines, lineNumber) {
+  if (lineNumber < 1 || lineNumber > lines.length) {
+    return "";
+  }
+  return lines[lineNumber - 1];
+}
+function createLocationInfo(line, column, lines, consumer) {
   return {
-    tools: [
-      {
-        name: "read_code_smart",
-        description: "Read and beautify minified/obfuscated JavaScript code with source map coordinates. Returns formatted code with original file positions for setting breakpoints.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            file_path: {
-              type: "string",
-              description: "Path to the JavaScript file"
-            },
-            start_line: {
-              type: "number",
-              description: "Start line number (1-based)"
-            },
-            end_line: {
-              type: "number",
-              description: "End line number (1-based)"
-            },
-            char_limit: {
-              type: "number",
-              description: "Character limit for string truncation (default: 300)",
-              default: 300
-            }
-          },
-          required: ["file_path", "start_line", "end_line"]
+    line,
+    column,
+    originalPosition: getOriginalPosition2(consumer, line, column),
+    lineContent: getLineContent(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 SourceMapConsumer3({
+    ...rawMap,
+    version: String(rawMap.version)
+  });
+  const bindings = [];
+  const processedScopes = /* @__PURE__ */ new Set();
+  const traverse2 = await getTraverse();
+  try {
+    traverse2(ast, {
+      Identifier(path3) {
+        if (path3.node.name !== identifier) {
+          return;
+        }
+        if (isTargeted) {
+          const nodeLoc = path3.node.loc;
+          if (!nodeLoc || nodeLoc.start.line !== targetLine) {
+            return;
+          }
+        }
+        const binding = path3.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 = path3.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) {
+          path3.stop();
         }
       }
-    ]
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Analysis error: ${message}`);
+  }
+  return {
+    bindings,
+    identifier,
+    isTargeted,
+    targetLine
   };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  if (name !== "read_code_smart") {
-    throw new Error(`Tool not found: ${name}`);
+}
+function formatSourcePosition3(line, column) {
+  if (line !== null && column !== null) {
+    return `L${line}:${column}`;
   }
-  try {
-    const input = ReadCodeSmartInputSchema.parse(args);
-    const result = await handleReadCodeSmart(input);
-    return {
-      content: [{ type: "text", text: result }]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      content: [{ type: "text", text: `Error: ${message}` }],
-      isError: true
-    };
+  return "";
+}
+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(`FILE: ${filePath}`);
+  outputParts.push(`IDENTIFIER: "${identifier}"`);
+  if (bindings.length === 0) {
+    if (isTargeted && targetLine !== void 0) {
+      outputParts.push(`BINDINGS: No binding found for "${identifier}" at line ${targetLine}`);
+      outputParts.push(`The variable may be global, externally defined, or not present at this line.`);
+    } else {
+      outputParts.push("BINDINGS: No definitions or references found");
+    }
+    return outputParts.join("\n");
+  }
+  if (isTargeted) {
+    outputParts.push(`BINDINGS: 1 found (Targeted Scope at line ${targetLine})`);
+  } else {
+    const scopeInfo = bindings.length > 1 ? " (in different scopes)" : "";
+    outputParts.push(`BINDINGS: ${bindings.length} found${scopeInfo}`);
+  }
+  outputParts.push("-".repeat(85));
+  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 = formatSourcePosition3(
+      binding.definition.originalPosition.line,
+      binding.definition.originalPosition.column
+    );
+    const defSrcPosPadded = defSrcPos ? `Src ${defSrcPos}` : "";
+    const defMarker = defIsHit ? " \u25C0\u2500\u2500 hit" : "";
+    outputParts.push(
+      `   ${binding.definition.line} | [${defSrcPosPadded.padEnd(14, " ")}] | ${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 = formatSourcePosition3(
+          ref.originalPosition.line,
+          ref.originalPosition.column
+        );
+        const refSrcPosPadded = refSrcPos ? `Src ${refSrcPos}` : "";
+        const refMarker = refIsHit ? " \u25C0\u2500\u2500 hit" : "";
+        outputParts.push(
+          `   ${ref.line} | [${refSrcPosPadded.padEnd(14, " ")}] | ${ref.lineContent}${refMarker}`
+        );
+      }
+      if (totalRefs > maxReferences) {
+        const remaining = totalRefs - maxReferences;
+        outputParts.push(`   ... (${remaining} more references not shown)`);
+      }
+    }
+    outputParts.push("");
+  }
+  return outputParts.join("\n");
+}
+
+// src/tools/findUsageSmart.ts
+var FindUsageSmartInputSchema = z4.object({
+  file_path: z4.string().describe("Path to the JavaScript file"),
+  identifier: z4.string().describe("Variable or function name to find"),
+  line: z4.number().int().positive().optional().describe(
+    "The line number where you see this variable. HIGHLY RECOMMENDED for precision in obfuscated code."
+  ),
+  char_limit: z4.number().int().min(50).default(300).describe("Character limit for string truncation"),
+  max_line_chars: z4.number().int().min(80).default(500).describe("Maximum characters per line")
+});
+var findUsageSmart = defineTool({
+  name: "find_usage_smart",
+  description: "Find all definitions and references of a variable/function using AST scope analysis. Returns binding information grouped by scope with original source coordinates for setting breakpoints. Useful for tracing variable usage in minified/obfuscated code with variable name reuse.",
+  schema: {
+    file_path: z4.string().describe("Path to the JavaScript file"),
+    identifier: z4.string().describe("Variable or function name to find"),
+    line: z4.number().int().positive().optional().describe(
+      "The line number where you see this variable. HIGHLY RECOMMENDED for precision in obfuscated code."
+    ),
+    char_limit: z4.number().int().min(50).default(300).describe("Character limit for string truncation"),
+    max_line_chars: z4.number().int().min(80).default(500).describe("Maximum characters per line")
+  },
+  handler: async (params) => {
+    const { file_path, identifier, line, char_limit, max_line_chars } = params;
+    const beautifyResult = await ensureBeautified(file_path);
+    const { code, rawMap } = beautifyResult;
+    const analysisResult = await analyzeBindings(code, rawMap, identifier, {
+      maxReferences: line ? 15 : 10,
+      targetLine: line
+    });
+    const truncatedCode = truncateCodeHighPerf(code, char_limit);
+    const truncatedLines = truncatedCode.split("\n");
+    for (const binding of analysisResult.bindings) {
+      const defLineIdx = binding.definition.line - 1;
+      if (defLineIdx >= 0 && defLineIdx < truncatedLines.length) {
+        binding.definition.lineContent = truncatedLines[defLineIdx];
+      }
+      for (const ref of binding.references) {
+        const refLineIdx = ref.line - 1;
+        if (refLineIdx >= 0 && refLineIdx < truncatedLines.length) {
+          ref.lineContent = truncatedLines[refLineIdx];
+        }
+      }
+    }
+    let output = formatAnalysisResult(file_path, analysisResult, line ? 15 : 10);
+    output = truncateLongLines(output, max_line_chars);
+    return output;
   }
 });
+
+// src/tools/index.ts
+var tools = [
+  readCodeSmart,
+  applyCustomTransform2,
+  searchCodeSmart,
+  findUsageSmart
+];
+
+// src/server.ts
+var server = new McpServer({
+  name: "smart-fs",
+  version: "1.0.0"
+});
+function registerTool(tool) {
+  const zodSchema = z5.object(tool.schema);
+  server.registerTool(
+    tool.name,
+    {
+      description: tool.description,
+      inputSchema: tool.schema
+    },
+    async (params, _extra) => {
+      try {
+        const validatedParams = zodSchema.parse(params);
+        const result = await tool.handler(validatedParams);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+for (const tool of tools) {
+  registerTool(tool);
+}
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("JSVMP Smart FS MCP Server running on stdio");
+  console.error("Smart FS MCP Server running on stdio");
 }
 main().catch((error) => {
   console.error("Fatal error:", error);