@theupsider/lsp-mcp 1.1.2 → 1.2.0

package/dist/lsp/__tests__/diagnostic-store.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const diagnostic_store_1 = require("../diagnostic-store");
+describe('DiagnosticStore', () => {
+    it('replaces diagnostics wholesale per uri on each publish', () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store({ uri: 'file:///a.ts', diagnostics: [makeDiagnostic(1, 'first')] });
+        store.store({ uri: 'file:///a.ts', diagnostics: [makeDiagnostic(2, 'second')] });
+        expect(store.getForFile('/a.ts')).toEqual([
+            { ...makeDiagnostic(2, 'second'), uri: 'file:///a.ts' },
+        ]);
+    });
+    it('ignores malformed publishDiagnostics payloads', () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store(null);
+        store.store({ uri: 'file:///a.ts' });
+        store.store({ diagnostics: [] });
+        expect(store.getForFile('/a.ts')).toEqual([]);
+    });
+    it('sorts workspace diagnostics by severity ascending (errors before warnings)', () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store({
+            uri: 'file:///warn.ts',
+            diagnostics: [makeDiagnostic(2, 'a warning')],
+        });
+        store.store({
+            uri: 'file:///error.ts',
+            diagnostics: [makeDiagnostic(1, 'an error')],
+        });
+        store.store({
+            uri: 'file:///hint.ts',
+            diagnostics: [makeDiagnostic(4, 'a hint')],
+        });
+        const result = store.getForWorkspace();
+        expect(result.map((d) => d.message)).toEqual([
+            'an error',
+            'a warning',
+            'a hint',
+        ]);
+    });
+    it('filters workspace diagnostics by language extension', () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store({ uri: 'file:///a.ts', diagnostics: [makeDiagnostic(1, 'ts issue')] });
+        store.store({ uri: 'file:///b.py', diagnostics: [makeDiagnostic(1, 'py issue')] });
+        const result = store.getForWorkspace('python');
+        expect(result).toEqual([
+            { ...makeDiagnostic(1, 'py issue'), uri: 'file:///b.py' },
+        ]);
+    });
+});
+function makeDiagnostic(severity, message) {
+    return {
+        severity,
+        message,
+        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+    };
+}

package/dist/lsp/__tests__/lsp-client.test.js

