@reverse-craft/smart-fs 1.0.7 → 2.0.1

package/dist/server.js

@@ -3,7 +3,7 @@
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/tools/readCodeSmart.ts
 import { z } from "zod";
@@ -18,9 +18,82 @@ function defineTool(definition) {
 import * as esbuild from "esbuild";
 import * as crypto from "crypto";
 import * as fs from "fs/promises";
-import * as path from "path";
+import * as path2 from "path";
 import * as os from "os";
-var TEMP_DIR = path.join(os.tmpdir(), "smart-fs-mcp-cache");
+
+// 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];
+}
+
+// src/beautifier.ts
+var TEMP_DIR = path2.join(os.tmpdir(), "smart-fs-mcp-cache");
 async function ensureCacheDir() {
   await fs.mkdir(TEMP_DIR, { recursive: true });
 }
@@ -29,17 +102,17 @@ function calculateCacheKey(originalPath, mtimeMs) {
   return crypto.createHash("md5").update(fileKey).digest("hex");
 }
 function getCachePaths(originalPath, hash) {
-  const fileName = path.basename(originalPath, ".js");
-  const beautifiedPath = path.join(TEMP_DIR, `${fileName}.${hash}.beautified.js`);
+  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 = 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 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 };
 }
@@ -55,7 +128,7 @@ async function isCacheValid(beautifiedPath, mapPath) {
   }
 }
 async function isLocalCacheValid(originalPath) {
-  const absolutePath = path.resolve(originalPath);
+  const absolutePath = path2.resolve(originalPath);
   const { beautifiedPath } = getLocalPaths(absolutePath);
   let originalStats;
   try {
@@ -89,15 +162,122 @@ async function isLocalCacheValid(originalPath) {
     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 = path.resolve(originalPath);
+  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 {
@@ -109,7 +289,8 @@ async function ensureBeautified(originalPath, options) {
         code: code2,
         rawMap: JSON.parse(mapContent),
         localPath: localPaths.beautifiedPath,
-        localMapPath: localPaths.mapPath
+        localMapPath: localPaths.mapPath,
+        usedFallback: false
       };
     } catch {
     }
@@ -126,7 +307,8 @@ async function ensureBeautified(originalPath, options) {
       code: code2,
       rawMap: JSON.parse(mapContent),
       localPath: localPaths.beautifiedPath,
-      localMapPath: localPaths.mapPath
+      localMapPath: localPaths.mapPath,
+      usedFallback: false
     };
     await saveToLocal(result2, localPaths, mapContent);
     return result2;
@@ -147,13 +329,26 @@ async function ensureBeautified(originalPath, options) {
       treeShaking: false
     });
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Esbuild processing failed: ${message}`);
+    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) {
-    throw new Error("Esbuild processing failed: Missing output files");
+    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);
@@ -166,7 +361,8 @@ async function ensureBeautified(originalPath, options) {
     code,
     rawMap,
     localPath: localPaths.beautifiedPath,
-    localMapPath: localPaths.mapPath
+    localMapPath: localPaths.mapPath,
+    usedFallback: false
   };
   await saveToLocal(result, localPaths, mapText);
   return result;
@@ -182,9 +378,9 @@ async function saveToLocal(result, localPaths, mapText) {
   } catch (err) {
     const error = err;
     if (error.code === "EACCES" || error.code === "EPERM") {
-      result.localSaveError = `Permission denied: Cannot write to ${path.dirname(localPaths.beautifiedPath)}`;
+      result.localSaveError = `Permission denied: Cannot write to ${path2.dirname(localPaths.beautifiedPath)}`;
     } else if (error.code === "ENOSPC") {
-      result.localSaveError = `Insufficient disk space: Cannot write to ${path.dirname(localPaths.beautifiedPath)}`;
+      result.localSaveError = `Insufficient disk space: Cannot write to ${path2.dirname(localPaths.beautifiedPath)}`;
     } else {
       result.localSaveError = `Failed to save locally: ${error.message || String(err)}`;
     }
@@ -213,7 +409,7 @@ function createTruncatedString(original, previewLength) {
   const newlineStr = "\n".repeat(preservedNewlines);
   return `${start}${marker}${newlineStr}${end}`;
 }
-function truncateCodeHighPerf(sourceCode, limit = 200, previewLength = 50) {
+function truncateCodeAST(sourceCode, limit = 200, previewLength = 50) {
   let ast;
   try {
     ast = parse(sourceCode, {
@@ -224,7 +420,7 @@ function truncateCodeHighPerf(sourceCode, limit = 200, previewLength = 50) {
       raw: true
     });
   } catch {
-    return sourceCode;
+    return { code: sourceCode, parseFailed: true };
   }
   const magicString = new MagicString(sourceCode);
   walk(ast, {
@@ -251,7 +447,10 @@ function truncateCodeHighPerf(sourceCode, limit = 200, previewLength = 50) {
       }
     }
   });
-  return magicString.toString();
+  return { code: magicString.toString(), parseFailed: false };
+}
+function truncateCodeHighPerf(sourceCode, limit = 200, previewLength = 50) {
+  return truncateCodeAST(sourceCode, limit, previewLength).code;
 }
 function truncateLongLines(code, maxLineChars = 500, previewRatio = 0.2) {
   if (!code) {
@@ -357,11 +556,11 @@ var readCodeSmart = defineTool({
 import { z as z2 } from "zod";
 
 // src/transformer.ts
-import * as path2 from "path";
+import * as path3 from "path";
 import * as fs2 from "fs/promises";
 import { transformSync } from "@babel/core";
 function cleanBasename(filename) {
-  const base = path2.basename(filename);
+  const base = path3.basename(filename);
   let name = base.endsWith(".js") ? base.slice(0, -3) : base;
   name = name.replace(/_deob[^/]*$/, "");
   if (name.endsWith(".beautified")) {
@@ -370,15 +569,15 @@ function cleanBasename(filename) {
   return name;
 }
 function getOutputPaths(targetFile, outputSuffix = "_deob") {
-  const absolutePath = path2.resolve(targetFile);
-  const dir = path2.dirname(absolutePath);
+  const absolutePath = path3.resolve(targetFile);
+  const dir = path3.dirname(absolutePath);
   const basename3 = cleanBasename(absolutePath);
-  const outputPath = path2.join(dir, `${basename3}${outputSuffix}.js`);
+  const outputPath = path3.join(dir, `${basename3}${outputSuffix}.js`);
   const mapPath = `${outputPath}.map`;
   return { outputPath, mapPath };
 }
 async function loadBabelPlugin(scriptPath) {
-  const absolutePath = path2.resolve(scriptPath);
+  const absolutePath = path3.resolve(scriptPath);
   try {
     await fs2.access(absolutePath);
   } catch {
@@ -436,7 +635,7 @@ function runBabelTransform(code, inputSourceMap, plugin, filename) {
 }
 async function applyCustomTransform(targetFile, options) {
   const { scriptPath, outputSuffix = "_deob" } = options;
-  const absoluteTargetPath = path2.resolve(targetFile);
+  const absoluteTargetPath = path3.resolve(targetFile);
   try {
     await fs2.access(absoluteTargetPath);
   } catch {
@@ -452,12 +651,12 @@ async function applyCustomTransform(targetFile, options) {
     absoluteTargetPath
   );
   const { outputPath, mapPath } = getOutputPaths(absoluteTargetPath, outputSuffix);
-  const mapFileName = path2.basename(mapPath);
+  const mapFileName = path3.basename(mapPath);
   const outputCode = `${transformResult.code}
 //# sourceMappingURL=${mapFileName}`;
   const outputMap = {
     ...transformResult.map,
-    file: path2.basename(outputPath)
+    file: path3.basename(outputPath)
   };
   try {
     await Promise.all([
@@ -467,7 +666,7 @@ async function applyCustomTransform(targetFile, options) {
   } 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(`Permission denied: Cannot write to ${path3.dirname(outputPath)}`);
     }
     throw new Error(`Failed to write output files: ${error.message || String(err)}`);
   }
@@ -816,17 +1015,17 @@ async function analyzeBindings(code, rawMap, identifier, options) {
   const traverse2 = await getTraverse();
   try {
     traverse2(ast, {
-      Identifier(path3) {
-        if (path3.node.name !== identifier) {
+      Identifier(path4) {
+        if (path4.node.name !== identifier) {
           return;
         }
         if (isTargeted) {
-          const nodeLoc = path3.node.loc;
+          const nodeLoc = path4.node.loc;
           if (!nodeLoc || nodeLoc.start.line !== targetLine) {
             return;
           }
         }
-        const binding = path3.scope.getBinding(identifier);
+        const binding = path4.scope.getBinding(identifier);
         if (!binding) {
           return;
         }
@@ -865,7 +1064,7 @@ async function analyzeBindings(code, rawMap, identifier, options) {
         const limitedReferences = allReferences.slice(0, maxReferences);
         let hitLocation;
         if (isTargeted) {
-          const nodeLoc = path3.node.loc;
+          const nodeLoc = path4.node.loc;
           hitLocation = createLocationInfo(
             nodeLoc.start.line,
             nodeLoc.start.column,
@@ -882,7 +1081,7 @@ async function analyzeBindings(code, rawMap, identifier, options) {
           hitLocation
         });
         if (isTargeted) {
-          path3.stop();
+          path4.stop();
         }
       }
     });
@@ -1021,12 +1220,309 @@ var findUsageSmart = defineTool({
   }
 });
 
+// src/tools/aiFindJsvmpDispatcher.ts
+import { SourceMapConsumer as SourceMapConsumer4 } from "source-map-js";
+import { z as z5 } from "zod";
+
+// src/llmConfig.ts
+function getLLMConfig() {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    return null;
+  }
+  const baseUrl = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+  const model = process.env.OPENAI_MODEL || "gpt-4o-mini";
+  return {
+    apiKey,
+    baseUrl,
+    model
+  };
+}
+function buildJSVMPSystemPrompt() {
+  return `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684 JavaScript \u9006\u5411\u5DE5\u7A0B\u4E13\u5BB6\uFF0C\u4E13\u95E8\u8BC6\u522B JSVMP\uFF08JavaScript Virtual Machine Protection\uFF09\u4FDD\u62A4\u4EE3\u7801\u3002
+
+JSVMP \u662F\u4E00\u79CD\u4EE3\u7801\u4FDD\u62A4\u6280\u672F\uFF0C\u5C06 JavaScript \u4EE3\u7801\u8F6C\u6362\u4E3A\u5B57\u8282\u7801\uFF0C\u5E76\u901A\u8FC7\u865A\u62DF\u673A\u6267\u884C\u3002\u5178\u578B\u7279\u5F81\u5305\u62EC\uFF1A
+
+1. **\u865A\u62DF\u6808\uFF08Virtual Stack\uFF09**\uFF1A\u4E2D\u592E\u6570\u7EC4\u7528\u4E8E\u5B58\u50A8\u64CD\u4F5C\u6570\u548C\u7ED3\u679C
+2. **\u5206\u53D1\u5668\uFF08Dispatcher\uFF09**\uFF1A\u5927\u578B switch \u8BED\u53E5\u6216\u5D4C\u5957 if-else \u94FE\uFF0C\u6839\u636E\u6307\u4EE4\u7801\u6267\u884C\u4E0D\u540C\u64CD\u4F5C
+3. **\u6307\u4EE4\u6570\u7EC4\uFF08Instruction Array\uFF09**\uFF1A\u5B58\u50A8\u5B57\u8282\u7801\u6307\u4EE4\u7684\u6570\u7EC4
+4. **\u4E3B\u5FAA\u73AF\uFF08Main Loop\uFF09**\uFF1Awhile \u5FAA\u73AF\u6301\u7EED\u6267\u884C\u6307\u4EE4
+
+\u68C0\u6D4B\u89C4\u5219\uFF1A
+
+**Ultra High \u7F6E\u4FE1\u5EA6**\uFF1A
+- \u540C\u65F6\u51FA\u73B0\uFF1A\u4E3B\u5FAA\u73AF + \u5206\u53D1\u5668 + \u6808\u64CD\u4F5C
+- \u5206\u53D1\u5668\u6709 >20 \u4E2A case \u6216 >10 \u5C42\u5D4C\u5957
+- \u660E\u786E\u7684\u6808\u64CD\u4F5C\u6A21\u5F0F\uFF08push/pop/\u6570\u7EC4\u7D22\u5F15\uFF09
+
+**High \u7F6E\u4FE1\u5EA6**\uFF1A
+- \u72EC\u7ACB\u7684\u5927\u578B\u5206\u53D1\u5668\u7ED3\u6784\uFF08>20 case \u7684 switch \u6216 >10 \u5C42\u5D4C\u5957\u7684 if-else\uFF09
+- \u660E\u786E\u7684\u6307\u4EE4\u6570\u7EC4\u548C\u7A0B\u5E8F\u8BA1\u6570\u5668\u6A21\u5F0F
+
+**Medium \u7F6E\u4FE1\u5EA6**\uFF1A
+- \u5B64\u7ACB\u7684\u6808\u64CD\u4F5C\u6216\u53EF\u7591\u7684 while \u5FAA\u73AF
+- \u90E8\u5206 JSVMP \u7279\u5F81\u4F46\u4E0D\u5B8C\u6574
+
+**Low \u7F6E\u4FE1\u5EA6**\uFF1A
+- \u901A\u7528\u6DF7\u6DC6\u6A21\u5F0F
+- \u53EF\u80FD\u76F8\u5173\u4F46\u4E0D\u786E\u5B9A\u7684\u7ED3\u6784
+
+\u8BF7\u5206\u6790\u63D0\u4F9B\u7684\u4EE3\u7801\uFF0C\u8BC6\u522B JSVMP \u76F8\u5173\u533A\u57DF\u3002\u8FD4\u56DE JSON \u683C\u5F0F\uFF1A
+
+{
+  "summary": "\u5206\u6790\u6458\u8981\uFF08\u4E2D\u6587\uFF09",
+  "regions": [
+    {
+      "start": \u8D77\u59CB\u884C\u53F7,
+      "end": \u7ED3\u675F\u884C\u53F7,
+      "type": "If-Else Dispatcher" | "Switch Dispatcher" | "Instruction Array" | "Stack Operation",
+      "confidence": "ultra_high" | "high" | "medium" | "low",
+      "description": "\u8BE6\u7EC6\u63CF\u8FF0\uFF08\u4E2D\u6587\uFF09"
+    }
+  ]
+}
+
+\u5982\u679C\u6CA1\u6709\u68C0\u6D4B\u5230 JSVMP \u7279\u5F81\uFF0C\u8FD4\u56DE\u7A7A\u7684 regions \u6570\u7EC4\u3002`;
+}
+function createLLMClient(config) {
+  return {
+    async analyzeJSVMP(formattedCode) {
+      const systemPrompt = buildJSVMPSystemPrompt();
+      const requestBody = {
+        model: config.model,
+        messages: [
+          {
+            role: "system",
+            content: systemPrompt
+          },
+          {
+            role: "user",
+            content: `\u8BF7\u5206\u6790\u4EE5\u4E0B\u4EE3\u7801\uFF0C\u8BC6\u522B JSVMP \u4FDD\u62A4\u7ED3\u6784\uFF1A
+
+${formattedCode}`
+          }
+        ],
+        temperature: 0.1,
+        response_format: { type: "json_object" }
+      };
+      try {
+        const response = await fetch(`${config.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${config.apiKey}`
+          },
+          body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`API \u8BF7\u6C42\u5931\u8D25 (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        if (!data.choices || !data.choices[0] || !data.choices[0].message) {
+          throw new Error("API \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF1A\u7F3A\u5C11 choices \u6216 message \u5B57\u6BB5");
+        }
+        const content = data.choices[0].message.content;
+        if (typeof content !== "string") {
+          throw new Error("API \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF1Amessage.content \u4E0D\u662F\u5B57\u7B26\u4E32");
+        }
+        return content;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`LLM \u8BF7\u6C42\u5931\u8D25: ${error.message}`);
+        }
+        throw new Error(`LLM \u8BF7\u6C42\u5931\u8D25: ${String(error)}`);
+      }
+    }
+  };
+}
+
+// src/tools/aiFindJsvmpDispatcher.ts
+import { existsSync } from "fs";
+function formatSourcePosition4(line, column) {
+  if (line !== null && column !== null) {
+    return `L${line}:${column}`;
+  }
+  return "";
+}
+function formatCodeLine4(lineNumber, sourcePos, code) {
+  const lineNumStr = String(lineNumber).padStart(5, " ");
+  const srcPosPadded = sourcePos ? sourcePos.padEnd(10, " ") : "          ";
+  return `${lineNumStr} ${srcPosPadded} ${code}`;
+}
+async function formatCodeForAnalysis(filePath, startLine, endLine, charLimit = 300) {
+  const beautifyResult = await ensureBeautified(filePath);
+  const { code, rawMap } = beautifyResult;
+  const truncatedCode = truncateCodeHighPerf(code, charLimit);
+  const lines = truncatedCode.split("\n");
+  const totalLines = lines.length;
+  const effectiveStartLine = Math.max(1, Math.min(totalLines, startLine));
+  const effectiveEndLine = Math.max(effectiveStartLine, Math.min(totalLines, endLine));
+  const consumer = new SourceMapConsumer4({
+    ...rawMap,
+    version: String(rawMap.version)
+  });
+  const formattedLines = [];
+  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 = formatSourcePosition4(originalPos.line, originalPos.column);
+    formattedLines.push(formatCodeLine4(lineNum, sourcePos, lineContent));
+  }
+  return {
+    content: formattedLines.join("\n"),
+    totalLines,
+    startLine: effectiveStartLine,
+    endLine: effectiveEndLine
+  };
+}
+var VALID_DETECTION_TYPES = [
+  "If-Else Dispatcher",
+  "Switch Dispatcher",
+  "Instruction Array",
+  "Stack Operation"
+];
+var VALID_CONFIDENCE_LEVELS = [
+  "ultra_high",
+  "high",
+  "medium",
+  "low"
+];
+function isValidDetectionType(value) {
+  return VALID_DETECTION_TYPES.includes(value);
+}
+function isValidConfidenceLevel(value) {
+  return VALID_CONFIDENCE_LEVELS.includes(value);
+}
+function parseDetectionResult(jsonString) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonString);
+  } catch (error) {
+    throw new Error(`\u65E0\u6CD5\u89E3\u6790 LLM \u54CD\u5E94: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0C\u671F\u671B\u5BF9\u8C61\u7C7B\u578B");
+  }
+  if (typeof parsed.summary !== "string") {
+    throw new Error("LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0C\u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: summary");
+  }
+  if (!Array.isArray(parsed.regions)) {
+    throw new Error("LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0C\u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: regions");
+  }
+  const validatedRegions = [];
+  for (let i = 0; i < parsed.regions.length; i++) {
+    const region = parsed.regions[i];
+    if (typeof region !== "object" || region === null) {
+      throw new Error(`LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}] \u4E0D\u662F\u5BF9\u8C61`);
+    }
+    if (typeof region.start !== "number") {
+      throw new Error(`LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}] \u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: start`);
+    }
+    if (typeof region.end !== "number") {
+      throw new Error(`LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}] \u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: end`);
+    }
+    if (typeof region.type !== "string") {
+      throw new Error(`LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}] \u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: type`);
+    }
+    if (typeof region.confidence !== "string") {
+      throw new Error(`LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}] \u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: confidence`);
+    }
+    if (typeof region.description !== "string") {
+      throw new Error(`LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}] \u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: description`);
+    }
+    if (!isValidDetectionType(region.type)) {
+      throw new Error(
+        `LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}].type \u503C\u65E0\u6548: "${region.type}". \u6709\u6548\u503C: ${VALID_DETECTION_TYPES.join(", ")}`
+      );
+    }
+    if (!isValidConfidenceLevel(region.confidence)) {
+      throw new Error(
+        `LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0Cregions[${i}].confidence \u503C\u65E0\u6548: "${region.confidence}". \u6709\u6548\u503C: ${VALID_CONFIDENCE_LEVELS.join(", ")}`
+      );
+    }
+    validatedRegions.push({
+      start: region.start,
+      end: region.end,
+      type: region.type,
+      confidence: region.confidence,
+      description: region.description
+    });
+  }
+  return {
+    summary: parsed.summary,
+    regions: validatedRegions
+  };
+}
+function formatDetectionResult(result, filePath, startLine, endLine) {
+  const lines = [];
+  lines.push("=== JSVMP Dispatcher Detection Result ===");
+  lines.push(`File: ${filePath} (${startLine}-${endLine})`);
+  lines.push("");
+  lines.push(`Summary: ${result.summary}`);
+  lines.push("");
+  if (result.regions.length > 0) {
+    lines.push("Detected Regions:");
+    for (const region of result.regions) {
+      lines.push(`[${region.confidence}] Lines ${region.start}-${region.end}: ${region.type}`);
+      lines.push(`  ${region.description}`);
+      lines.push("");
+    }
+  } else {
+    lines.push("No JSVMP dispatcher patterns detected.");
+  }
+  return lines.join("\n");
+}
+var AiFindJsvmpDispatcherInputSchema = z5.object({
+  file_path: z5.string().describe("Path to the JavaScript file to analyze"),
+  start_line: z5.number().int().positive().describe("Start line number (1-based)"),
+  end_line: z5.number().int().positive().describe("End line number (1-based)"),
+  char_limit: z5.number().int().positive().optional().describe("Character limit for string truncation (default: 300)")
+});
+var aiFindJsvmpDispatcher = defineTool({
+  name: "ai_find_jsvmp_dispatcher",
+  description: "AI-powered tool to find JSVMP (JavaScript Virtual Machine Protection) dispatcher patterns in code using LLM analysis. Identifies dispatchers (switch/if-else), virtual stacks, instruction arrays, and other obfuscation patterns. Requires OPENAI_API_KEY environment variable.",
+  schema: AiFindJsvmpDispatcherInputSchema.shape,
+  handler: async (params) => {
+    const { file_path, start_line, end_line, char_limit } = params;
+    const config = getLLMConfig();
+    if (!config) {
+      return "\u9519\u8BEF\uFF1A\u672A\u914D\u7F6E LLM\u3002\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF OPENAI_API_KEY \u4EE5\u542F\u7528 JSVMP dispatcher \u68C0\u6D4B\u529F\u80FD\u3002";
+    }
+    if (!existsSync(file_path)) {
+      return `\u9519\u8BEF\uFF1A\u6587\u4EF6\u4E0D\u5B58\u5728: ${file_path}`;
+    }
+    try {
+      const formattedCode = await formatCodeForAnalysis(
+        file_path,
+        start_line,
+        end_line,
+        char_limit
+      );
+      const client = createLLMClient(config);
+      const llmResponse = await client.analyzeJSVMP(formattedCode.content);
+      const result = parseDetectionResult(llmResponse);
+      return formatDetectionResult(result, file_path, start_line, end_line);
+    } catch (error) {
+      if (error instanceof Error) {
+        return `\u9519\u8BEF\uFF1A${error.message}`;
+      }
+      return `\u9519\u8BEF\uFF1A${String(error)}`;
+    }
+  }
+});
+
 // src/tools/index.ts
 var tools = [
   readCodeSmart,
   applyCustomTransform2,
   searchCodeSmart,
-  findUsageSmart
+  findUsageSmart,
+  aiFindJsvmpDispatcher
 ];
 
 // src/server.ts
@@ -1035,7 +1531,7 @@ var server = new McpServer({
   version: "1.0.0"
 });
 function registerTool(tool) {
-  const zodSchema = z5.object(tool.schema);
+  const zodSchema = z6.object(tool.schema);
   server.registerTool(
     tool.name,
     {