mcp-code-context 3.0.6 → 3.4.0

package/dist/src/index.js

@@ -1,28 +1,113 @@
 #!/usr/bin/env node
 /**
- * mcp-code-context v3.0.6 - Tree-sitter WASM Edition
+ * mcp-code-context v3.4.0 - Tree-sitter WASM Edition
  *
- * Complete rewrite with:
+ * Production-ready 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
+ * - Zero native dependencies — 100% portable across Windows/Mac/Linux
+ * - Two-phase write workflow (dry-run + confirmation token)
+ * - Middleware pipeline: rate limiting, file locking, audit logging, telemetry
+ * - Mandatory security boundaries on ALL handlers
  */
 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 * as path from "node:path";
 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";
+import { replaceSymbol, insertCode, removeSymbol, writeFile, renameSymbol } from "./operations/write.js";
+import { extractSymbol, readLines, searchPattern, analyzeImpact } from "./operations/read.js";
+import { compressRepository } from "./operations/compress.js";
+import { globalConfirmationStore } from "./operations/confirmationStore.js";
+import { globalAuditLogger } from "./utils/auditLogger.js";
+import { globalTelemetry } from "./utils/telemetry.js";
+import { RateLimiter, OPERATION_COSTS } from "./utils/rateLimiter.js";
+import { globalLockManager } from "./utils/fileLock.js";
+import { streamFile } from "./utils/streaming.js";
+import { BackupManager } from "./utils/backupManager.js";
+import * as fs from "node:fs/promises";
 const SERVER_NAME = "mcp-code-context";
-const SERVER_VERSION = "3.0.6";
+const SERVER_VERSION = "3.4.0";
 // Global instances
 let engine;
 let registry;