@@ -1,6 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_events_1 = require("node:events");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
 const node_stream_1 = require("node:stream");
 const lsp_client_1 = require("../lsp-client");
 jest.mock('node:child_process', () => ({
@@ -208,6 +214,73 @@ describe('LspClient', () => {
         child.stdout.write(encodeMessage({ jsonrpc: '2.0', method: 'textDocument/publishDiagnostics', params: { uri: 'file:///x', diagnostics: [] } }));
         await expect(notificationPromise).resolves.toEqual({ method: 'textDocument/publishDiagnostics', params: { uri: 'file:///x', diagnostics: [] } });
     });
+    describe('openAllFilesForDiagnostics (workspace scan regressions)', () => {
+        let tmpDir;
+        beforeEach(async () => {
+            tmpDir = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), 'lsp-client-scan-'));
+        });
+        afterEach(async () => {
+            await (0, promises_1.rm)(tmpDir, { recursive: true, force: true });
+        });
+        // Publish notifications never arrive in this test (no real server), so
+        // shorten the wait so these regression tests run fast under real timers
+        // instead of racing fake timers against real fs I/O.
+        function withShortDiagnosticsWait(client) {
+            const original = client.waitForDiagnosticsPublish.bind(client);
+            client.waitForDiagnosticsPublish = (filePath) => original(filePath, 50);
+        }
+        it('does not let one unreadable file abort the whole scan (regression)', async () => {
+            const child = new MockChildProcess();
+            const spawn = jest.requireMock('node:child_process').spawn;
+            spawn.mockReturnValue(child);
+            const client = new lsp_client_1.LspClient(SERVER, tmpDir, 'error');
+            await startClient(client, child);
+            withShortDiagnosticsWait(client);
+            await (0, promises_1.writeFile)(node_path_1.default.join(tmpDir, 'a.ts'), 'const a = 1;\n');
+            await (0, promises_1.writeFile)(node_path_1.default.join(tmpDir, 'b.ts'), 'const b = 1;\n');
+            const brokenPath = node_path_1.default.join(tmpDir, 'broken.ts');
+            await (0, promises_1.writeFile)(brokenPath, 'const c = 1;\n');
+            await (0, promises_1.chmod)(brokenPath, 0o000);
+            if (process.getuid?.() === 0) {
+                // Running as root: chmod 0o000 does not block reads, so this test cannot apply.
+                return;
+            }
+            const summary = await client.openAllFilesForDiagnostics(['.ts']);
+            expect(summary).toEqual({ opened: 2, failed: 1, truncated: false });
+        }, 10000);
+        it('skips virtualenv-style directories during the workspace scan (regression)', async () => {
+            const child = new MockChildProcess();
+            const spawn = jest.requireMock('node:child_process').spawn;
+            spawn.mockReturnValue(child);
+            const client = new lsp_client_1.LspClient(SERVER, tmpDir, 'error');
+            await startClient(client, child);
+            withShortDiagnosticsWait(client);
+            await (0, promises_1.writeFile)(node_path_1.default.join(tmpDir, 'top1.py'), 'x = 1\n');
+            await (0, promises_1.writeFile)(node_path_1.default.join(tmpDir, 'top2.py'), 'y = 2\n');
+            const venvPkgDir = node_path_1.default.join(tmpDir, '.venv', 'lib', 'site-packages');
+            await (0, promises_1.mkdir)(venvPkgDir, { recursive: true });
+            await Promise.all(Array.from({ length: 5 }, (_, i) => (0, promises_1.writeFile)(node_path_1.default.join(venvPkgDir, `dep${i}.py`), `dep = ${i}\n`)));
+            const summary = await client.openAllFilesForDiagnostics(['.py']);
+            expect(summary).toEqual({ opened: 2, failed: 0, truncated: false });
+            const openedUris = child.stdinWrites
+                .map((raw) => extractMessage(raw))
+                .filter((message) => message.method === 'textDocument/didOpen')
+                .map((message) => getObject(message.params).textDocument)
+                .map((textDocument) => textDocument.uri);
+            expect(openedUris.some((uri) => uri.includes('.venv'))).toBe(false);
+        }, 10000);
+        it('caps the workspace scan at 100 files per language and reports truncation', async () => {
+            const child = new MockChildProcess();
+            const spawn = jest.requireMock('node:child_process').spawn;
+            spawn.mockReturnValue(child);
+            const client = new lsp_client_1.LspClient(SERVER, tmpDir, 'error');
+            await startClient(client, child);
+            withShortDiagnosticsWait(client);
+            await Promise.all(Array.from({ length: 150 }, (_, i) => (0, promises_1.writeFile)(node_path_1.default.join(tmpDir, `file${i}.ts`), `const v${i} = ${i};\n`)));
+            const summary = await client.openAllFilesForDiagnostics(['.ts']);
+            expect(summary).toEqual({ opened: 100, failed: 0, truncated: true });
+        }, 10000);
+    });
 });
 function encodeMessage(payload) {
     const body = JSON.stringify(payload);

package/dist/lsp/lifecycle-manager.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LifecycleManager = void 0;
+exports.promiseWithTimeout = promiseWithTimeout;
 const node_path_1 = __importDefault(require("node:path"));
 const language_detector_1 = require("../detection/language-detector");
 const language_registry_1 = require("../detection/language-registry");
@@ -68,18 +69,44 @@ class LifecycleManager {
         return this.store.getForWorkspace(language);
     }
     async analyzeWorkspace(language) {
-        await Promise.all(Array.from(this.supervisors.entries())
+        const results = await Promise.allSettled(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;
+            if (!client) {
+                return { language: lang, opened: 0, failed: 0, truncated: false };
+            }
             const extensions = (0, language_registry_1.extensionsForLanguage)(lang);
-            await client.openAllFilesForDiagnostics(extensions);
+            try {
+                const scan = await client.openAllFilesForDiagnostics(extensions);
+                return { language: lang, ...scan };
+            }
+            catch (error) {
+                return {
+                    language: lang,
+                    opened: 0,
+                    failed: 0,
+                    truncated: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
         }));
+        return {
+            perLanguage: results.map((result) => result.status === "fulfilled"
+                ? result.value
+                : {
+                    language: "unknown",
+                    opened: 0,
+                    failed: 0,
+                    truncated: false,
+                    error: result.reason instanceof Error
+                        ? result.reason.message
+                        : String(result.reason),
+                }),
+        };
     }
     async ensureSeedFilesOpen() {
         await Promise.all(Array.from(this.supervisors.entries()).map(async ([language, supervisor]) => {

package/dist/lsp/lsp-client.js

@@ -176,13 +176,16 @@ class LspClient extends node_events_1.EventEmitter {
         const MAX_FILES = 100;
         const allFiles = await findAllFilesWithExtension(this.projectRoot, extensions, MAX_FILES);
         const newFiles = allFiles.filter((f) => !this.openedFiles.has(f));
+        const truncated = allFiles.length >= MAX_FILES;
         if (newFiles.length === 0) {
-            return;
+            return { opened: 0, failed: 0, truncated };
         }
         // 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);
+        const openResults = await Promise.allSettled(newFiles.map((f) => this.ensureDidOpen(f)));
+        await Promise.allSettled(waitPromises);
+        const failed = openResults.filter((result) => result.status === "rejected").length;
+        return { opened: newFiles.length - failed, failed, truncated };
     }
     sendMessage(message) {
         if (!this.process) {
@@ -311,6 +314,13 @@ const SKIP_DIRS = new Set([
     "target",
     ".cache",
     "vendor",
+    ".venv",
+    "venv",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".idea",
+    ".gradle",
 ]);
 async function findFirstFileWithExtension(dir, extensions) {
     const extensionSet = new Set(extensions.map((e) => e.toLowerCase()));

package/dist/mcp/__tests__/read-tools.test.js

@@ -306,6 +306,74 @@ describe("registerReadTools", () => {
             raw: diagnostics,
         });
     });
+    it("returns a structured error instead of throwing when workspace analysis fails (regression)", async () => {
+        const registrar = new FakeRegistrar();
+        const lifecycle = createLifecycle({ diagnostics: [] });
+        lifecycle.analyzeWorkspace.mockRejectedValueOnce(new Error("boom"));
+        (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
+        await expect(getHandler(registrar, "lsp_diagnostics")({ scope: "workspace" })).resolves.toMatchObject({
+            content: [{ type: "text", text: "boom" }],
+            error: true,
+        });
+    });
+    it("reports the standard timeout message when workspace analysis times out (regression)", async () => {
+        const registrar = new FakeRegistrar();
+        const lifecycle = createLifecycle({ diagnostics: [] });
+        lifecycle.analyzeWorkspace.mockRejectedValueOnce(new Error("Workspace diagnostics timed out"));
+        (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
+        await expect(getHandler(registrar, "lsp_diagnostics")({ scope: "workspace" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Operation timed out after 30s — try a more specific query or check the LSP server health",
+                },
+            ],
+            error: true,
+            raw: null,
+        });
+    });
+    it("caps workspace diagnostics at 200 results", async () => {
+        const registrar = new FakeRegistrar();
+        const many = Array.from({ length: 250 }, (_, i) => ({
+            uri: `file:///workspace/src/file${i}.ts`,
+            message: `issue ${i}`,
+            severity: vscode_languageserver_protocol_1.DiagnosticSeverity.Warning,
+            range: {
+                start: { line: 0, character: 0 },
+                end: { line: 0, character: 1 },
+            },
+        }));
+        const lifecycle = createLifecycle({ diagnostics: many });
+        (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
+        const result = (await getHandler(registrar, "lsp_diagnostics")({ scope: "workspace" }));
+        expect(result.raw).toHaveLength(200);
+        expect(result.raw).toEqual(many.slice(0, 200));
+    });
+    it("notes truncated/errored languages in workspace diagnostics text without altering raw (regression)", async () => {
+        const registrar = new FakeRegistrar();
+        const diagnostics = [
+            {
+                uri: "file:///workspace/src/index.ts",
+                message: "Boom",
+                severity: vscode_languageserver_protocol_1.DiagnosticSeverity.Error,
+                range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 1 },
+                },
+            },
+        ];
+        const lifecycle = createLifecycle({ diagnostics });
+        lifecycle.analyzeWorkspace.mockResolvedValueOnce({
+            perLanguage: [
+                { language: "python", opened: 90, failed: 3, truncated: true },
+            ],
+        });
+        (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
+        const result = (await getHandler(registrar, "lsp_diagnostics")({ scope: "workspace" }));
+        expect(result.content[0]?.text).toContain("100-file scan limit");
+        expect(result.content[0]?.text).toContain("python");
+        expect(result.raw).toEqual(diagnostics);
+    });
     it("returns health instantly without LSP requests", async () => {
         const registrar = new FakeRegistrar();
         const lifecycle = createLifecycle({
@@ -461,7 +529,7 @@ function createLifecycle(options) {
         getHealth: jest.fn(() => options.health ?? []),
         ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
         ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined),
-        analyzeWorkspace: jest.fn().mockResolvedValue(undefined),
+        analyzeWorkspace: jest.fn().mockResolvedValue({ perLanguage: [] }),
     };
 }
 function createClient(result) {

package/dist/mcp/__tests__/write-tools.test.js

@@ -219,7 +219,7 @@ describe("registerWriteTools", () => {
             getHealth: jest.fn(() => []),
             ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
             ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined),
-            analyzeWorkspace: jest.fn().mockResolvedValue(undefined),
+            analyzeWorkspace: jest.fn().mockResolvedValue({ perLanguage: [] }),
         };
         (0, write_tools_1.registerWriteTools)(registrar, noClientLifecycle);
         await expect(getHandler(registrar, "lsp_rename")({ file: "/workspace/README.md", line: 0, character: 0, newName: "x" })).resolves.toEqual({
@@ -302,7 +302,7 @@ function createLifecycle(client) {
         getHealth: jest.fn(() => []),
         ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
         ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined),
-        analyzeWorkspace: jest.fn().mockResolvedValue(undefined),
+        analyzeWorkspace: jest.fn().mockResolvedValue({ perLanguage: [] }),
     };
 }
 function createClient(result, capabilities = { renameProvider: true }) {

package/dist/mcp/tools/read-tools.js

@@ -10,6 +10,7 @@ const zod_1 = require("zod");
 const formatters_1 = require("../formatters");
 const uri_1 = require("../../utils/uri");
 const shared_1 = require("./shared");
+const lifecycle_manager_1 = require("../../lsp/lifecycle-manager");
 function registerReadTools(registrar, lifecycleManager, options) {
     registrar.registerTool("lsp_init", {
         description: "Initialize LSP for a project root. Pass languages to pre-warm specific servers; omit to auto-detect from project files (lazy startup per file if none found).",
@@ -86,28 +87,47 @@ function registerReadTools(registrar, lifecycleManager, options) {
     }, async (args) => {
         const filePath = typeof args.file === "string" ? args.file : "";
         const scope = args.scope === "workspace" ? "workspace" : "file";
-        if (filePath) {
-            await lifecycleManager.ensureLanguageForFile(filePath);
-            const client = lifecycleManager.getClientForFile(filePath);
-            if (client) {
-                const waitPromise = client.waitForDiagnosticsPublish(filePath, 10000);
-                await client.ensureDidOpen(filePath);
-                client.notify("textDocument/didSave", {
-                    textDocument: { uri: (0, uri_1.pathToUri)(filePath) },
-                });
-                await waitPromise;
+        const timeoutSeconds = scope === "workspace" ? 30 : 10;
+        try {
+            if (filePath) {
+                await lifecycleManager.ensureLanguageForFile(filePath);
+                const client = lifecycleManager.getClientForFile(filePath);
+                if (client) {
+                    const waitPromise = client.waitForDiagnosticsPublish(filePath, 10000);
+                    await client.ensureDidOpen(filePath);
+                    client.notify("textDocument/didSave", {
+                        textDocument: { uri: (0, uri_1.pathToUri)(filePath) },
+                    });
+                    await waitPromise;
+                }
             }
+            if (scope === "workspace") {
+                const language = typeof args.language === "string" ? args.language : undefined;
+                const summary = await (0, lifecycle_manager_1.promiseWithTimeout)(lifecycleManager.analyzeWorkspace(language), 30000, "Workspace diagnostics timed out");
+                const diagnostics = lifecycleManager
+                    .getWorkspaceDiagnostics(language)
+                    .slice(0, 200);
+                let text = (0, formatters_1.formatDiagnostics)(diagnostics, "workspace");
+                const truncated = summary.perLanguage
+                    .filter((entry) => entry.truncated)
+                    .map((entry) => entry.language);
+                const errored = summary.perLanguage
+                    .filter((entry) => entry.error)
+                    .map((entry) => `${entry.language}: ${entry.error}`);
+                if (truncated.length > 0) {
+                    text += `\n\nNote: hit the 100-file scan limit for: ${truncated.join(", ")}. Results may be incomplete — narrow scope with { language }.`;
+                }
+                if (errored.length > 0) {
+                    text += `\n\nNote: workspace scan failed for: ${errored.join("; ")}. Other languages were unaffected.`;
+                }
+                return (0, shared_1.success)(text, diagnostics);
+            }
+            const diagnostics = lifecycleManager.getFileDiagnostics(filePath);
+            return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, "file"), diagnostics);
         }
-        if (scope === "workspace") {
-            const language = typeof args.language === "string" ? args.language : undefined;
-            await lifecycleManager.analyzeWorkspace(language);
-            const diagnostics = lifecycleManager
-                .getWorkspaceDiagnostics(language)
-                .slice(0, 200);
-            return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, "workspace"), diagnostics);
+        catch (error) {
+            return (0, shared_1.mapToolError)(error, timeoutSeconds);
         }
-        const diagnostics = lifecycleManager.getFileDiagnostics(filePath);
-        return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, "file"), diagnostics);
     });
     registrar.registerTool("lsp_type_definition", { description: "Find type definitions", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theupsider/lsp-mcp",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Universal LSP MCP server",
   "license": "Apache-2.0",
   "type": "commonjs",