mcp-code-context 2.5.1 → 3.0.4

package/dist/src/index.js

@@ -1,465 +1,250 @@
 #!/usr/bin/env node
 /**
- * mcp-code-context — Semantic Code Context Server (v2.3.1 - Refactored)
+ * mcp-code-context v3.0.4 - Tree-sitter WASM Edition
  *
- * A Model Context Protocol (MCP) server that compresses any code repository
- * into LLM-ready semantic context and provides surgical code editing.
- *
- * Architecture: Modular handlers with centralized utilities
- * - Read handlers: get_semantic_repo_map, read_file_surgical, analyze_impact, etc.
- * - Write handlers: write_file_surgical, insert_symbol, rename_symbol, remove_symbol
- * - Util handlers: rollback_file, clean_backups
- *
- * Transport: stdio (JSON-RPC over stdin/stdout)
- * Compatible with: Claude Desktop, Cursor, Windsurf, Copilot, Amazon Q, and any MCP client.
+ * Complete rewrite with:
+ * - Tree-sitter WASM for 100% AST accuracy (TypeScript, Python, PHP, Dart)
+ * - Zero native dependencies (no Visual Studio, node-gyp, or Python required)
+ * - 100% portable across Windows/Mac/Linux
+ * - Async-first architecture
+ * - Mandatory security boundaries
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-// Import handlers
-import { handleGetSemanticRepoMap, handleReadFileSurgical, handleAnalyzeImpact, handleReadFileLines, handleSearchCodePattern, } from "./handlers/readHandlers.js";
-import { handleWriteFileSurgical, handleInsertSymbol, handleRenameSymbol, handleRemoveSymbol, } from "./handlers/writeHandlers.js";
-import { handleRollbackFile, handleCleanBackups, } from "./handlers/utilHandlers.js";
-import { SERVER_NAME, SERVER_VERSION } from "./utils/constants.js";
-// ─── MCP Server Instance ────────────────────────────────────────────
+import { CodeContextEngine } from "./core/engine.js";
+import { ParserRegistry } from "./parsers/registry.js";
+import { SecurityValidator } from "./core/validator.js";
+import { replaceSymbol, insertCode, removeSymbol, writeFile } from "./operations/write.js";
+const SERVER_NAME = "mcp-code-context";
+const SERVER_VERSION = "3.0.3";
+// Global instances
+let engine;
+let registry;
 const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
-// ─── Tool Definitions ───────────────────────────────────────────────
 const TOOLS = [
     {
-        name: "get_semantic_repo_map",
-        description: "Generates a semantically compressed map of a code repository. " +
-            "Walks the directory tree respecting .gitignore rules, reads source files, " +
-            "and extracts only structural signatures (functions, classes, interfaces, types) " +
-            "while stripping implementation bodies. Returns an XML or Markdown document " +
-            "optimized for LLM consumption with minimal token usage. " +
-            "Supports TypeScript, JavaScript, PHP (AST-based), Dart, and Python. " +
-            "Use this to understand the architecture of a large codebase at a glance.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                directoryPath: {
-                    type: "string",
-                    description: "Absolute path to the repository root directory to analyze.",
-                },
-                format: {
-                    type: "string",
-                    enum: ["xml", "markdown"],
-                    description: "Output format for the repo map. 'xml' (default) provides structured data, " +
-                        "'markdown' provides human-readable output.",
-                },
-            },
-            required: ["directoryPath"],
-        },
-    },
-    {
-        name: "read_file_surgical",
-        description: "Reads the complete source code of a file, or surgically extracts only " +
-            "a specific named symbol (function, class, interface, method, type alias). " +
-            "When a symbol name is provided, only the full source code block for that " +
-            "symbol is returned — saving tokens compared to reading the entire file. " +
-            "Supports TypeScript, JavaScript, PHP, Dart, and Python files for symbol extraction.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the source file to read.",
-                },
-                symbolName: {
-                    type: "string",
-                    description: "Optional. Name of a specific function, class, interface, method, " +
-                        "or type alias to extract. If omitted, the entire file is returned.",
-                },
-                className: {
-                    type: "string",
-                    description: "Optional. Name of the class to scope the symbol search to. " +
-                        "Use this when multiple classes in the same file have methods with the same name " +
-                        "(e.g., multiple build() methods in Flutter). If omitted, returns the first match.",
-                },
-            },
-            required: ["filePath"],
-        },
-    },
-    {
-        name: "analyze_impact",
-        description: "Analyzes the impact of modifying a given file by discovering all other " +
-            "files in the repository that import or depend on it. Scans for ES import/export, " +
-            "CommonJS require(), Python import, PHP use/require_once/include, and Dart import statements. " +
-            "Returns a structured report listing all dependent files and the specific " +
-            "import statements that create the dependency. Essential for understanding " +
-            "blast radius before refactoring.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the file being modified (the dependency target).",
-                },
-                rootDir: {
-                    type: "string",
-                    description: "Optional. Absolute path to the repository root. If omitted, " +
-                        "the server walks up from filePath to find the nearest directory " +
-                        "containing package.json, .git, or similar root markers.",
-                },
-            },
-            required: ["filePath"],
-        },
-    },
-    {
-        name: "read_file_lines",
-        description: "Reads specific line ranges from a file without loading the entire content. " +
-            "Supports reading by exact line range (startLine/endLine) or around a pattern match. " +
-            "More efficient than read_file_surgical when you only need a small fragment of code. " +
-            "Perfect for debugging, viewing specific code blocks, or extracting context around errors.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the source file to read.",
-                },
-                startLine: {
-                    type: "number",
-                    description: "Starting line number (1-indexed). Required if using exact range mode.",
-                },
-                endLine: {
-                    type: "number",
-                    description: "Ending line number (1-indexed). Required if using exact range mode.",
-                },
-                aroundPattern: {
-                    type: "string",
-                    description: "Search pattern to find in the file. Returns lines around the first match. " +
-                        "Use this mode when you don't know the exact line numbers.",
-                },
-                contextLines: {
-                    type: "number",
-                    description: "Number of lines to include before and after the pattern match. " +
-                        "Defaults to 5. Only used with aroundPattern mode.",
-                },
-            },
-            required: ["filePath"],
-        },
-    },
-    {
-        name: "search_code_pattern",
-        description: "Searches for code patterns across multiple files in a repository. " +
-            "Returns matches with file paths, line numbers, and optional context lines. " +
-            "Respects .gitignore rules and allows filtering by file extensions. " +
-            "More efficient than manual grep when you need structured results with context.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                rootDir: {
-                    type: "string",
-                    description: "Absolute path to the repository root directory to search.",
-                },
-                pattern: {
-                    type: "string",
-                    description: "Regular expression pattern to search for. Use proper regex escaping " +
-                        "(e.g., 'widget\\\\.height' to match 'widget.height').",
-                },
-                fileExtensions: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Array of file extensions to search (e.g., ['.ts', '.dart', '.py']). " +
-                        "Defaults to common code extensions if omitted.",
-                },
-                excludeDirs: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Array of directory names to exclude (e.g., ['node_modules', 'dist']). " +
-                        "Defaults to common build/dependency directories.",
-                },
-                showContext: {
-                    type: "boolean",
-                    description: "If true, includes surrounding lines for each match. Defaults to true.",
-                },
-                contextLines: {
-                    type: "number",
-                    description: "Number of context lines before/after each match. Defaults to 3.",
-                },
-                maxResults: {
-                    type: "number",
-                    description: "Maximum number of matches to return. Defaults to 50.",
-                },
-            },
-            required: ["rootDir", "pattern"],
-        },
-    },
-    {
-        name: "write_file_surgical",
-        description: "Surgically replaces the full source code of a named symbol (function, class, " +
-            "method, interface, type alias) in a file. The AI provides ONLY the replacement " +
-            "code for that specific symbol — the tool handles locating it via AST parsing " +
-            "and splicing the replacement into the correct position. Supports TypeScript, " +
-            "JavaScript, PHP, Dart, and Python. Returns a unified diff of the changes. " +
-            "Supports dry-run mode to preview changes without modifying the file.",
+        name: "parse_file",
+        description: "Parse a file using Tree-sitter and extract symbols",
         inputSchema: {
             type: "object",
             properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the source file to modify.",
-                },
-                symbolName: {
-                    type: "string",
-                    description: "Name of the function, class, method, interface, or type alias to replace.",
-                },
-                newContent: {
-                    type: "string",
-                    description: "The complete replacement source code for the symbol, including its " +
-                        "signature and body. Must be syntactically valid for the target language.",
-                },
-                className: {
-                    type: "string",
-                    description: "Optional. Name of the class to scope the symbol search to. " +
-                        "Use when multiple classes have methods with the same name.",
-                },
-                confirmationToken: {
-                    type: "string",
-                    description: "Required for Phase 2. The token provided from the Phase 1 Dry-Run preview.",
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Required for Phase 2. Set to true to confirm and apply the changes.",
-                },
-                createBackup: {
-                    type: "boolean",
-                    description: "If true, creates a .bak copy of the file before modifying it. " +
-                        "Defaults to false (opt-in).",
-                },
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
             },
-            required: ["filePath", "symbolName", "newContent"],
+            required: ["filePath", "projectRoot"],
         },
     },
     {
-        name: "insert_symbol",
-        description: "Inserts new code at a precise location relative to an existing symbol in a file. " +
-            "Can insert before or after a symbol, or inside a class/interface at the start or end. " +
-            "If no anchor symbol is provided, inserts at the end of the file. " +
-            "Supports TypeScript, JavaScript, PHP, Dart, and Python. " +
-            "Automatically matches the surrounding indentation style.",
+        name: "replace_symbol",
+        description: "Replace a symbol (function/class/method) with new code",
         inputSchema: {
             type: "object",
             properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the source file to modify.",
-                },
-                code: {
-                    type: "string",
-                    description: "The new code to insert. Must be syntactically valid.",
-                },
-                anchorSymbol: {
-                    type: "string",
-                    description: "Name of an existing symbol to position relative to. " +
-                        "If omitted, code is inserted at the end of the file.",
-                },
-                position: {
-                    type: "string",
-                    enum: ["before", "after", "inside_start", "inside_end"],
-                    description: "Where to insert relative to the anchor. 'before' and 'after' insert " +
-                        "outside the symbol. 'inside_start' and 'inside_end' insert as members " +
-                        "inside a class or interface. Defaults to 'after'.",
-                },
-                className: {
-                    type: "string",
-                    description: "Optional. Name of the class to scope the anchor symbol search to. " +
-                        "Use when multiple classes have methods with the same name.",
-                },
-                confirmationToken: {
-                    type: "string",
-                    description: "Required for Phase 2. The token provided from the Phase 1 Dry-Run preview.",
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Required for Phase 2. Set to true to confirm and apply the changes.",
-                },
-                createBackup: {
-                    type: "boolean",
-                    description: "If true, backup the file before modifying.",
-                },
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
+                symbolName: { type: "string", description: "Symbol to replace" },
+                newContent: { type: "string", description: "New code" },
+                className: { type: "string", description: "Class name (optional, for scoping)" },
             },
-            required: ["filePath", "code"],
+            required: ["filePath", "projectRoot", "symbolName", "newContent"],
         },
     },
     {
-        name: "rename_symbol",
-        description: "Renames a symbol across an entire repository. Renames the definition in the " +
-            "source file AND updates all files that import or reference it. Uses AST-aware " +
-            "whole-word replacement to avoid false matches. Supports TypeScript, JavaScript, " +
-            "PHP, Dart, and Python. Returns a multi-file diff showing all changes. " +
-            "Essential for safe refactoring.",
+        name: "insert_code",
+        description: "Insert code at a specific location",
         inputSchema: {
             type: "object",
             properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the file where the symbol is defined.",
-                },
-                oldName: {
-                    type: "string",
-                    description: "The current name of the symbol.",
-                },
-                newName: {
-                    type: "string",
-                    description: "The new name for the symbol.",
-                },
-                rootDir: {
-                    type: "string",
-                    description: "Optional. Absolute path to the repository root. " +
-                        "If omitted, auto-detected from the file path.",
-                },
-                confirmationToken: {
-                    type: "string",
-                    description: "Required for Phase 2. The token provided from the Phase 1 Dry-Run preview.",
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Required for Phase 2. Set to true to confirm and apply the changes.",
-                },
-                createBackup: {
-                    type: "boolean",
-                    description: "If true, backup each modified file before changing it.",
-                },
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
+                code: { type: "string", description: "Code to insert" },
+                anchorSymbol: { type: "string", description: "Symbol to position relative to" },
+                position: { type: "string", enum: ["before", "after", "inside_start", "inside_end"], description: "Where to insert" },
+                className: { type: "string", description: "Class name (optional)" },
             },
-            required: ["filePath", "oldName", "newName"],
+            required: ["filePath", "projectRoot", "code"],
         },
     },
     {
         name: "remove_symbol",
-        description: "Removes a named symbol from a file. By default, checks for dependents first " +
-            "and refuses to remove if other files import or reference the symbol. " +
-            "Use force=true to skip the dependency check and remove anyway. " +
-            "Supports TypeScript, JavaScript, PHP, Dart, and Python. " +
-            "Returns a diff showing what was removed.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the source file.",
-                },
-                symbolName: {
-                    type: "string",
-                    description: "Name of the symbol to remove.",
-                },
-                className: {
-                    type: "string",
-                    description: "Optional. Name of the class to scope the symbol search to. " +
-                        "Use when multiple classes have methods with the same name.",
-                },
-                force: {
-                    type: "boolean",
-                    description: "If true, skip the dependency check and remove the symbol even if " +
-                        "other files reference it. Defaults to false.",
-                },
-                confirmationToken: {
-                    type: "string",
-                    description: "Required for Phase 2. The token provided from the Phase 1 Dry-Run preview.",
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Required for Phase 2. Set to true to confirm and apply the changes.",
-                },
-                createBackup: {
-                    type: "boolean",
-                    description: "If true, backup the file before modifying.",
-                },
-            },
-            required: ["filePath", "symbolName"],
-        },
-    },
-    {
-        name: "rollback_file",
-        description: "Reverts a file to a previous backup state after a surgical write operation. Keeps up to 5 automatic backups. Specify the number of steps to rollback (1 = most recent).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filePath: {
-                    type: "string",
-                    description: "Absolute path to the source file to revert.",
-                },
-                steps: {
-                    type: "number",
-                    description: "Number of steps back to revert to (1-5). Defaults to 1 (most recent backup).",
-                }
-            },
-            required: ["filePath"],
-        },
-    },
-    {
-        name: "clean_backups",
-        description: "Removes all backup files for a project. Deletes the entire .mcp-backups directory " +
-            "at the project root, freeing up disk space and cleaning the working directory. " +
-            "Use this to clean up after completing a series of edits or when backups are no longer needed.",
+        description: "Remove a symbol from file",
         inputSchema: {
             type: "object",
             properties: {
-                projectRoot: {
-                    type: "string",
-                    description: "Absolute path to the project root directory. The .mcp-backups folder " +
-                        "at this location will be removed.",
-                },
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
+                symbolName: { type: "string", description: "Symbol to remove" },
+                className: { type: "string", description: "Class name (optional)" },
             },
-            required: ["projectRoot"],
+            required: ["filePath", "projectRoot", "symbolName"],
         },
     },
 ];
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS,
 }));
-// ─── Tool Dispatcher ────────────────────────────────────────────────
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
-            // Read tools
-            case "get_semantic_repo_map":
-                return await handleGetSemanticRepoMap(args);
-            case "read_file_surgical":
-                return await handleReadFileSurgical(args);
-            case "analyze_impact":
-                return await handleAnalyzeImpact(args);
-            case "read_file_lines":
-                return await handleReadFileLines(args);
-            case "search_code_pattern":
-                return await handleSearchCodePattern(args);
-            // Write tools
-            case "write_file_surgical":
-                return await handleWriteFileSurgical(args);
-            case "insert_symbol":
-                return await handleInsertSymbol(args);
-            case "rename_symbol":
-                return await handleRenameSymbol(args);
+            case "parse_file":
+                return await handleParseFile(args);
+            case "replace_symbol":
+                return await handleReplaceSymbol(args);
+            case "insert_code":
+                return await handleInsertCode(args);
             case "remove_symbol":
                 return await handleRemoveSymbol(args);
-            // Util tools
-            case "rollback_file":
-                return await handleRollbackFile(args);
-            case "clean_backups":
-                return await handleCleanBackups(args);
             default:
                 return errorResponse(`Unknown tool: "${name}"`);
         }
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return errorResponse(`Unhandled error in tool "${name}": ${message}`);
+        return errorResponse(`Error in tool "${name}": ${message}`);
     }
 });
-// ─── Utility ────────────────────────────────────────────────────────
+async function handleParseFile(args) {
+    const filePath = args.filePath;
+    const projectRoot = args.projectRoot;
+    if (!filePath)
+        return errorResponse("Missing required parameter: filePath");
+    if (!projectRoot)
+        return errorResponse("Missing required parameter: projectRoot");
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (!validation.valid) {
+        return errorResponse(validation.error);
+    }
+    const fs = await import("node:fs/promises");
+    const content = await fs.readFile(validation.resolvedPath, "utf-8");
+    const path = await import("node:path");
+    const ext = path.extname(validation.resolvedPath);
+    const parser = registry.getParser(ext);
+    if (!parser) {
+        return errorResponse(`No parser available for extension: ${ext}`);
+    }
+    const tree = parser.parse(content);
+    const symbols = parser.findSymbols(tree);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ file: filePath, symbols }, null, 2),
+            },
+        ],
+    };
+}
+async function handleReplaceSymbol(args) {
+    const filePath = args.filePath;
+    const projectRoot = args.projectRoot;
+    const symbolName = args.symbolName;
+    const newContent = args.newContent;
+    const className = args.className;
+    if (!filePath)
+        return errorResponse("Missing: filePath");
+    if (!projectRoot)
+        return errorResponse("Missing: projectRoot");
+    if (!symbolName)
+        return errorResponse("Missing: symbolName");
+    if (!newContent)
+        return errorResponse("Missing: newContent");
+    const path = await import("node:path");
+    const ext = path.extname(filePath);
+    const parser = registry.getParser(ext);
+    if (!parser)
+        return errorResponse(`No parser for: ${ext}`);
+    const result = await replaceSymbol({ filePath, projectRoot, symbolName, newContent, className, parser });
+    if (!result.success) {
+        return errorResponse(result.error);
+    }
+    // Write to file
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (validation.valid) {
+        await writeFile(validation.resolvedPath, result.newContent);
+    }
+    return {
+        content: [{ type: "text", text: `✅ Replaced "${symbolName}"\n\n${result.diff}` }],
+    };
+}
+async function handleInsertCode(args) {
+    const filePath = args.filePath;
+    const projectRoot = args.projectRoot;
+    const code = args.code;
+    const anchorSymbol = args.anchorSymbol;
+    const position = args.position;
+    const className = args.className;
+    if (!filePath)
+        return errorResponse("Missing: filePath");
+    if (!projectRoot)
+        return errorResponse("Missing: projectRoot");
+    if (!code)
+        return errorResponse("Missing: code");
+    const path = await import("node:path");
+    const ext = path.extname(filePath);
+    const parser = registry.getParser(ext);
+    if (!parser)
+        return errorResponse(`No parser for: ${ext}`);
+    const result = await insertCode({ filePath, projectRoot, code, anchorSymbol, position, className, parser });
+    if (!result.success) {
+        return errorResponse(result.error);
+    }
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (validation.valid) {
+        await writeFile(validation.resolvedPath, result.newContent);
+    }
+    return {
+        content: [{ type: "text", text: `✅ Code inserted\n\n${result.diff}` }],
+    };
+}
+async function handleRemoveSymbol(args) {
+    const filePath = args.filePath;
+    const projectRoot = args.projectRoot;
+    const symbolName = args.symbolName;
+    const className = args.className;
+    if (!filePath)
+        return errorResponse("Missing: filePath");
+    if (!projectRoot)
+        return errorResponse("Missing: projectRoot");
+    if (!symbolName)
+        return errorResponse("Missing: symbolName");
+    const path = await import("node:path");
+    const ext = path.extname(filePath);
+    const parser = registry.getParser(ext);
+    if (!parser)
+        return errorResponse(`No parser for: ${ext}`);
+    const result = await removeSymbol({ filePath, projectRoot, symbolName, className, parser });
+    if (!result.success) {
+        return errorResponse(result.error);
+    }
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (validation.valid) {
+        await writeFile(validation.resolvedPath, result.newContent);
+    }
+    return {
+        content: [{ type: "text", text: `✅ Removed "${symbolName}"\n\n${result.diff}` }],
+    };
+}
 function errorResponse(message) {
     return {
         content: [{ type: "text", text: `❌ ${message}` }],
         isError: true,
     };
 }
-// ─── Bootstrap ──────────────────────────────────────────────────────
 async function main() {
+    console.error("🚀 Initializing mcp-code-context v3.0.4 (WASM)...");
+    engine = new CodeContextEngine();
+    await engine.init();
+    registry = new ParserRegistry(engine);
+    await registry.init();
+    console.error("✅ Engine initialized with Tree-sitter WASM (portable)");
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`🚀 ${SERVER_NAME} v${SERVER_VERSION} running on stdio transport`);
+    console.error(`🚀 ${SERVER_NAME} v${SERVER_VERSION} running on stdio`);
 }
 import { pathToFileURL } from "node:url";
 if (import.meta.url === pathToFileURL(process.argv[1]).href) {