@reverse-craft/ai-tools 1.0.0 → 1.0.2

package/dist/llmConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llmConfig.d.ts","sourceRoot":"","sources":["../src/llmConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,SAAS,GAAG,IAAI,CAiB/C;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtD;AAoDD;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAyD5D"}
+{"version":3,"file":"llmConfig.d.ts","sourceRoot":"","sources":["../src/llmConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAExC;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,WAAW,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAIpE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,WAAW,EAAE;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAgBA,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,WAAW,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,IAAI,CAM9E;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,SAAS,GAAG,IAAI,CAoC/C;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtD;AA6DD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,aAAa,CAwBpE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAyB5D"}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":""}

package/dist/server.js

@@ -0,0 +1,614 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+
+// src/tools/findJsvmpDispatcherTool.ts
+import { z } from "zod";
+
+// src/tools/ToolDefinition.ts
+function defineTool(definition) {
+  return definition;
+}
+
+// src/jsvmpDetector.ts
+import { SourceMapConsumer } from "source-map-js";
+import { ensureBeautified, truncateCodeHighPerf } from "@reverse-craft/smart-fs";
+import { existsSync } from "fs";
+
+// src/llmConfig.ts
+import { generateText } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+var PROVIDER_DEFAULTS = {
+  openai: { model: "gpt-4o-mini" },
+  anthropic: { model: "claude-sonnet-4-20250514" },
+  google: { model: "gemini-2.0-flash" }
+};
+var PROVIDER_ENV_KEYS = {
+  openai: {
+    apiKey: "OPENAI_API_KEY",
+    model: "OPENAI_MODEL",
+    baseUrl: "OPENAI_BASE_URL"
+  },
+  anthropic: {
+    apiKey: "ANTHROPIC_API_KEY",
+    model: "ANTHROPIC_MODEL",
+    baseUrl: "ANTHROPIC_BASE_URL"
+  },
+  google: {
+    apiKey: "GOOGLE_API_KEY",
+    model: "GOOGLE_MODEL",
+    baseUrl: "GOOGLE_BASE_URL"
+  }
+};
+function validateProvider(value) {
+  if (value === void 0) return null;
+  if (value === "openai" || value === "anthropic" || value === "google") {
+    return value;
+  }
+  return null;
+}
+function getLLMConfig() {
+  const providerEnv = process.env.LLM_PROVIDER?.toLowerCase();
+  const provider = validateProvider(providerEnv);
+  if (provider === null && providerEnv !== void 0) {
+    console.warn(`Invalid LLM_PROVIDER: ${providerEnv}. Valid values: openai, anthropic, google`);
+    return null;
+  }
+  const effectiveProvider = provider ?? "openai";
+  const envKeys = PROVIDER_ENV_KEYS[effectiveProvider];
+  const apiKey = process.env[envKeys.apiKey];
+  if (!apiKey) {
+    return null;
+  }
+  const model = process.env.LLM_MODEL || process.env[envKeys.model] || PROVIDER_DEFAULTS[effectiveProvider].model;
+  const baseUrl = process.env.LLM_BASE_URL || process.env[envKeys.baseUrl];
+  return {
+    provider: effectiveProvider,
+    apiKey,
+    model,
+    baseUrl
+  };
+}
+function buildJSVMPSystemPrompt() {
+  return `You are a Senior JavaScript Reverse Engineer and De-obfuscation Expert. Your specialty is analyzing **JSVMP (JavaScript Virtual Machine Protection)**.
+
+**Context: What is JSVMP?**
+JSVMP is a protection technique where original JavaScript code is compiled into custom **bytecode** and executed by a custom **interpreter** (virtual machine) written in JavaScript.
+
+Key components of JSVMP code include:
+1. **The Virtual Stack:** A central array used to store operands and results (e.g., \`stack[pointer++]\` or \`v[p--]\`).
+2. **The Dispatcher:** A control flow structure inside a loop that decides which instruction to execute next based on the current bytecode (opcode).
+   * *Common variants:* A massive \`switch\` statement, a deeply nested \`if-else\` chain (binary search style), or a function array mapping (\`handlers[opcode]()\`).
+3. **The Bytecode:** A large string or array of integers representing the program logic.
+
+**Task:**
+Analyze the provided JavaScript code snippet to identify regions that match JSVMP structural patterns.
+
+**Input Data Format:**
+The code is provided in a simplified format: \`LineNo SourceLoc Code\`.
+* **Example:** \`10 L234:56 var x = stack[p++];\`
+* **Instruction:** Focus on the **LineNo** (1st column) and **Code** (3rd column onwards). Ignore the \`SourceLoc\` (middle column).
+
+**Detection Rules & Confidence Levels:**
+Please assign confidence based on the following criteria:
+
+* **Ultra High:**
+  * A combination of a **Main Loop** + **Dispatcher** + **Stack Operations** appears in the same block.
+  * *Example:* A \`while(true)\` loop containing a huge \`if-else\` chain where branches perform \`stack[p++]\` operations.
+
+* **High:**
+  * Distinct **Dispatcher** structures found (e.g., a \`switch\` with >20 cases, or an \`if-else\` chain nested >10 levels deep checking integer values).
+  * Large arrays containing only function definitions (Instruction Handlers).
+
+* **Medium:**
+  * Isolated **Stack Operations** (e.g., \`v2[p2] = v2[p2 - 1]\`) without visible dispatchers nearby.
+  * Suspicious \`while\` loops iterating over a string/array.
+
+* **Low:**
+  * Generic obfuscation patterns (short variable names, comma operators) that *might* be part of a VM but lack specific structural proof.
+
+**Output Format:**
+Return **ONLY valid JSON**. No markdown wrapper, no conversational text.
+
+**JSON Schema:**
+{
+  "summary": "Brief analysis of the code structure in chinese, shortly",
+  "regions": [
+    {
+      "start": <start_line>,
+      "end": <end_line>,
+      "type": "<If-Else Dispatcher | Switch Dispatcher | Instruction Array | Stack Operation>",
+      "confidence": "<ultra_high | high | medium | low>",
+      "description": "<Why you flagged this. Mention specific variables like 'v2', 'p2' or structures. in chinese, shortly>"
+    }
+  ]
+}`;
+}
+function createProviderModel(config) {
+  switch (config.provider) {
+    case "openai": {
+      const openai = createOpenAI({
+        apiKey: config.apiKey,
+        baseURL: config.baseUrl
+      });
+      return openai(config.model);
+    }
+    case "anthropic": {
+      const anthropic = createAnthropic({
+        apiKey: config.apiKey,
+        baseURL: config.baseUrl
+      });
+      return anthropic(config.model);
+    }
+    case "google": {
+      const google = createGoogleGenerativeAI({
+        apiKey: config.apiKey,
+        baseURL: config.baseUrl
+      });
+      return google(config.model);
+    }
+  }
+}
+function createLLMClient(config) {
+  const model = createProviderModel(config);
+  return {
+    async analyzeJSVMP(formattedCode) {
+      const systemPrompt = buildJSVMPSystemPrompt();
+      try {
+        const result = await generateText({
+          model,
+          system: systemPrompt,
+          prompt: `\u8BF7\u5206\u6790\u4EE5\u4E0B\u4EE3\u7801\uFF0C\u8BC6\u522B JSVMP \u4FDD\u62A4\u7ED3\u6784\uFF1A
+
+${formattedCode}`,
+          temperature: 0.1
+        });
+        return result.text;
+      } catch (error) {
+        const providerName = config.provider.charAt(0).toUpperCase() + config.provider.slice(1);
+        if (error instanceof Error) {
+          throw new Error(`${providerName} LLM \u8BF7\u6C42\u5931\u8D25: ${error.message}`);
+        }
+        throw new Error(`${providerName} LLM \u8BF7\u6C42\u5931\u8D25: ${String(error)}`);
+      }
+    }
+  };
+}
+
+// src/tokenizer.ts
+import { encoding_for_model } from "tiktoken";
+var DEFAULT_MODEL = "gpt-4o";
+function countTokens(text, model) {
+  const enc = encoding_for_model(model ?? DEFAULT_MODEL);
+  try {
+    const tokens = enc.encode(text);
+    return tokens.length;
+  } finally {
+    enc.free();
+  }
+}
+function splitByTokenLimit(lines, maxTokens, model) {
+  if (lines.length === 0) {
+    return [];
+  }
+  if (maxTokens <= 0) {
+    throw new Error("maxTokens must be a positive number");
+  }
+  const batches = [];
+  let currentBatch = [];
+  let currentTokenCount = 0;
+  const enc = encoding_for_model(model ?? DEFAULT_MODEL);
+  try {
+    for (const line of lines) {
+      const lineWithNewline = line + "\n";
+      const lineTokens = enc.encode(lineWithNewline).length;
+      if (lineTokens > maxTokens) {
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+          currentBatch = [];
+          currentTokenCount = 0;
+        }
+        batches.push([line]);
+        continue;
+      }
+      if (currentTokenCount + lineTokens > maxTokens && currentBatch.length > 0) {
+        batches.push(currentBatch);
+        currentBatch = [];
+        currentTokenCount = 0;
+      }
+      currentBatch.push(line);
+      currentTokenCount += lineTokens;
+    }
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+    return batches;
+  } finally {
+    enc.free();
+  }
+}
+
+// src/jsvmpDetector.ts
+function formatSourcePosition(line, column) {
+  if (line !== null && column !== null) {
+    return `L${line}:${column}`;
+  }
+  return "";
+}
+function formatCodeLine(lineNumber, sourcePos, code) {
+  const lineNumStr = String(lineNumber).padStart(5, " ");
+  const srcPosPadded = sourcePos ? sourcePos.padEnd(10, " ") : "          ";
+  return `${lineNumStr} ${srcPosPadded} ${code}`;
+}
+async function formatEntireFile(filePath, charLimit = 300) {
+  const beautifyResult = await ensureBeautified(filePath);
+  const { code, rawMap } = beautifyResult;
+  const truncatedCode = truncateCodeHighPerf(code, charLimit);
+  const codeLines = truncatedCode.split("\n");
+  const totalLines = codeLines.length;
+  const formattedLines = [];
+  let consumer = null;
+  if (rawMap && rawMap.sources && rawMap.names && rawMap.mappings) {
+    consumer = new SourceMapConsumer({
+      version: String(rawMap.version),
+      sources: rawMap.sources,
+      names: rawMap.names,
+      mappings: rawMap.mappings,
+      file: rawMap.file,
+      sourceRoot: rawMap.sourceRoot
+    });
+  }
+  for (let lineNum = 1; lineNum <= totalLines; lineNum++) {
+    const lineIndex = lineNum - 1;
+    const lineContent = codeLines[lineIndex] ?? "";
+    let sourcePos = "";
+    if (consumer) {
+      const originalPos = consumer.originalPositionFor({
+        line: lineNum,
+        column: 0
+      });
+      sourcePos = formatSourcePosition(originalPos.line, originalPos.column);
+    }
+    formattedLines.push(formatCodeLine(lineNum, sourcePos, lineContent));
+  }
+  return {
+    lines: formattedLines,
+    totalLines
+  };
+}
+function extractLineNumber(formattedLine) {
+  const lineNumStr = formattedLine.substring(0, 5).trim();
+  return parseInt(lineNumStr, 10);
+}
+function createBatches(formattedLines, maxTokensPerBatch) {
+  if (formattedLines.length === 0) {
+    return [];
+  }
+  const lineBatches = splitByTokenLimit(formattedLines, maxTokensPerBatch);
+  const batches = [];
+  for (const batchLines of lineBatches) {
+    if (batchLines.length === 0) continue;
+    const startLine = extractLineNumber(batchLines[0]);
+    const endLine = extractLineNumber(batchLines[batchLines.length - 1]);
+    const content = batchLines.join("\n");
+    const tokenCount = countTokens(content);
+    batches.push({
+      startLine,
+      endLine,
+      content,
+      tokenCount
+    });
+  }
+  return batches;
+}
+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");
+  }
+  const obj = parsed;
+  if (typeof obj.summary !== "string") {
+    throw new Error("LLM \u54CD\u5E94\u683C\u5F0F\u65E0\u6548\uFF0C\u7F3A\u5C11\u5FC5\u9700\u5B57\u6BB5: summary");
+  }
+  if (!Array.isArray(obj.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 < obj.regions.length; i++) {
+    const region = obj.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: obj.summary,
+    regions: validatedRegions
+  };
+}
+function formatDetectionResultOutput(result, filePath, totalLines, batchCount) {
+  const lines = [];
+  lines.push("=== JSVMP Dispatcher Detection Result ===");
+  lines.push(`File: ${filePath} (${totalLines} lines, ${batchCount} batch${batchCount > 1 ? "es" : ""})`);
+  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");
+}
+function mergeDetectionResults(results) {
+  if (results.length === 0) {
+    return { summary: "", regions: [] };
+  }
+  if (results.length === 1) {
+    const sortedRegions = [...results[0].regions].sort((a, b) => a.start - b.start);
+    return { summary: results[0].summary, regions: sortedRegions };
+  }
+  const summaries = results.map((r, i) => `[Batch ${i + 1}] ${r.summary}`);
+  const combinedSummary = summaries.join("\n");
+  const allRegions = [];
+  for (const result of results) {
+    allRegions.push(...result.regions);
+  }
+  allRegions.sort((a, b) => a.start - b.start);
+  const confidenceOrder = {
+    "ultra_high": 4,
+    "high": 3,
+    "medium": 2,
+    "low": 1
+  };
+  const deduplicatedRegions = [];
+  for (const region of allRegions) {
+    let overlappingIndex = -1;
+    for (let i = 0; i < deduplicatedRegions.length; i++) {
+      const existing = deduplicatedRegions[i];
+      if (region.start <= existing.end && region.end >= existing.start) {
+        overlappingIndex = i;
+        break;
+      }
+    }
+    if (overlappingIndex === -1) {
+      deduplicatedRegions.push(region);
+    } else {
+      const existing = deduplicatedRegions[overlappingIndex];
+      if (confidenceOrder[region.confidence] > confidenceOrder[existing.confidence]) {
+        deduplicatedRegions[overlappingIndex] = region;
+      }
+    }
+  }
+  return {
+    summary: combinedSummary,
+    regions: deduplicatedRegions
+  };
+}
+async function processBatch(client, batch) {
+  const llmResponse = await client.analyzeJSVMP(batch.content);
+  return parseDetectionResult(llmResponse);
+}
+async function processBatchesWithErrorHandling(client, batches) {
+  const results = [];
+  const errors = [];
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    try {
+      const result = await processBatch(client, batch);
+      results.push(result);
+    } catch (error) {
+      const errorMsg = `Batch ${i + 1} (lines ${batch.startLine}-${batch.endLine}) failed: ${error instanceof Error ? error.message : String(error)}`;
+      errors.push(errorMsg);
+    }
+  }
+  return { results, errors };
+}
+async function findJsvmpDispatcher(filePath, options) {
+  const charLimit = options?.charLimit ?? 300;
+  const maxTokensPerBatch = options?.maxTokensPerBatch ?? 8e3;
+  const config = getLLMConfig();
+  if (!config) {
+    return {
+      success: false,
+      filePath,
+      totalLines: 0,
+      batchCount: 0,
+      error: "\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(filePath)) {
+    return {
+      success: false,
+      filePath,
+      totalLines: 0,
+      batchCount: 0,
+      error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`
+    };
+  }
+  try {
+    const formattedCode = await formatEntireFile(filePath, charLimit);
+    const totalLines = formattedCode.totalLines;
+    const batches = createBatches(formattedCode.lines, maxTokensPerBatch);
+    const batchCount = batches.length;
+    const client = createLLMClient(config);
+    const { results, errors } = await processBatchesWithErrorHandling(client, batches);
+    if (results.length === 0) {
+      return {
+        success: false,
+        filePath,
+        totalLines,
+        batchCount,
+        error: `\u6240\u6709\u6279\u6B21\u5904\u7406\u5931\u8D25: ${errors.join("; ")}`,
+        partialErrors: errors
+      };
+    }
+    const mergedResult = mergeDetectionResults(results);
+    const formattedOutput = formatDetectionResultOutput(mergedResult, filePath, totalLines, batchCount);
+    return {
+      success: true,
+      filePath,
+      totalLines,
+      batchCount,
+      result: mergedResult,
+      formattedOutput,
+      partialErrors: errors.length > 0 ? errors : void 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      filePath,
+      totalLines: 0,
+      batchCount: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/tools/findJsvmpDispatcherTool.ts
+var FindJsvmpDispatcherInputSchema = {
+  filePath: z.string().describe("Path to the JavaScript file to analyze"),
+  charLimit: z.number().int().positive().optional().describe("Character limit for string truncation (default: 300)"),
+  maxTokensPerBatch: z.number().int().positive().optional().describe("Maximum tokens per batch for LLM analysis (default: 200000)")
+};
+var findJsvmpDispatcherTool = defineTool({
+  name: "find_jsvmp_dispatcher",
+  description: `Detect JSVMP (JavaScript Virtual Machine Protection) patterns in code using LLM analysis.
+
+JSVMP is a code protection technique that converts JavaScript to bytecode executed by a virtual machine. This tool identifies:
+- If-Else Dispatchers: Nested if-else chains for instruction dispatch
+- Switch Dispatchers: Large switch statements (>20 cases) for opcode handling
+- Instruction Arrays: Arrays storing bytecode instructions
+- Stack Operations: Virtual stack push/pop patterns
+
+Automatically splits large files into batches based on token limits and merges results.
+
+Returns detection results with confidence levels (ultra_high, high, medium, low) and detailed descriptions.
+
+Requires OPENAI_API_KEY environment variable. Optional: OPENAI_BASE_URL, OPENAI_MODEL.`,
+  schema: FindJsvmpDispatcherInputSchema,
+  handler: async (params) => {
+    const { filePath, charLimit, maxTokensPerBatch } = params;
+    const result = await findJsvmpDispatcher(filePath, {
+      charLimit: charLimit ?? 300,
+      maxTokensPerBatch: maxTokensPerBatch ?? 2e5
+    });
+    if (!result.success) {
+      throw new Error(result.error ?? "Detection failed");
+    }
+    return result.formattedOutput ?? "No output generated";
+  }
+});
+
+// src/tools/index.ts
+var tools = [
+  findJsvmpDispatcherTool
+];
+
+// src/server.ts
+var server = new McpServer({
+  name: "ai-tools-mcp",
+  version: "1.0.0"
+});
+function registerTool(tool) {
+  const zodSchema = z2.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("AI Tools MCP Server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map