@theupsider/lsp-mcp 1.0.1 → 1.0.8

package/README.md

@@ -32,7 +32,7 @@ A Model Context Protocol (MCP) server that gives language models access to **Lan
 
 - **🔍 Automatic Language Detection** — Scans project root for language markers (`package.json`, `Cargo.toml`, `go.mod`, etc.)
 - **🔄 Auto Language Server Selection** — Hardcoded mapping with fallback servers; installs missing LSPs automatically
-- **🛠 19 LSP Tools** — Hover, definition, references, completions, diagnostics, rename, code actions, formatting, and more
+- **🛠 12 LSP Tools** — Definition, references, symbols, diagnostics, rename, code actions, formatting, and more
 - **📝 Read & Write Operations** — Both inspection and modification of code via LSP
 - **🌐 Polyglot Support** — Multiple language servers run simultaneously in the same project
 - **📋 Hybrid Responses** — Human-readable `text` field + raw LSP data in `raw` field
@@ -103,14 +103,11 @@ lsp_init({ root: "/path/to/project", languages: ["python", "typescript"] })
 | Tool                    | Description                             | Key Parameters                                         |
 | ----------------------- | --------------------------------------- | ------------------------------------------------------ |
 | `lsp_init`              | Initialize server for a project root    | `root` (required), `languages` (optional string array) |
-| `lsp_hover`             | Show type info / documentation          | `file`, `line`, `character`                            |
 | `lsp_definition`        | Go to definition                | `file`, `line`, `character`           |
 | `lsp_references`        | Find all references             | `file`, `line`, `character`           |
 | `lsp_document_symbols`  | List symbols in a file          | `file`                                |
 | `lsp_workspace_symbols` | Search symbols across workspace | `query` (limit: 100–500 results)      |
-| `lsp_completion`        | Code completion suggestions     | `file`, `line`, `character`           |
 | `lsp_diagnostics`       | Get errors & warnings           | `file` (scope: `file` or `workspace`) |
-| `lsp_signature_help`    | Function signature help         | `file`, `line`, `character`           |
 | `lsp_type_definition`   | Go to type definition           | `file`, `line`, `character`           |
 | `lsp_implementation`    | Find implementations            | `file`, `line`, `character`           |
 | `lsp_health`            | Check status of all LSP servers | _(none)_                              |
@@ -123,7 +120,6 @@ lsp_init({ root: "/path/to/project", languages: ["python", "typescript"] })
 | `lsp_code_action`          | Apply / list code actions | `file`, `line`, `character`, `apply`   |
 | `lsp_formatting`           | Format document           | `file`                                 |
 | `lsp_range_formatting`     | Format code range         | `file`, `range`                        |
-| `lsp_apply_workspace_edit` | Apply raw workspace edit  | `edit` (WorkspaceEdit object)          |
 
 ## Configuration
 
@@ -190,7 +186,7 @@ Each language server runs as a separate process. For large projects with many la
 ┌─────────────────────────────────────────────┐
 │         LSP MCP Server (Node.js)            │
 │  ┌───────────┐ ┌──────────┐ ┌───────────┐  │
-│  │ lsp_hover │ │ lsp_...  │ │ lsp_...   │  │
+│  │ lsp_init  │ │ lsp_...  │ │ lsp_...   │  │
 │  └─────┬─────┘ └────┬─────┘ └─────┬─────┘  │
 │        └─────────────┼─────────────┘        │
 │                      ▼                       │

package/dist/lsp/lifecycle-manager.js

