roslyn-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,54 @@
+# Roslyn MCP Server
+
+A robust, independent Model Context Protocol (MCP) server integration for Microsoft's **Roslyn Language Server (C#)**.
+
+## Why use this project?
+The original Go-based MCP proxies typically encounter intense difficulties when operating with Microsoft's `StreamJsonRpc`. Common crashes (like `InvalidOperationException` due to null payloads, or `Document is null` on hovering) render the native MCP connections useless on huge codebases.
+
+This Node.js / TypeScript wrapper introduces a foolproof communication bridge that forcefully conforms to the rigorous LSP standards:
+* Features **`didOpen` buffer loading**, ensuring large C# solutions will natively understand dynamic diagnostic requests without crashing.
+* Includes rigorous fallback configurations tailored to seamlessly route tools like hover, definition, and reference symbol queries to your underlying MCP client (like Claude/Cursor).
+
+## Global Installation
+
+```bash
+npm install -g roslyn-mcp-server
+```
+
+### Pre-requisites
+You must have the official `.NET 8 (or above) SDK` installed along with the `roslyn-language-server` global tool.
+
+```bash
+dotnet tool install -g Microsoft.CodeAnalysis.LanguageServer
+```
+
+## How to use as an MCP Server
+
+Once installed globally, you can effortlessly configure it within your favorite Agent configurations (e.g., `mcp_config.json`, `claude_desktop_config.json`, Cursor etc.):
+
+```json
+{
+  "mcpServers": {
+    "csharp-lsp": {
+      "command": "roslyn-mcp-server",
+      "args": ["<OPTIONAL_ABSOLUTE_PATH_TO_CSHARP_PROJECT>"]
+    }
+  }
+}
+```
+
+> **Note:** If you don't supply `<OPTIONAL_ABSOLUTE_PATH_TO_CSHARP_PROJECT>`, the server will gracefully fallback to the Current Working Directory (CWD). This makes it infinitely portable!
+
+## Exposed MCP Tools
+
+* **`csharp_hover`**: Fetches the semantic type or variable definitions in markdown formats precisely at line/column boundaries.
+* **`csharp_definition`**: Retrieves the concrete origination URI.
+* **`csharp_references`**: Locates all occurrences or assignments of methods/properties across the entire initialized app constraints.
+* **`csharp_diagnostics`**: Summarizes the syntax errors and build warnings on a component.
+* **`csharp_workspace_symbol`**: Queries fuzzy name references broadly resolving the file locations across large infrastructures.
+
+## Development
+
+1. `npm install`
+2. `npm run build`
+3. Execute tests via: `node dist/test.js` or `npm start`

package/dist/LspClient.js

