roslyn-mcp-server 1.0.1 → 1.1.0

package/dist/LspClient.js

@@ -2,7 +2,9 @@ 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';
+import { readFileSync, readdirSync } from 'fs';
+import * as chokidar from 'chokidar';
+import * as path from 'path';
 export class LspClient {
     workspacePath;
     command;
@@ -11,60 +13,144 @@ export class LspClient {
     connection;
     diagnostics = new Map();
     openedDocuments = new Set();
+    documentVersions = new Map();
+    watcher = null;
+    closed = false;
     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
+        // Diagnostic push events
         this.connection.onNotification(lsp.PublishDiagnosticsNotification.method, (params) => {
             this.diagnostics.set(params.uri, params.diagnostics);
         });
+        // Progress support
+        this.connection.onRequest('window/workDoneProgress/create', (_params) => null);
+        this.connection.onNotification('$/progress', (params) => {
+            const { value } = params;
+            if (value.kind === 'begin') {
+                console.error(`[Roslyn Progress] ${value.title} başladı...`);
+            }
+            else if (value.kind === 'end') {
+                console.error(`[Roslyn Progress] Tamamlandı.`);
+            }
+        });
+        // Handle connection close gracefully
+        this.connection.onClose(() => { this.closed = true; });
+        this.process.on('exit', () => { this.closed = true; });
         this.connection.listen();
     }
+    // ─── FILE WATCHER ──────────────────────────────────────────────
+    setupFileWatcher() {
+        this.watcher = chokidar.watch(this.workspacePath, {
+            ignored: [/node_modules/, /\.git/, /bin/, /obj/],
+            ignoreInitial: true
+        });
+        const isValid = (p) => p.endsWith('.cs') || p.endsWith('.csproj') || p.endsWith('.sln') || p.endsWith('.slnx');
+        this.watcher.on('add', (absPath) => {
+            if (!isValid(absPath) || this.closed)
+                return;
+            this.sendWatchedFileChange(absPath, 1);
+            this.ensureDocumentOpen(absPath);
+        });
+        this.watcher.on('change', (absPath) => {
+            if (!isValid(absPath) || this.closed)
+                return;
+            this.sendWatchedFileChange(absPath, 2);
+            // If not open yet, open it first; otherwise push didChange
+            const uri = this.pathToUri(absPath);
+            try {
+                const content = readFileSync(absPath, 'utf8');
+                if (!this.openedDocuments.has(uri)) {
+                    // First time seeing this file — open it
+                    this.documentVersions.set(uri, 1);
+                    this.connection.sendNotification(lsp.DidOpenTextDocumentNotification.method, {
+                        textDocument: { uri, languageId: 'csharp', version: 1, text: content }
+                    });
+                    this.openedDocuments.add(uri);
+                }
+                else {
+                    // Already open — send incremental change
+                    const newVersion = (this.documentVersions.get(uri) || 1) + 1;
+                    this.documentVersions.set(uri, newVersion);
+                    this.connection.sendNotification(lsp.DidChangeTextDocumentNotification.method, {
+                        textDocument: { uri, version: newVersion },
+                        contentChanges: [{ text: content }]
+                    });
+                }
+            }
+            catch (e) {
+                console.error(`ERROR: Failed to sync change for ${absPath}`, e);
+            }
+        });
+        this.watcher.on('unlink', (absPath) => {
+            if (!isValid(absPath) || this.closed)
+                return;
+            try {
+                this.sendWatchedFileChange(absPath, 3);
+            }
+            catch (e) { /* connection may be closed */ }
+            const uri = this.pathToUri(absPath);
+            if (this.openedDocuments.has(uri)) {
+                try {
+                    this.connection.sendNotification(lsp.DidCloseTextDocumentNotification.method, {
+                        textDocument: { uri }
+                    });
+                }
+                catch (e) { /* connection may be closed */ }
+                this.openedDocuments.delete(uri);
+                this.documentVersions.delete(uri);
+                this.diagnostics.delete(uri);
+            }
+        });
+    }
+    sendWatchedFileChange(filePath, changeType) {
+        if (this.closed)
+            return;
+        this.connection.sendNotification(lsp.DidChangeWatchedFilesNotification.method, {
+            changes: [{ uri: this.pathToUri(filePath), type: changeType }]
+        });
+    }
     ensureDocumentOpen(filePath) {
         const uri = this.pathToUri(filePath);
         if (!this.openedDocuments.has(uri)) {
             try {
                 const content = readFileSync(filePath, 'utf8');
+                this.documentVersions.set(uri, 1);
                 this.connection.sendNotification(lsp.DidOpenTextDocumentNotification.method, {
-                    textDocument: {
-                        uri: uri,
-                        languageId: 'csharp',
-                        version: 1,
-                        text: content
-                    }
+                    textDocument: { uri, languageId: 'csharp', version: 1, text: content }
                 });
                 this.openedDocuments.add(uri);
             }
             catch (e) {
-                console.error(`ERROR: Failed to open document ${filePath} natively:`, e);
+                console.error(`ERROR: Failed to open document ${filePath}:`, e);
             }
         }
     }
+    // ─── INITIALIZE ────────────────────────────────────────────────
     async initialize() {
         const rootUri = pathToFileURL(this.workspacePath).href;
         const initParams = {
             processId: process.pid,
             rootUri: rootUri,
             capabilities: {
+                window: {
+                    workDoneProgress: true
+                },
                 workspace: {
-                    symbol: {
-                        dynamicRegistration: true
-                    }
+                    symbol: { dynamicRegistration: true },
+                    didChangeWatchedFiles: { dynamicRegistration: true }
                 },
                 textDocument: {
-                    hover: { dynamicRegistration: true },
+                    hover: { dynamicRegistration: true, contentFormat: ['markdown', 'plaintext'] },
                     definition: { dynamicRegistration: true },
                     references: { dynamicRegistration: true },
                     publishDiagnostics: { relatedInformation: true },
@@ -76,36 +162,67 @@ export class LspClient {
                     }
                 }
             },
-            workspaceFolders: [
-                {
-                    uri: rootUri,
-                    name: 'workspace'
-                }
-            ]
+            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, {});
+        // CRITICAL: Tell Roslyn which solution/projects to load
+        await this.openSolutionOrProjects();
+        // Start File Watcher
+        this.setupFileWatcher();
+    }
+    async openSolutionOrProjects() {
+        const rootFiles = readdirSync(this.workspacePath);
+        const slnFile = rootFiles.find(f => f.endsWith('.sln') || f.endsWith('.slnx'));
+        if (slnFile) {
+            const slnUri = pathToFileURL(path.join(this.workspacePath, slnFile)).href;
+            console.error(`[LSP] Opening solution: ${slnFile}`);
+            await this.connection.sendNotification('solution/open', { solution: slnUri });
+            return;
+        }
+        const csprojFiles = this.findFiles(this.workspacePath, '.csproj');
+        if (csprojFiles.length > 0) {
+            const projectUris = csprojFiles.map(f => pathToFileURL(f).href);
+            console.error(`[LSP] Opening ${csprojFiles.length} project(s)`);
+            await this.connection.sendNotification('project/open', { projects: projectUris });
+            return;
+        }
+        console.error('[LSP] WARNING: No .sln, .slnx, or .csproj files found.');
+    }
+    findFiles(dir, ext) {
+        const results = [];
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory() && !['node_modules', '.git', 'bin', 'obj'].includes(entry.name)) {
+                    results.push(...this.findFiles(fullPath, ext));
+                }
+                else if (entry.isFile() && entry.name.endsWith(ext)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch (e) { /* skip */ }
+        return results;
     }
+    // ─── LSP TOOLS ─────────────────────────────────────────────────
     async hover(filePath, line, column) {
-        this.ensureDocumentOpen(filePath);
+        await this.ensureDocumentOpenAsync(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);
+        await this.ensureDocumentOpenAsync(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
+        await this.ensureDocumentOpenAsync(filePath);
         return this.connection.sendRequest(lsp.ReferencesRequest.method, {
             textDocument: { uri: this.pathToUri(filePath) },
             position: { line, character: column },
@@ -113,19 +230,68 @@ export class LspClient {
         });
     }
     async workspaceSymbol(query) {
-        return this.connection.sendRequest(lsp.WorkspaceSymbolRequest.method, {
-            query
-        });
+        return this.connection.sendRequest(lsp.WorkspaceSymbolRequest.method, { query });
     }
-    getDiagnostics(filePath) {
-        this.ensureDocumentOpen(filePath);
+    async getDiagnostics(filePath) {
+        await this.ensureDocumentOpenAsync(filePath);
+        // Diagnostics are pushed asynchronously by Roslyn via publishDiagnostics
+        // The watcher handles file changes via didChange. Just return from cache.
         return this.diagnostics.get(this.pathToUri(filePath)) || [];
     }
+    // ─── HELPERS ───────────────────────────────────────────────────
+    async ensureDocumentOpenAsync(filePath) {
+        const uri = this.pathToUri(filePath);
+        if (!this.openedDocuments.has(uri)) {
+            try {
+                const content = readFileSync(filePath, 'utf8');
+                this.documentVersions.set(uri, 1);
+                this.connection.sendNotification(lsp.DidOpenTextDocumentNotification.method, {
+                    textDocument: { uri, languageId: 'csharp', version: 1, text: content }
+                });
+                this.openedDocuments.add(uri);
+                // Wait for Roslyn to parse the opened document
+                await new Promise(r => setTimeout(r, 300));
+            }
+            catch (e) {
+                console.error(`ERROR: Failed to open ${filePath}:`, e);
+            }
+        }
+    }
+    async refreshDocument(filePath) {
+        const uri = this.pathToUri(filePath);
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            if (!this.openedDocuments.has(uri)) {
+                this.documentVersions.set(uri, 1);
+                this.connection.sendNotification(lsp.DidOpenTextDocumentNotification.method, {
+                    textDocument: { uri, languageId: 'csharp', version: 1, text: content }
+                });
+                this.openedDocuments.add(uri);
+            }
+            else {
+                const newVersion = (this.documentVersions.get(uri) || 1) + 1;
+                this.documentVersions.set(uri, newVersion);
+                this.connection.sendNotification(lsp.DidChangeTextDocumentNotification.method, {
+                    textDocument: { uri, version: newVersion },
+                    contentChanges: [{ text: content }]
+                });
+            }
+        }
+        catch (e) { /* file might not exist */ }
+    }
     pathToUri(filePath) {
         return pathToFileURL(filePath).href;
     }
     shutdown() {
-        this.connection.end();
-        this.process.kill();
+        this.closed = true;
+        this.watcher?.close();
+        try {
+            this.connection.end();
+        }
+        catch (e) { }
+        try {
+            this.process.kill();
+        }
+        catch (e) { }
     }
 }

package/dist/index.js

@@ -63,19 +63,32 @@ mcpServer.tool("csharp_references", "Finds all usages of the specified variable,
     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", {
+mcpServer.tool("csharp_diagnostics", "Retrieves the current syntax errors, build issues, and warnings for the requested file. The tool re-reads the file from disk and waits briefly for Roslyn to process changes before returning results.", {
     filePath: z.string().describe("Absolute path to the C# file")
 }, async ({ filePath }) => {
-    const diagnostics = lspClient.getDiagnostics(filePath);
+    const diagnostics = await 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", {
+mcpServer.tool("csharp_workspace_symbol", "Searches for methods, classes, or interfaces by name or partial name across the entire C# project. IMPORTANT: The C# Language Server might take 5-10 seconds to fully index large workspaces perfectly. If your prompt expects results but you receive empty [], please wait a few seconds and call this tool again.", {
     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) }] };
+    try {
+        const result = await lspClient.workspaceSymbol(query);
+        let responseText = JSON.stringify(result, null, 2);
+        if (!result || result.length === 0) {
+            responseText += "\n\n[Note for AI: The Roslyn indexer might still be processing the workspace. If you confidently expect a result here, please wait 3-5 seconds and try calling this tool again.]";
+        }
+        return {
+            content: [{ type: "text", text: responseText }]
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: error.message }]
+        };
+    }
 });
 async function main() {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roslyn-mcp-server",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "type": "module",
   "files": [
@@ -30,6 +30,7 @@
   "description": "An unconditionally robust MCP server for Microsoft Roslyn Language Server (C#)",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "chokidar": "^5.0.0",
     "vscode-jsonrpc": "^8.2.1",
     "vscode-languageserver-protocol": "^3.17.5",
     "zod": "^4.3.6"