-const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+const rateLimiter = new RateLimiter();
+// Write operations that require file locking and two-phase workflow
+const WRITE_OPS = new Set(["replace_symbol", "insert_symbol", "remove_symbol", "rename_symbol"]);
 const TOOLS = [
+    {
+        name: "get_semantic_repo_map",
+        description: "Generate a compressed architectural overview of an entire repository",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directoryPath: { type: "string", description: "Absolute path to repository root" },
+                projectRoot: { type: "string", description: "Project root for security boundary" },
+                format: { type: "string", enum: ["xml", "markdown"], description: "Output format (default: xml)" },
+            },
+            required: ["directoryPath", "projectRoot"],
+        },
+    },
+    {
+        name: "read_file_surgical",
+        description: "Read a file or extract a specific named symbol",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
+                symbolName: { type: "string", description: "Symbol name to extract (optional)" },
+                className: { type: "string", description: "Class name for scoping (optional)" },
+            },
+            required: ["filePath", "projectRoot"],
+        },
+    },
+    {
+        name: "analyze_impact",
+        description: "Find all files that depend on a given file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root for security boundary" },
+                rootDir: { type: "string", description: "Repository root (optional, defaults to projectRoot)" },
+            },
+            required: ["filePath", "projectRoot"],
+        },
+    },
+    {
+        name: "read_file_lines",
+        description: "Read specific line ranges from a file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root for security boundary" },
+                startLine: { type: "number", description: "Starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Ending line number (1-indexed)" },
+                aroundPattern: { type: "string", description: "Search pattern to find and return surrounding lines" },
+                contextLines: { type: "number", description: "Number of lines before/after pattern (default: 5)" },
+            },
+            required: ["filePath", "projectRoot"],
+        },
+    },
+    {
+        name: "search_code_pattern",
+        description: "Search for code patterns across multiple files",
+        inputSchema: {
+            type: "object",
+            properties: {
+                rootDir: { type: "string", description: "Repository root directory" },
+                projectRoot: { type: "string", description: "Project root for security boundary" },
+                pattern: { type: "string", description: "Regular expression pattern to search" },
+                fileExtensions: { type: "array", items: { type: "string" }, description: "Extensions to search" },
+                excludeDirs: { type: "array", items: { type: "string" }, description: "Directories to exclude" },
+                maxResults: { type: "number", description: "Maximum matches to return (default: 50)" },
+            },
+            required: ["rootDir", "projectRoot", "pattern"],
+        },
+    },
     {
         name: "parse_file",
         description: "Parse a file using Tree-sitter and extract symbols",
@@ -36,8 +121,8 @@ const TOOLS = [
         },
     },
     {
-        name: "replace_symbol",
-        description: "Replace a symbol (function/class/method) with new code",
+        name: "write_file_surgical",
+        description: "Replace a symbol with new code. Phase 1 (dry-run): returns diff + token. Phase 2: confirm with token to apply.",
         inputSchema: {
             type: "object",
             properties: {
@@ -46,13 +131,15 @@ const TOOLS = [
                 symbolName: { type: "string", description: "Symbol to replace" },
                 newContent: { type: "string", description: "New code" },
                 className: { type: "string", description: "Class name (optional, for scoping)" },
+                confirm: { type: "boolean", description: "Set true to apply a pending operation" },
+                confirmationToken: { type: "string", description: "Token from Phase 1 dry-run" },
             },
             required: ["filePath", "projectRoot", "symbolName", "newContent"],
         },
     },
     {
-        name: "insert_code",
-        description: "Insert code at a specific location",
+        name: "insert_symbol",
+        description: "Insert code at a specific location. Phase 1: returns diff + token. Phase 2: confirm with token to apply.",
         inputSchema: {
             type: "object",
             properties: {
@@ -62,13 +149,15 @@ const TOOLS = [
                 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)" },
+                confirm: { type: "boolean", description: "Set true to apply a pending operation" },
+                confirmationToken: { type: "string", description: "Token from Phase 1 dry-run" },
             },
             required: ["filePath", "projectRoot", "code"],
         },
     },
     {
         name: "remove_symbol",
-        description: "Remove a symbol from file",
+        description: "Remove a symbol from file. Phase 1: returns diff + token. Phase 2: confirm with token to apply.",
         inputSchema: {
             type: "object",
             properties: {
@@ -76,181 +165,433 @@ const TOOLS = [
                 projectRoot: { type: "string", description: "Project root (REQUIRED)" },
                 symbolName: { type: "string", description: "Symbol to remove" },
                 className: { type: "string", description: "Class name (optional)" },
+                force: { type: "boolean", description: "Skip dependency check" },
+                confirm: { type: "boolean", description: "Set true to apply a pending operation" },
+                confirmationToken: { type: "string", description: "Token from Phase 1 dry-run" },
             },
             required: ["filePath", "projectRoot", "symbolName"],
         },
     },
+    {
+        name: "rename_symbol",
+        description: "Rename a symbol across the entire repository. Phase 1: returns diff + token. Phase 2: confirm with token to apply.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "File where symbol is defined" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
+                oldName: { type: "string", description: "Current name" },
+                newName: { type: "string", description: "New name" },
+                rootDir: { type: "string", description: "Repository root (optional)" },
+                confirm: { type: "boolean", description: "Set true to apply a pending operation" },
+                confirmationToken: { type: "string", description: "Token from Phase 1 dry-run" },
+            },
+            required: ["filePath", "projectRoot", "oldName", "newName"],
+        },
+    },
+    {
+        name: "rollback_file",
+        description: "Revert a file to its backup state",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Absolute path to file" },
+                projectRoot: { type: "string", description: "Project root (REQUIRED)" },
+            },
+            required: ["filePath", "projectRoot"],
+        },
+    },
+    {
+        name: "clean_backups",
+        description: "Remove all backup files for a project",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectRoot: { type: "string", description: "Project root directory" },
+            },
+            required: ["projectRoot"],
+        },
+    },
+    {
+        name: "get_server_stats",
+        description: "Get server telemetry, audit statistics, and health metrics",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
 ];