@@ -0,0 +1,131 @@
+import { spawn } from 'child_process';
+import * as rpc from 'vscode-jsonrpc/node.js';
+import * as lsp from 'vscode-languageserver-protocol';
+import { pathToFileURL } from 'url';
+import { readFileSync } from 'fs';
+export class LspClient {
+    workspacePath;
+    command;
+    args;
+    process;
+    connection;
+    diagnostics = new Map();
+    openedDocuments = new Set();
+    constructor(workspacePath, command = 'C:\\Users\\PC2\\.dotnet\\tools\\roslyn-language-server.cmd', args = ['--stdio', '--logLevel=Information']) {
+        this.workspacePath = workspacePath;
+        this.command = command;
+        this.args = args;
+        // Start the LSP process
+        this.process = spawn(this.command, this.args, { shell: true });
+        if (!this.process.stdin || !this.process.stdout) {
+            throw new Error("LSP process stdio could not be started.");
+        }
+        // Log stderr output from LSP for debugging
+        this.process.stderr?.on('data', (data) => {
+            console.error(`[LSP STDERR]: ${data.toString()}`);
+        });
+        // Create the JSON-RPC connection
+        this.connection = rpc.createMessageConnection(new rpc.StreamMessageReader(this.process.stdout), new rpc.StreamMessageWriter(this.process.stdin));
+        // Listener (Push Event) to catch and store diagnostic reports
+        this.connection.onNotification(lsp.PublishDiagnosticsNotification.method, (params) => {
+            this.diagnostics.set(params.uri, params.diagnostics);
+        });
+        this.connection.listen();
+    }
+    ensureDocumentOpen(filePath) {
+        const uri = this.pathToUri(filePath);
+        if (!this.openedDocuments.has(uri)) {
+            try {
+                const content = readFileSync(filePath, 'utf8');
+                this.connection.sendNotification(lsp.DidOpenTextDocumentNotification.method, {
+                    textDocument: {
+                        uri: uri,
+                        languageId: 'csharp',
+                        version: 1,
+                        text: content
+                    }
+                });
+                this.openedDocuments.add(uri);
+            }
+            catch (e) {
+                console.error(`ERROR: Failed to open document ${filePath} natively:`, e);
+            }
+        }
+    }
+    async initialize() {
+        const rootUri = pathToFileURL(this.workspacePath).href;
+        const initParams = {
+            processId: process.pid,
+            rootUri: rootUri,
+            capabilities: {
+                workspace: {
+                    symbol: {
+                        dynamicRegistration: true
+                    }
+                },
+                textDocument: {
+                    hover: { dynamicRegistration: true },
+                    definition: { dynamicRegistration: true },
+                    references: { dynamicRegistration: true },
+                    publishDiagnostics: { relatedInformation: true },
+                    synchronization: {
+                        dynamicRegistration: true,
+                        willSave: true,
+                        willSaveWaitUntil: true,
+                        didSave: true
+                    }
+                }
+            },
+            workspaceFolders: [
+                {
+                    uri: rootUri,
+                    name: 'workspace'
+                }
+            ]
+        };
+        // Send initialize request
+        await this.connection.sendRequest(lsp.InitializeRequest.method, initParams);
+        // Send initialized notification to signal readiness
+        await this.connection.sendNotification(lsp.InitializedNotification.method, {});
+    }
+    async hover(filePath, line, column) {
+        this.ensureDocumentOpen(filePath);
+        return this.connection.sendRequest(lsp.HoverRequest.method, {
+            textDocument: { uri: this.pathToUri(filePath) },
+            // LSP positions are 0-based.
+            position: { line, character: column }
+        });
+    }
+    async definition(filePath, line, column) {
+        this.ensureDocumentOpen(filePath);
+        return this.connection.sendRequest(lsp.DefinitionRequest.method, {
+            textDocument: { uri: this.pathToUri(filePath) },
+            position: { line, character: column }
+        });
+    }
+    async references(filePath, line, column) {
+        this.ensureDocumentOpen(filePath);
+        // CRITICAL FIX: The 'context' object must not be omitted to prevent Roslyn crashes
+        return this.connection.sendRequest(lsp.ReferencesRequest.method, {
+            textDocument: { uri: this.pathToUri(filePath) },
+            position: { line, character: column },
+            context: { includeDeclaration: true }
+        });
+    }
+    async workspaceSymbol(query) {
+        return this.connection.sendRequest(lsp.WorkspaceSymbolRequest.method, {
+            query
+        });
+    }
+    getDiagnostics(filePath) {
+        this.ensureDocumentOpen(filePath);
+        return this.diagnostics.get(this.pathToUri(filePath)) || [];
+    }
+    pathToUri(filePath) {
+        return pathToFileURL(filePath).href;
+    }
+    shutdown() {
+        this.connection.end();
+        this.process.kill();
+    }
+}