@@ -20,7 +20,7 @@ class LifecycleManager {
     }
     async start(languages) {
         const startPromise = this.startInternal(languages);
-        await promiseWithTimeout(startPromise, 30000, 'Lifecycle start timed out');
+        await promiseWithTimeout(startPromise, 30000, "Lifecycle start timed out");
     }
     async ensureLanguage(language) {
         if (this.supervisors.has(language)) {
@@ -53,7 +53,8 @@ class LifecycleManager {
         return Array.from(this.supervisors.values())
             .filter((supervisor) => {
             const health = supervisor.getHealth();
-            return health.status === 'ready' && (!language || supervisor.language === language);
+            return (health.status === "ready" &&
+                (!language || supervisor.language === language));
         })
             .flatMap((supervisor) => {
             const client = supervisor.getClient();
@@ -66,6 +67,20 @@ class LifecycleManager {
     getWorkspaceDiagnostics(language) {
         return this.store.getForWorkspace(language);
     }
+    async analyzeWorkspace(language) {
+        await Promise.all(Array.from(this.supervisors.entries())
+            .filter(([lang, supervisor]) => {
+            const health = supervisor.getHealth();
+            return health.status === "ready" && (!language || lang === language);
+        })
+            .map(async ([lang, supervisor]) => {
+            const client = supervisor.getClient();
+            if (!client)
+                return;
+            const extensions = (0, language_registry_1.extensionsForLanguage)(lang);
+            await client.openAllFilesForDiagnostics(extensions);
+        }));
+    }
     async ensureSeedFilesOpen() {
         await Promise.all(Array.from(this.supervisors.entries()).map(async ([language, supervisor]) => {
             const client = supervisor.getClient();
@@ -77,8 +92,8 @@ class LifecycleManager {
     }
     async shutdown() {
         const supervisors = Array.from(this.supervisors.values());
-        const results = await Promise.allSettled(supervisors.map(async (supervisor) => await promiseWithTimeout(supervisor.shutdown(), 5000, 'LSP shutdown timed out')));
-        const errors = results.filter((result) => result.status === 'rejected').length;
+        const results = await Promise.allSettled(supervisors.map(async (supervisor) => await promiseWithTimeout(supervisor.shutdown(), 5000, "LSP shutdown timed out")));
+        const errors = results.filter((result) => result.status === "rejected").length;
         process.stderr.write(`{"timestamp":"${new Date().toISOString()}","level":"info","event":"Shutdown: ${supervisors.length - errors} LSP-Server beendet, ${errors} Fehler"}\n`);
     }
     async startInternal(languages) {
@@ -93,7 +108,7 @@ class LifecycleManager {
     }
     createSupervisor(language) {
         return new server_supervisor_1.ServerSupervisor(language, this.projectRoot, this.logLevel, (method, params) => {
-            if (method === 'textDocument/publishDiagnostics') {
+            if (method === "textDocument/publishDiagnostics") {
                 this.store.store(params);
             }
         });
@@ -101,10 +116,10 @@ class LifecycleManager {
 }
 exports.LifecycleManager = LifecycleManager;
 function normalizeLogLevel(level) {
-    if (level === 'error' || level === 'debug') {
+    if (level === "error" || level === "debug") {
         return level;
     }
-    return 'info';
+    return "info";
 }
 async function promiseWithTimeout(promise, timeoutMs, message) {
     return await new Promise((resolve, reject) => {

package/dist/lsp/lsp-client.js

@@ -131,7 +131,10 @@ class LspClient extends node_events_1.EventEmitter {
     waitForDiagnosticsPublish(filePath, timeoutMs) {
         const uri = (0, uri_1.pathToUri)(filePath);
         return new Promise((resolve) => {
-            const timer = setTimeout(resolve, timeoutMs);
+            const timer = setTimeout(() => {
+                this.off("notification", handler);
+                resolve();
+            }, timeoutMs);
             const handler = (method, params) => {
                 if (method === "textDocument/publishDiagnostics") {
                     const p = params;
@@ -169,6 +172,18 @@ class LspClient extends node_events_1.EventEmitter {
             await this.ensureDidOpen(file);
         }
     }
+    async openAllFilesForDiagnostics(extensions) {
+        const MAX_FILES = 100;
+        const allFiles = await findAllFilesWithExtension(this.projectRoot, extensions, MAX_FILES);
+        const newFiles = allFiles.filter((f) => !this.openedFiles.has(f));
+        if (newFiles.length === 0) {
+            return;
+        }
+        // Set up wait promises BEFORE opening files to avoid missing notifications
+        const waitPromises = newFiles.map((f) => this.waitForDiagnosticsPublish(f, 15000));
+        await Promise.all(newFiles.map((f) => this.ensureDidOpen(f)));
+        await Promise.all(waitPromises);
+    }
     sendMessage(message) {
         if (!this.process) {
             throw new Error("LSP process is not running");
@@ -285,8 +300,17 @@ function shouldLog(configuredLevel, messageLevel) {
     return order[messageLevel] <= order[configuredLevel];
 }
 const SKIP_DIRS = new Set([
-    'node_modules', '.git', 'dist', 'build', 'out', '.next',
-    'coverage', '__pycache__', 'target', '.cache', 'vendor',
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    "coverage",
+    "__pycache__",
+    "target",
+    ".cache",
+    "vendor",
 ]);
 async function findFirstFileWithExtension(dir, extensions) {
     const extensionSet = new Set(extensions.map((e) => e.toLowerCase()));
@@ -298,7 +322,8 @@ async function findFirstFileWithExtension(dir, extensions) {
         return null;
     }
     for (const entry of entries) {
-        if (entry.isFile() && extensionSet.has(node_path_1.default.extname(entry.name).toLowerCase())) {
+        if (entry.isFile() &&
+            extensionSet.has(node_path_1.default.extname(entry.name).toLowerCase())) {
             return node_path_1.default.join(dir, entry.name);
         }
     }
@@ -311,3 +336,31 @@ async function findFirstFileWithExtension(dir, extensions) {
     }
     return null;
 }
+async function findAllFilesWithExtension(dir, extensions, maxFiles, results = []) {
+    if (results.length >= maxFiles)
+        return results;
+    const extensionSet = new Set(extensions.map((e) => e.toLowerCase()));
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        if (results.length >= maxFiles)
+            break;
+        if (entry.isFile() &&
+            extensionSet.has(node_path_1.default.extname(entry.name).toLowerCase())) {
+            results.push(node_path_1.default.join(dir, entry.name));
+        }
+    }
+    for (const entry of entries) {
+        if (results.length >= maxFiles)
+            break;
+        if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+            await findAllFilesWithExtension(node_path_1.default.join(dir, entry.name), extensions, maxFiles, results);
+        }
+    }
+    return results;
+}

package/dist/lsp/server-supervisor.js

@@ -8,10 +8,9 @@ class ServerSupervisor {
     language;
     restartCount = 0;
     client = null;
-    status = 'starting';
+    status = "starting";
     error = undefined;
     capabilities = undefined;
-    serverDef = null;
     healthInterval = null;
     projectRoot;
     logLevel;
@@ -26,36 +25,36 @@ class ServerSupervisor {
     async start() {
         const serverDef = await this.resolveServer();
         if (!serverDef) {
-            this.status = 'error';
+            this.status = "error";
             this.error = `No LSP server available for ${this.language}`;
             return;
         }
-        this.serverDef = serverDef;
         const client = new lsp_client_1.LspClient(serverDef, this.projectRoot, this.logLevel);
         this.client = client;
-        client.on('crash', async () => {
+        client.on("crash", async () => {
             if (this.shuttingDown) {
                 return;
             }
             await this.restart(`LSP server crashed for ${this.language}`);
         });
-        client.on('error', (error) => {
-            this.status = 'error';
-            this.error = error instanceof Error ? error.message : 'Unknown LSP error';
+        client.on("error", (error) => {
+            this.status = "error";
+            this.error = error instanceof Error ? error.message : "Unknown LSP error";
         });
-        client.on('notification', (method, params) => {
+        client.on("notification", (method, params) => {
             this.onDiagnostics(method, params);
         });
         try {
             await client.start();
-            this.status = 'ready';
+            this.status = "ready";
             this.error = undefined;
             this.capabilities = client.getCapabilities() ?? undefined;
             this.startHealthChecks();
         }
         catch (error) {
-            this.status = 'error';
-            this.error = error instanceof Error ? error.message : 'Unknown LSP startup error';
+            this.status = "error";
+            this.error =
+                error instanceof Error ? error.message : "Unknown LSP startup error";
         }
     }
     async restart(reason) {
@@ -64,17 +63,17 @@ class ServerSupervisor {
             this.healthInterval = null;
         }
         if (this.restartCount >= 3) {
-            this.status = 'error';
+            this.status = "error";
             this.error = reason;
             this.client = null;
             return;
         }
         this.restartCount += 1;
-        this.status = 'starting';
+        this.status = "starting";
         this.error = reason;
         if (this.client) {
             try {
-                await promiseWithTimeout(this.client.shutdown(), 5000, 'LSP shutdown timed out');
+                await promiseWithTimeout(this.client.shutdown(), 5000, "LSP shutdown timed out");
             }
             catch {
                 // Ignore shutdown failures during restart.
@@ -102,7 +101,7 @@ class ServerSupervisor {
             language: this.language,
             status: this.status,
             error: this.error,
-            capabilities: this.capabilities
+            capabilities: this.capabilities,
         };
     }
     startHealthChecks() {
@@ -114,11 +113,11 @@ class ServerSupervisor {
         }, 30000);
     }
     async runHealthCheck() {
-        if (!this.client || this.status !== 'ready') {
+        if (!this.client || this.status !== "ready") {
             return;
         }
         if (!this.client.isReady()) {
-            await this.restart('LSP client lost ready state');
+            await this.restart("LSP client lost ready state");
         }
     }
     async resolveServer() {