+const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS,
 }));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        switch (name) {
-            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);
-            default:
-                return errorResponse(`Unknown tool: "${name}"`);
-        }
+// Setup connection and initialize engine
+async function main() {
+    engine = new CodeContextEngine();
+    await engine.init();
+    registry = new ParserRegistry(engine);
+    await registry.init();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[${SERVER_NAME}] v${SERVER_VERSION} running on stdio`);
+}
+// -----------------------------------------------------------------------------
+// READ HANDLERS
+// -----------------------------------------------------------------------------
+async function handleGetSemanticRepoMap(args) {
+    const directoryPath = String(args.directoryPath);
+    const projectRoot = String(args.projectRoot);
+    const format = args.format === "markdown" ? "markdown" : "xml";
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(directoryPath);
+    if (!validation.valid) {
+        throw new Error(validation.error);
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return errorResponse(`Error in tool "${name}": ${message}`);
+    const result = await compressRepository({
+        directoryPath: validation.resolvedPath,
+        registry,
+        format: format
+    });
+    return {
+        content: [{ type: "text", text: result }],
+    };
+}
+async function handleReadFileSurgical(args) {
+    const filePath = String(args.filePath);
+    const projectRoot = String(args.projectRoot);
+    const symbolName = args.symbolName ? String(args.symbolName) : undefined;
+    const className = args.className ? String(args.className) : undefined;
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (!validation.valid)
+        throw new Error(validation.error);
+    let content;
+    if (symbolName) {
+        const ext = path.extname(filePath);
+        const parser = registry.getParser(ext);
+        if (!parser)
+            throw new Error(`No parser available for ${ext} files`);
+        const result = await extractSymbol({ filePath: validation.resolvedPath, projectRoot, symbolName, className, parser });
+        if (!result.success)
+            throw new Error(result.error);
+        content = result.content;
     }
-});
+    else {
+        // If > 5MB, stream it to avoid memory issues
+        const stat = await fs.stat(validation.resolvedPath);
+        if (stat.size > 5 * 1024 * 1024) {
+            const streamRes = await streamFile(validation.resolvedPath);
+            if (!streamRes.success)
+                throw new Error(streamRes.error);
+            content = streamRes.chunks.join("");
+        }
+        else {
+            content = await fs.readFile(validation.resolvedPath, "utf-8");
+        }
+    }
+    return { content: [{ type: "text", text: content }] };
+}
+async function handleAnalyzeImpact(args) {
+    const filePath = String(args.filePath);
+    const projectRoot = String(args.projectRoot);
+    const rootDir = args.rootDir ? String(args.rootDir) : projectRoot;
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (!validation.valid)
+        throw new Error(validation.error);
+    const rootValidation = await validator.validateFilePath(rootDir);
+    if (!rootValidation.valid)
+        throw new Error(rootValidation.error);
+    const result = await analyzeImpact({ filePath: validation.resolvedPath, rootDir: rootValidation.resolvedPath });
+    if (!result.success)
+        throw new Error(result.error);
+    return { content: [{ type: "text", text: result.content }] };
+}
+async function handleReadFileLines(args) {
+    const filePath = String(args.filePath);
+    const projectRoot = String(args.projectRoot);
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(filePath);
+    if (!validation.valid)
+        throw new Error(validation.error);
+    const result = await readLines({
+        filePath: validation.resolvedPath,
+        startLine: args.startLine,
+        endLine: args.endLine,
+        aroundPattern: args.aroundPattern,
+        contextLines: args.contextLines,
+    });
+    if (!result.success)
+        throw new Error(result.error);
+    return { content: [{ type: "text", text: result.content }] };
+}
+async function handleSearchCodePattern(args) {
+    const rootDir = String(args.rootDir);
+    const projectRoot = String(args.projectRoot);
+    const validator = new SecurityValidator(projectRoot);
+    const validation = await validator.validateFilePath(rootDir);
+    if (!validation.valid)
+        throw new Error(validation.error);
+    const result = await searchPattern({
+        rootDir: validation.resolvedPath,
+        pattern: String(args.pattern),
+        fileExtensions: args.fileExtensions,
+        excludeDirs: args.excludeDirs,
+        maxResults: args.maxResults,
+    });
+    if (!result.success)
+        throw new Error(result.error);
+    return { content: [{ type: "text", text: result.content }] };
+}
 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 filePath = String(args.filePath);
+    const projectRoot = String(args.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");
+    if (!validation.valid)
+        throw new Error(validation.error);
     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}`);
-    }
+    if (!parser)
+        throw new Error(`No parser available for ${ext} files`);
     const tree = parser.parse(content);
     const symbols = parser.findSymbols(tree);
     return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ file: filePath, symbols }, null, 2),