package/dist/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { LspClient } from "./LspClient.js";
+import * as lsp from "vscode-languageserver-protocol";
+// The target workspace folder is taken as an argument, defaults to the current execution directory
+const workspacePath = process.argv[2] ?? process.cwd();
+if (!workspacePath) {
+    console.error("ERROR: Could not resolve the workspace path.");
+    process.exit(1);
+}
+// Start the official server via LspClient
+const lspClient = new LspClient(workspacePath);
+// Define the MCP Bridge Server
+const mcpServer = new McpServer({
+    name: "roslyn-mcp-server",
+    version: "1.0.0"
+});
+// TOOL 1: Hover (Go To Definition hover info etc.)
+mcpServer.tool("csharp_hover", "Returns the type and documentation for the variable/method at the specified line and column", {
+    filePath: z.string().describe("Absolute path to the C# file"),
+    line: z.number().describe("Line number (1-based)"),
+    column: z.number().describe("Column number (1-based)")
+}, async ({ filePath, line, column }) => {
+    // AI usually sends 1-based lines, LSP works 0-based.
+    const lspLine = Math.max(0, line - 1);
+    const lspCol = Math.max(0, column - 1);
+    const hover = await lspClient.hover(filePath, lspLine, lspCol);
+    if (!hover || !hover.contents) {
+        return { content: [{ type: "text", text: "Hover info not found." }] };
+    }
+    let hoverText = "";
+    if (lsp.MarkupContent.is(hover.contents)) {
+        hoverText = hover.contents.value;
+    }
+    else if (typeof hover.contents === 'string') {
+        hoverText = hover.contents;
+    }
+    else if (Array.isArray(hover.contents)) {
+        hoverText = hover.contents.map(c => typeof c === 'string' ? c : c.value).join('\n');
+    }
+    else {
+        hoverText = hover.contents.value;
+    }
+    return { content: [{ type: "text", text: hoverText }] };
+});
+// TOOL 2: C# Definition (Go to definition - Where was it defined?)
+mcpServer.tool("csharp_definition", "Returns the source location of where the specified method, class, or variable is defined", {
+    filePath: z.string().describe("Absolute path to the C# file"),
+    line: z.number().describe("Line number (1-based)"),
+    column: z.number().describe("Column number (1-based)")
+}, async ({ filePath, line, column }) => {
+    const definition = await lspClient.definition(filePath, Math.max(0, line - 1), Math.max(0, column - 1));
+    return { content: [{ type: "text", text: JSON.stringify(definition, null, 2) }] };
+});
+// TOOL 3: C# References (Where is it used?)
+mcpServer.tool("csharp_references", "Finds all usages of the specified variable, class, or method across the entire project", {
+    filePath: z.string().describe("Absolute path to the C# file"),
+    line: z.number().describe("Line number (1-based)"),
+    column: z.number().describe("Column number (1-based)")
+}, async ({ filePath, line, column }) => {
+    const references = await lspClient.references(filePath, Math.max(0, line - 1), Math.max(0, column - 1));
+    return { content: [{ type: "text", text: JSON.stringify(references, null, 2) }] };
+});
+// TOOL 4: C# Diagnostics (Build/Syntax errors)
+mcpServer.tool("csharp_diagnostics", "Retrieves the current syntax errors, build issues, and warnings for the requested file", {
+    filePath: z.string().describe("Absolute path to the C# file")
+}, async ({ filePath }) => {
+    const diagnostics = lspClient.getDiagnostics(filePath);
+    return { content: [{ type: "text", text: JSON.stringify(diagnostics, null, 2) }] };
+});
+// TOOL 5: Workspace Symbol (Project-wide Search)
+mcpServer.tool("csharp_workspace_symbol", "Searches for methods, classes, or interfaces by name or partial name across the entire C# project", {
+    query: z.string().describe("The search query (e.g. method or class name)")
+}, async ({ query }) => {
+    const symbols = await lspClient.workspaceSymbol(query);
+    return { content: [{ type: "text", text: JSON.stringify(symbols, null, 2) }] };
+});
+async function main() {
+    try {
+        console.error("Sending LSP Initialization request...");
+        await lspClient.initialize();
+        console.error("LSP Server successfully initialized and handshaked.");
+        const transport = new StdioServerTransport();
+        await mcpServer.connect(transport);
+        console.error("MCP Server is now listening over Stdio. Ready for communication.");
+    }
+    catch (e) {
+        console.error("ERROR:", e);
+        process.exit(1);
+    }
+}
+main();

package/dist/test.js

@@ -0,0 +1,25 @@
+import { LspClient } from "./LspClient.js";
+async function run() {
+    console.log("Starting LspClient on TestCsharpApp...");
+    const lsp = new LspClient("C:\\Users\\PC2\\source\\repos\\RoslynMcpServer\\TestCsharpApp");
+    try {
+        await lsp.initialize();
+        console.log("LSP Initialized successfully.");
+        console.log("Waiting 5 seconds for background Roslyn analysis to push diagnostics...");
+        setTimeout(() => {
+            const diags = lsp.getDiagnostics("C:\\Users\\PC2\\source\\repos\\RoslynMcpServer\\TestCsharpApp\\Program.cs");
+            console.log("\n==================================");
+            console.log("Diagnostics Found:");
+            console.log(JSON.stringify(diags, null, 2));
+            console.log("==================================\n");
+            console.log("Shutting down...");
+            lsp.shutdown();
+            process.exit(0);
+        }, 5000);
+    }
+    catch (e) {
+        console.error("Test Error:", e);
+        process.exit(1);
+    }
+}
+run();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "roslyn-mcp-server",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "roslyn-mcp-server": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model context protocol",
+    "csharp",
+    "roslyn",
+    "lsp",
+    "language server",
+    "ai",
+    "claude"
+  ],
+  "author": "Antigravity",
+  "license": "MIT",
+  "description": "An unconditionally robust MCP server for Microsoft Roslyn Language Server (C#)",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-protocol": "^3.17.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "typescript": "^6.0.2"
+  }
+}