mcp-lsp-driver 0.0.1

package/dist/server.js

@@ -0,0 +1,557 @@
+/**
+ * MCP Server Implementation for LSP Driver SDK
+ *
+ * The SDK automatically registers tools based on which capability providers
+ * are defined in the IdeCapabilities configuration.
+ */
+import { ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { formatDiagnosticsAsMarkdown, formatSymbolsAsMarkdown, generateEditId, makeToolResult, normalizeUri, } from './formatting.js';
+import { SymbolResolutionError, SymbolResolver, } from './resolver.js';
+import { ApplyEditSchema, CallHierarchySchema, FuzzyPositionSchema, GlobalFindSchema, GlobalReplaceSchema, } from './schemas.js';
+/**
+ * Register LSP-based tools and resources on the provided MCP server.
+ */
+export function installMcpLspDriver({ server, capabilities, config, }) {
+    const resolver = new SymbolResolver(capabilities.fileAccess, config?.resolverConfig);
+    try {
+        registerTools(server, capabilities, resolver);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error,
+            reason: 'Error occured during registration of tools',
+        };
+    }
+    try {
+        registerResources(server, capabilities);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error,
+            reason: 'Error occured during registration of resources',
+        };
+    }
+    return {
+        success: true,
+    };
+}
+function registerTools(server, capabilities, resolver) {
+    if (capabilities.definition) {
+        registerGotoDefinitionTool(server, capabilities, resolver);
+    }
+    if (capabilities.references) {
+        registerFindReferencesTool(server, capabilities, resolver);
+    }
+    if (capabilities.hierarchy) {
+        registerCallHierarchyTool(server, capabilities, resolver);
+    }
+    if (capabilities.userInteraction) {
+        registerApplyEditTool(server, capabilities, resolver);
+    }
+    if (capabilities.globalFind) {
+        registerGlobalFindTool(server, capabilities);
+        registerGlobalReplaceTool(server, capabilities);
+    }
+}
+function registerResources(server, capabilities) {
+    if (capabilities.diagnostics) {
+        registerDiagnosticsResources(server, capabilities);
+    }
+    if (capabilities.outline) {
+        registerOutlineResource(server, capabilities);
+    }
+    if (capabilities.filesystem) {
+        registerFilesystemResource(server, capabilities);
+    }
+}
+/**
+ * Registers the goto_definition tool.
+ */
+function registerGotoDefinitionTool(server, capabilities, resolver) {
+    const definitionProvider = capabilities.definition;
+    if (!definitionProvider)
+        return;
+    server.registerTool('goto_definition', {
+        description: 'Navigate to the definition of a symbol.',
+        inputSchema: FuzzyPositionSchema,
+        outputSchema: {
+            snippets: z.array(z.object({
+                uri: z.string(),
+                startLine: z.number(),
+                endLine: z.number(),
+                content: z.string(),
+            })),
+        },
+    }, async (params) => {
+        try {
+            const uri = normalizeUri(params.uri);
+            const fuzzy = {
+                symbolName: params.symbol_name,
+                lineHint: params.line_hint,
+                orderHint: params.order_hint,
+            };
+            const exactPosition = await resolver.resolvePosition(uri, fuzzy);
+            const snippets = (await definitionProvider.provideDefinition(uri, exactPosition)).map((snippet) => ({
+                uri: snippet.uri,
+                startLine: snippet.range.start.line + 1,
+                endLine: snippet.range.end.line + 1,
+                content: snippet.content,
+            }));
+            return makeToolResult({ snippets });
+        }
+        catch (error) {
+            const message = error instanceof SymbolResolutionError
+                ? error.message
+                : `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                structuredContent: { error: message },
+                isError: true,
+            };
+        }
+    });
+}
+/**
+ * Registers the find_references tool.
+ */
+function registerFindReferencesTool(server, capabilities, resolver) {
+    const referencesProvider = capabilities.references;
+    if (!referencesProvider)
+        return;
+    server.registerTool('find_references', {
+        description: 'Find all references to a symbol. Returns a list of locations where the symbol is used.',
+        inputSchema: FuzzyPositionSchema,
+        outputSchema: {
+            snippets: z.array(z.object({
+                uri: z.string(),
+                startLine: z.number(),
+                endLine: z.number(),
+                content: z.string(),
+            })),
+        },
+    }, async (params) => {
+        try {
+            const uri = normalizeUri(params.uri);
+            const fuzzy = {
+                symbolName: params.symbol_name,
+                lineHint: params.line_hint,
+                orderHint: params.order_hint,
+            };
+            const exactPosition = await resolver.resolvePosition(uri, fuzzy);
+            const snippets = (await referencesProvider.provideReferences(uri, exactPosition)).map((snippet) => ({
+                uri: snippet.uri,
+                startLine: snippet.range.start.line + 1,
+                endLine: snippet.range.end.line + 1,
+                content: snippet.content,
+            }));
+            return makeToolResult({ snippets });
+        }
+        catch (error) {
+            const message = error instanceof SymbolResolutionError
+                ? error.message
+                : `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                structuredContent: { error: message },
+                isError: true,
+            };
+        }
+    });
+}
+/**
+ * Registers the call_hierarchy tool.
+ */
+function registerCallHierarchyTool(server, capabilities, resolver) {
+    const hierarchyProvider = capabilities.hierarchy;
+    if (!hierarchyProvider)
+        return;
+    server.registerTool('call_hierarchy', {
+        description: 'Get call hierarchy for a function or method. Shows incoming or outgoing calls.',
+        inputSchema: CallHierarchySchema,
+        outputSchema: {
+            snippets: z.array(z.object({
+                uri: z.string(),
+                startLine: z.number(),
+                endLine: z.number(),
+                content: z.string(),
+            })),
+        },
+    }, async (params) => {
+        try {
+            const uri = normalizeUri(params.uri);
+            const fuzzy = {
+                symbolName: params.symbol_name,
+                lineHint: params.line_hint,
+                orderHint: params.order_hint,
+            };
+            const exactPosition = await resolver.resolvePosition(uri, fuzzy);
+            const snippets = (await hierarchyProvider.provideCallHierarchy(uri, exactPosition, params.direction)).map((snippet) => ({
+                uri: snippet.uri,
+                startLine: snippet.range.start.line + 1,
+                endLine: snippet.range.end.line + 1,
+                content: snippet.content,
+            }));
+            return makeToolResult({ snippets });
+        }
+        catch (error) {
+            const message = error instanceof SymbolResolutionError
+                ? error.message
+                : `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                structuredContent: { error: message },
+                isError: true,
+            };
+        }
+    });
+}
+/**
+ * Registers diagnostics resources.
+ * - lsp://diagnostics/{path} - diagnostics for a specific file
+ * - lsp://diagnostics/workspace - diagnostics for the entire workspace (if getWorkspaceDiagnostics is provided)
+ */
+function registerDiagnosticsResources(server, capabilities) {
+    const diagnosticsProvider = capabilities.diagnostics;
+    if (!diagnosticsProvider)
+        return;
+    // Register file diagnostics resource template
+    const fileDiagnosticsTemplate = new ResourceTemplate('lsp://diagnostics/{+path}', {
+        list: undefined, // Cannot enumerate all files with diagnostics
+    });
+    server.registerResource('file-diagnostics', fileDiagnosticsTemplate, {
+        description: 'Diagnostics (errors, warnings, hints) for a specific file. Use the file path after lsp://diagnostics/',
+        mimeType: 'text/markdown',
+    }, async (_uri, variables) => {
+        try {
+            const path = variables.path;
+            const normalizedPath = normalizeUri(path);
+            const diagnostics = await diagnosticsProvider.provideDiagnostics(normalizedPath);
+            const markdown = formatDiagnosticsAsMarkdown(diagnostics);
+            return {
+                contents: [
+                    {
+                        uri: `lsp://diagnostics/${path}`,
+                        mimeType: 'text/markdown',
+                        text: markdown,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                contents: [
+                    {
+                        uri: `lsp://diagnostics/${variables.path}`,
+                        mimeType: 'text/markdown',
+                        text: message,
+                    },
+                ],
+            };
+        }
+    });
+    // Register workspace diagnostics resource if getWorkspaceDiagnostics is provided
+    if (diagnosticsProvider.getWorkspaceDiagnostics) {
+        const getWorkspaceDiagnostics = diagnosticsProvider.getWorkspaceDiagnostics.bind(diagnosticsProvider);
+        server.registerResource('workspace-diagnostics', 'lsp://diagnostics/workspace', {
+            description: 'All diagnostics (errors, warnings, hints) across the entire workspace',
+            mimeType: 'text/markdown',
+        }, async () => {
+            try {
+                const diagnostics = await getWorkspaceDiagnostics();
+                // Group diagnostics by file
+                const groupedByFile = new Map();
+                for (const d of diagnostics) {
+                    const existing = groupedByFile.get(d.uri) ?? [];
+                    existing.push(d);
+                    groupedByFile.set(d.uri, existing);
+                }
+                if (groupedByFile.size === 0) {
+                    return {
+                        contents: [
+                            {
+                                uri: 'lsp://diagnostics/workspace',
+                                mimeType: 'text/markdown',
+                                text: 'No diagnostics found in workspace.',
+                            },
+                        ],
+                    };
+                }
+                // Format grouped diagnostics
+                const sections = [];
+                for (const [uri, fileDiagnostics] of groupedByFile) {
+                    sections.push(`## ${uri}\n${formatDiagnosticsAsMarkdown(fileDiagnostics)}`);
+                }
+                return {
+                    contents: [
+                        {
+                            uri: 'lsp://diagnostics/workspace',
+                            mimeType: 'text/markdown',
+                            text: sections.join('\n\n'),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+                return {
+                    contents: [
+                        {
+                            uri: 'lsp://diagnostics/workspace',
+                            mimeType: 'text/markdown',
+                            text: message,
+                        },
+                    ],
+                };
+            }
+        });
+    }
+    // Set up subscription support if onDiagnosticsChanged is provided
+    if (capabilities.onDiagnosticsChanged) {
+        capabilities.onDiagnosticsChanged((uri) => {
+            // Notify MCP clients that the diagnostics resource has been updated
+            const normalizedUri = normalizeUri(uri);
+            server.server.sendResourceUpdated({
+                uri: `lsp://diagnostics/${normalizedUri}`,
+            });
+            // Also notify workspace diagnostics if it exists
+            if (diagnosticsProvider.getWorkspaceDiagnostics) {
+                server.server.sendResourceUpdated({
+                    uri: 'lsp://diagnostics/workspace',
+                });
+            }
+        });
+    }
+}
+/**
+ * Registers the outline resource.
+ * - lsp://outline/{path} - document symbols (outline) for a specific file
+ */
+function registerOutlineResource(server, capabilities) {
+    const outlineProvider = capabilities.outline;
+    if (!outlineProvider)
+        return;
+    const outlineTemplate = new ResourceTemplate('lsp://outline/{+path}', {
+        list: undefined, // Cannot enumerate all files
+    });
+    server.registerResource('file-outline', outlineTemplate, {
+        description: 'Document outline (symbols like classes, functions, variables) for a specific file. Use the file path after lsp://outline/',
+        mimeType: 'text/markdown',
+    }, async (_uri, variables) => {
+        try {
+            const path = variables.path;
+            const normalizedPath = normalizeUri(path);
+            const symbols = await outlineProvider.provideDocumentSymbols(normalizedPath);
+            const markdown = formatSymbolsAsMarkdown(symbols);
+            return {
+                contents: [
+                    {
+                        uri: `lsp://outline/${path}`,
+                        mimeType: 'text/markdown',
+                        text: markdown,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                contents: [
+                    {
+                        uri: `lsp://outline/${variables.path}`,
+                        mimeType: 'text/markdown',
+                        text: message,
+                    },
+                ],
+            };
+        }
+    });
+}
+/**
+ * Registers the apply_edit tool.
+ */
+function registerApplyEditTool(server, capabilities, resolver) {
+    const userInteraction = capabilities.userInteraction;
+    if (!userInteraction)
+        return;
+    server.registerTool('apply_edit', {
+        description: 'Apply a text edit to a file. The edit must be approved by the user before being applied.',
+        inputSchema: {
+            uri: ApplyEditSchema.shape.uri,
+            search_text: ApplyEditSchema.shape.search_text,
+            replace_text: ApplyEditSchema.shape.replace_text,
+            description: ApplyEditSchema.shape.description,
+        },
+        outputSchema: {
+            success: z.boolean(),
+            message: z.string(),
+        },
+    }, async (params) => {
+        try {
+            const uri = normalizeUri(params.uri);
+            // Validate that the search text exists and is unique
+            const range = await resolver.findExactText(uri, params.search_text);
+            // Create pending edit operation
+            const operation = {
+                id: generateEditId(),
+                uri,
+                edits: [
+                    {
+                        range,
+                        newText: params.replace_text,
+                    },
+                ],
+                description: params.description,
+            };
+            // Request user approval
+            const approved = await userInteraction.previewAndApplyEdits(operation);
+            const result = approved
+                ? { success: true, message: 'Edit successfully applied and saved.' }
+                : {
+                    success: false,
+                    message: 'Edit rejected by user.',
+                };
+            return makeToolResult(result);
+        }
+        catch (error) {
+            const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                structuredContent: {
+                    success: false,
+                    message,
+                },
+                isError: true,
+            };
+        }
+    });
+}
+/**
+ * Registers the filesystem resource.
+ * - lsp://files/{path} - file tree for a directory (git-ignored files excluded)
+ */
+function registerFilesystemResource(server, capabilities) {
+    const filesystemProvider = capabilities.filesystem;
+    if (!filesystemProvider)
+        return;
+    const filesystemTemplate = new ResourceTemplate('lsp://files/{+path}', {
+        list: undefined, // Cannot enumerate all directories
+    });
+    server.registerResource('filesystem', filesystemTemplate, {
+        description: 'File tree for a directory, excluding git-ignored files. Use the folder path after lsp://files/',
+        mimeType: 'text/markdown',
+    }, async (_uri, variables) => {
+        try {
+            const path = variables.path;
+            const normalizedPath = normalizeUri(path);
+            const files = await filesystemProvider.getFileTree(normalizedPath);
+            const markdown = files.length === 0
+                ? 'No files found in directory.'
+                : files.map((f) => `- ${f}`).join('\n');
+            return {
+                contents: [
+                    {
+                        uri: `lsp://files/${path}`,
+                        mimeType: 'text/markdown',
+                        text: markdown,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                contents: [
+                    {
+                        uri: `lsp://files/${variables.path}`,
+                        mimeType: 'text/markdown',
+                        text: message,
+                    },
+                ],
+            };
+        }
+    });
+}
+/**
+ * Registers the global_find tool.
+ */
+function registerGlobalFindTool(server, capabilities) {
+    const globalFindProvider = capabilities.globalFind;
+    if (!globalFindProvider)
+        return;
+    server.registerTool('global_find', {
+        description: 'Search for text across the entire workspace.',
+        inputSchema: GlobalFindSchema,
+        outputSchema: {
+            matches: z.array(z.object({
+                uri: z.string(),
+                line: z.number(),
+                column: z.number(),
+                matchText: z.string(),
+                context: z.string(),
+            })),
+            count: z.number(),
+        },
+    }, async (params) => {
+        try {
+            const caseSensitive = params.case_sensitive ?? false;
+            const exactMatch = params.exact_match ?? false;
+            const regexMode = params.regex_mode ?? false;
+            const matches = await globalFindProvider.globalFind(params.query, {
+                caseSensitive,
+                exactMatch,
+                regexMode,
+            });
+            return makeToolResult({ count: matches.length, matches });
+        }
+        catch (error) {
+            const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                structuredContent: { error: message },
+                isError: true,
+            };
+        }
+    });
+}
+/**
+ * Registers the global_replace tool.
+ */
+function registerGlobalReplaceTool(server, capabilities) {
+    const globalFindProvider = capabilities.globalFind;
+    if (!globalFindProvider)
+        return;
+    server.registerTool('global_replace', {
+        description: 'Replace all occurrences of text across the entire workspace.',
+        inputSchema: GlobalReplaceSchema,
+        outputSchema: {
+            success: z.boolean(),
+            count: z.number(),
+            message: z.string().optional(),
+        },
+    }, async (params) => {
+        try {
+            const caseSensitive = params.case_sensitive ?? false;
+            const exactMatch = params.exact_match ?? false;
+            const regexMode = params.regex_mode ?? false;
+            const count = await globalFindProvider.globalReplace(params.query, params.replace_with, { caseSensitive, exactMatch, regexMode });
+            return makeToolResult({ success: true, count });
+        }
+        catch (error) {
+            const message = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                structuredContent: {
+                    success: false,
+                    replacementCount: 0,
+                    message,
+                },
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=server.js.map

package/dist/types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Core Data Models for MCP LSP Driver SDK
+ *
+ * These types define how the LLM communicates intent versus
+ * how the IDE executes commands.
+ */
+/**
+ * A Unified Resource Identifier.
+ * Must be a file system path or a standard file:// scheme.
+ */
+export type UnifiedUri = string;
+/**
+ * 0-based exact coordinate system (Used internally by IDE).
+ */
+export interface ExactPosition {
+    /** 0-based line number */
+    line: number;
+    /** 0-based column (character offset) */
+    character: number;
+}
+/**
+ * The fuzzy location provided by the LLM.
+ * Designed to be robust against minor formatting changes or token counting errors.
+ */
+export interface FuzzyPosition {
+    /**
+     * The text of the symbol to find (e.g., function name, variable name).
+     */
+    symbolName: string;
+    /**
+     * An approximate line number where the symbol is expected.
+     * 1-based (Human friendly) for LLM input, converted to 0-based internally.
+     */
+    lineHint: number;
+    /**
+     * If the symbol appears multiple times on the line, which occurrence to target?
+     * 0-based index. Defaults to 0 (the first occurrence).
+     * Example: "add(a, a)" -> looking for second 'a' -> orderHint: 1.
+     */
+    orderHint?: number;
+}
+/**
+ * Represents a resolved span of text on disk.
+ */
+export interface DiskRange {
+    start: ExactPosition;
+    end: ExactPosition;
+}
+/**
+ * Represents a snippet of code read from disk.
+ */
+export interface CodeSnippet {
+    /** The URI of the file containing the snippet */
+    uri: UnifiedUri;
+    /** The range of the snippet in the file */
+    range: DiskRange;
+    /** The actual text read from disk */
+    content: string;
+}
+/**
+ * Represents a proposed change to a file.
+ */
+export interface TextEdit {
+    /** The range to replace */
+    range: DiskRange;
+    /** The new text to insert */
+    newText: string;
+}
+/**
+ * Represents a pending edit operation that awaits user approval.
+ */
+export interface PendingEditOperation {
+    /** Unique identifier for this operation */
+    id: string;
+    /** The URI of the file to edit */
+    uri: UnifiedUri;
+    /** The list of edits to apply */
+    edits: TextEdit[];
+    /** Optional description of the edit (e.g., "Refactor logic to handle null cases") */
+    description?: string;
+}
+/**
+ * The reason why an edit operation failed.
+ */
+export type EditFailureReason = 'UserRejected' | 'IOError' | 'ValidationFailed';
+/**
+ * The result of an edit operation.
+ */
+export type EditResult = {
+    success: boolean;
+    message: string;
+};
+/**
+ * Severity level for diagnostics.
+ */
+export type DiagnosticSeverity = 'error' | 'warning' | 'information' | 'hint';
+/**
+ * Represents a diagnostic (error, warning, etc.) from the IDE.
+ */
+export interface Diagnostic {
+    /** The URI of the file containing the diagnostic */
+    uri: UnifiedUri;
+    /** The range of the diagnostic */
+    range: DiskRange;
+    /** The severity of the diagnostic */
+    severity: DiagnosticSeverity;
+    /** The diagnostic message */
+    message: string;
+    /** Optional source of the diagnostic (e.g., "typescript", "eslint") */
+    source?: string;
+    /** Optional diagnostic code */
+    code?: string | number;
+}
+/**
+ * Symbol kind for outline items.
+ */
+export type SymbolKind = 'file' | 'module' | 'namespace' | 'package' | 'class' | 'method' | 'property' | 'field' | 'constructor' | 'enum' | 'interface' | 'function' | 'variable' | 'constant' | 'string' | 'number' | 'boolean' | 'array' | 'object' | 'key' | 'null' | 'enumMember' | 'struct' | 'event' | 'operator' | 'typeParameter';
+/**
+ * Represents a symbol in the document outline (e.g., class, function, variable).
+ */
+export interface DocumentSymbol {
+    /** The name of the symbol */
+    name: string;
+    /** More detail for this symbol (e.g., signature) */
+    detail?: string;
+    /** The kind of this symbol */
+    kind: SymbolKind;
+    /** The range of the entire symbol (including body) */
+    range: DiskRange;
+    /** The range of the symbol's name */
+    selectionRange: DiskRange;
+    /** Children of this symbol (e.g., methods in a class) */
+    children?: DocumentSymbol[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * Core Data Models for MCP LSP Driver SDK
+ *
+ * These types define how the LLM communicates intent versus
+ * how the IDE executes commands.
+ */
+export {};
+//# sourceMappingURL=types.js.map