-            },
-        ],
+        content: [{ type: "text", text: JSON.stringify(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);
+// -----------------------------------------------------------------------------
+// WRITE HANDLERS (Two-Phase)
+// -----------------------------------------------------------------------------
+async function handleTwoPhaseWrite(args, operationName, executeWrite) {
+    const confirm = Boolean(args.confirm);
+    const token = args.confirmationToken ? String(args.confirmationToken) : undefined;
+    if (confirm) {
+        if (!token)
+            throw new Error("confirmationToken is required when confirm=true");
+        const pendingOp = globalConfirmationStore.consumePending(token);
+        if (!pendingOp)
+            throw new Error(`Invalid or expired confirmation token: ${token}`);
+        // Create backup before applying
+        await BackupManager.createBackup(pendingOp.filePath, String(args.projectRoot));
+        // Apply the write
+        await writeFile(pendingOp.filePath, pendingOp.newContent);
+        return {
+            content: [{ type: "text", text: `Success. Changes applied to ${pendingOp.filePath}\n\nDiff:\n${pendingOp.diff}` }],
+        };
     }
+    // Phase 1: Dry-run
+    const result = await executeWrite();
+    if (!result.success)
+        throw new Error(result.error);
+    const newToken = globalConfirmationStore.storePending({
+        filePath: String(args.filePath),
+        operation: operationName,
+        symbolName: args.symbolName ? String(args.symbolName) : undefined,
+        newContent: result.newContent,
+        diff: result.diff,
+    });
     return {
-        content: [{ type: "text", text: `✅ Replaced "${symbolName}"\n\n${result.diff}` }],
+        content: [{
+                type: "text",
+                text: `DRY RUN SUCCESSFUL. Please review the diff below.\nTo apply these changes, call this tool again with confirm=true and confirmationToken="${newToken}"\n\nDiff:\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 handleWriteFileSurgical(args) {
+    return handleTwoPhaseWrite(args, "write_file_surgical", async () => {
+        const ext = path.extname(String(args.filePath));
+        const parser = registry.getParser(ext);
+        if (!parser)
+            throw new Error(`No parser available for ${ext} files`);
+        return await replaceSymbol({
+            filePath: String(args.filePath),
+            projectRoot: String(args.projectRoot),
+            symbolName: String(args.symbolName),
+            newContent: String(args.newContent),
+            className: args.className ? String(args.className) : undefined,
+            parser,
+        });
+    });
+}
+async function handleInsertSymbol(args) {
+    return handleTwoPhaseWrite(args, "insert_symbol", async () => {
+        const ext = path.extname(String(args.filePath));
+        const parser = registry.getParser(ext);
+        if (!parser)
+            throw new Error(`No parser available for ${ext} files`);
+        return await insertCode({
+            filePath: String(args.filePath),
+            projectRoot: String(args.projectRoot),
+            code: String(args.code),
+            anchorSymbol: args.anchorSymbol ? String(args.anchorSymbol) : undefined,
+            position: args.position,
+            className: args.className ? String(args.className) : undefined,
+            parser,
+        });
+    });
 }
 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);
-    }
+    return handleTwoPhaseWrite(args, "remove_symbol", async () => {
+        const ext = path.extname(String(args.filePath));
+        const parser = registry.getParser(ext);
+        if (!parser)
+            throw new Error(`No parser available for ${ext} files`);
+        return await removeSymbol({
+            filePath: String(args.filePath),
+            projectRoot: String(args.projectRoot),
+            symbolName: String(args.symbolName),
+            className: args.className ? String(args.className) : undefined,
+            parser,
+        });
+    });
+}
+async function handleRenameSymbol(args) {
+    return handleTwoPhaseWrite(args, "rename_symbol", async () => {
+        const ext = path.extname(String(args.filePath));
+        const parser = registry.getParser(ext);
+        if (!parser)
+            throw new Error(`No parser available for ${ext} files`);
+        return await renameSymbol({
+            filePath: String(args.filePath),
+            projectRoot: String(args.projectRoot),
+            oldName: String(args.oldName),
+            newName: String(args.newName),
+            rootDir: args.rootDir ? String(args.rootDir) : String(args.projectRoot),
+            parser,
+        });
+    });
+}
+// -----------------------------------------------------------------------------
+// OTHER HANDLERS
+// -----------------------------------------------------------------------------
+async function handleRollbackFile(args) {
+    const filePath = String(args.filePath);
+    const projectRoot = String(args.projectRoot);
+    const steps = args.steps ? Number(args.steps) : 1;
     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}` }],
-    };
+    if (!validation.valid)
+        throw new Error(validation.error);
+    const result = await BackupManager.rollback(validation.resolvedPath, projectRoot, steps);
+    if (!result.success)
+        throw new Error(result.error);
+    return { content: [{ type: "text", text: `Successfully rolled back ${path.basename(filePath)} from backup: ${result.restoredFrom}` }] };
 }
-function errorResponse(message) {
+async function handleCleanBackups(args) {
+    const projectRoot = String(args.projectRoot);
+    const validator = new SecurityValidator(projectRoot);
+    // Just validate projectRoot is a valid directory
+    const validation = await validator.validateFilePath(projectRoot);
+    if (!validation.valid)
+        throw new Error(validation.error);
+    const result = await BackupManager.clean(projectRoot);
+    if (!result.success)
+        throw new Error(result.error);
+    return { content: [{ type: "text", text: `Successfully cleaned backups. Deleted ${result.deletedCount} backup files.` }] };
+}
+async function handleGetServerStats() {
+    const stats = {
+        pendingConfirmations: globalConfirmationStore.getPendingCount(),
+        // Telemetry and audit stats can be exposed here later
+    };
     return {
-        content: [{ type: "text", text: `❌ ${message}` }],
-        isError: true,
+        content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
     };
 }
-async function main() {
-    console.error("🚀 Initializing mcp-code-context v3.0.6 (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`);
-}
-import { pathToFileURL } from "node:url";
-if (import.meta.url === pathToFileURL(process.argv[1]).href) {
-    main().catch((error) => {
-        console.error("Fatal error starting MCP server:", error);
-        process.exit(1);
-    });
-}
+// -----------------------------------------------------------------------------
+// PIPELINE & MAIN EXECUTION
+// -----------------------------------------------------------------------------
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const startTime = Date.now();
+    let success = false;
+    let lockReleased = false;
+    try {
+        // 1. Rate Limiting Middleware
+        const cost = OPERATION_COSTS[name] ?? 1;
+        const rateCheck = await rateLimiter.checkLimit(name, cost);
+        if (!rateCheck.allowed) {
+            throw new Error(`Rate limit exceeded for tool: ${name}. Retry after ${rateCheck.retryAfter}ms`);
+        }
+        // 2. File Locking Middleware (for writes only)
+        if (WRITE_OPS.has(name) && args && args.filePath) {
+            await globalLockManager.acquireLock(String(args.filePath), "mcp-client", name);
+        }
+        // 3. Execution
+        let result;
+        switch (name) {
+            case "get_semantic_repo_map":
+                result = await handleGetSemanticRepoMap(args);
+                break;
+            case "read_file_surgical":
+                result = await handleReadFileSurgical(args);
+                break;
+            case "analyze_impact":
+                result = await handleAnalyzeImpact(args);
+                break;
+            case "read_file_lines":
+                result = await handleReadFileLines(args);
+                break;
+            case "search_code_pattern":
+                result = await handleSearchCodePattern(args);
+                break;
+            case "parse_file":
+                result = await handleParseFile(args);
+                break;
+            case "write_file_surgical":
+                result = await handleWriteFileSurgical(args);
+                break;
+            case "insert_symbol":
+                result = await handleInsertSymbol(args);
+                break;
+            case "remove_symbol":
+                result = await handleRemoveSymbol(args);
+                break;
+            case "rename_symbol":
+                result = await handleRenameSymbol(args);
+                break;
+            case "rollback_file":
+                result = await handleRollbackFile(args);
+                break;
+            case "clean_backups":
+                result = await handleCleanBackups(args);
+                break;
+            case "get_server_stats":
+                result = await handleGetServerStats();
+                break;
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        success = true;
+        return result;
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error executing ${name}: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+    finally {
+        const duration = Date.now() - startTime;
+        // 4. File Lock Release
+        if (WRITE_OPS.has(name) && args && args.filePath && !lockReleased) {
+            globalLockManager.releaseLock(String(args.filePath), "mcp-client");
+            lockReleased = true;
+        }
+        // 5. Telemetry & Audit Logging Middleware
+        globalTelemetry.recordOperation({ toolName: name, duration, success });
+        globalAuditLogger.log({
+            level: success ? "info" : "error",
+            operation: name,
+            details: args ? args : {},
+            result: success ? "success" : "failure"
+        });
+    }
+});
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});
 //# sourceMappingURL=index.js.map