@theupsider/lsp-mcp 1.1.2 → 1.3.0

package/dist/detection/__tests__/lsp-mapping.test.js

@@ -14,6 +14,12 @@ describe('lsp-mapping', () => {
             { cmd: 'pylsp', args: [], pkg: 'python-lsp-server', mgr: 'pip' }
         ]);
     });
+    it('returns ruff as the python linter candidate, run alongside the primary server', () => {
+        expect((0, lsp_mapping_1.getLinterCandidates)('python')).toEqual([
+            { cmd: 'ruff', args: ['server', '--quiet'], pkg: 'ruff', mgr: 'pip' }
+        ]);
+        expect((0, lsp_mapping_1.getLinterCandidates)('typescript')).toEqual([]);
+    });
     it('returns the full supported language list and shared candidate mappings', () => {
         expect(lsp_mapping_1.SUPPORTED_LANGUAGES).toEqual([
             'python',
@@ -69,6 +75,7 @@ describe('lsp-mapping', () => {
             process.env.PATH = binDir;
             await expect((0, lsp_mapping_1.findAvailableLsp)('swift')).resolves.toBeNull();
             await expect((0, lsp_mapping_1.findAvailableLsp)('unknown')).resolves.toBeNull();
+            await expect((0, lsp_mapping_1.findAvailableLinter)('python')).resolves.toBeNull();
         }
         finally {
             process.env.PATH = originalPath;

package/dist/detection/lsp-mapping.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUPPORTED_LANGUAGES = void 0;
 exports.getLspCandidates = getLspCandidates;
+exports.getLinterCandidates = getLinterCandidates;
 exports.findAvailableLsp = findAvailableLsp;
+exports.findAvailableLinter = findAvailableLinter;
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
@@ -12,6 +14,14 @@ const TYPESCRIPT_CANDIDATES = [
 const CLANGD_CANDIDATES = [
     { cmd: 'clangd', args: [], pkg: 'clangd', mgr: 'apt' }
 ];
+// Linters that run alongside (not instead of) the primary language server for a
+// language, so their diagnostics (e.g. ruff lint rules) show up next to the
+// primary server's diagnostics (e.g. pyright type errors) instead of being lost.
+const LANGUAGE_TO_LINTERS = {
+    python: [
+        { cmd: 'ruff', args: ['server', '--quiet'], pkg: 'ruff', mgr: 'pip' }
+    ]
+};
 const LANGUAGE_TO_CANDIDATES = {
     python: [
         { cmd: 'pyright-langserver', args: ['--stdio'], pkg: 'pyright', mgr: 'npm' },
@@ -65,8 +75,16 @@ exports.SUPPORTED_LANGUAGES = Object.freeze([
 function getLspCandidates(language) {
     return LANGUAGE_TO_CANDIDATES[language]?.map((candidate) => ({ ...candidate, args: [...candidate.args] })) ?? [];
 }
+function getLinterCandidates(language) {
+    return LANGUAGE_TO_LINTERS[language]?.map((candidate) => ({ ...candidate, args: [...candidate.args] })) ?? [];
+}
 async function findAvailableLsp(language) {
-    const candidates = getLspCandidates(language);
+    return await findFirstAvailable(getLspCandidates(language));
+}
+async function findAvailableLinter(language) {
+    return await findFirstAvailable(getLinterCandidates(language));
+}
+async function findFirstAvailable(candidates) {
     for (const candidate of candidates) {
         if (await commandExists(candidate.cmd)) {
             return candidate;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const diagnostic_store_1 = require("../diagnostic-store");
+describe('DiagnosticStore', () => {
+    it("replaces a source's diagnostics wholesale per uri on each publish", () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store('pyright', { uri: 'file:///a.ts', diagnostics: [makeDiagnostic(1, 'first')] });
+        store.store('pyright', { uri: 'file:///a.ts', diagnostics: [makeDiagnostic(2, 'second')] });
+        expect(store.getForFile('/a.ts')).toEqual([
+            { ...makeDiagnostic(2, 'second'), uri: 'file:///a.ts' },
+        ]);
+    });
+    it('merges diagnostics from multiple sources for the same uri instead of overwriting', () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store('pyright', { uri: 'file:///a.py', diagnostics: [makeDiagnostic(1, 'type error')] });
+        store.store('ruff', { uri: 'file:///a.py', diagnostics: [makeDiagnostic(2, 'unused import')] });
+        expect(store.getForFile('/a.py')).toEqual([
+            { ...makeDiagnostic(1, 'type error'), uri: 'file:///a.py' },
+            { ...makeDiagnostic(2, 'unused import'), uri: 'file:///a.py' },
+        ]);
+    });
+    it("only replaces the publishing source's diagnostics, leaving other sources intact", () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store('pyright', { uri: 'file:///a.py', diagnostics: [makeDiagnostic(1, 'type error')] });
+        store.store('ruff', { uri: 'file:///a.py', diagnostics: [makeDiagnostic(2, 'unused import')] });
+        store.store('ruff', { uri: 'file:///a.py', diagnostics: [] });
+        expect(store.getForFile('/a.py')).toEqual([
+            { ...makeDiagnostic(1, 'type error'), uri: 'file:///a.py' },
+        ]);
+    });
+    it('ignores malformed publishDiagnostics payloads', () => {
+        const store = new diagnostic_store_1.DiagnosticStore();
+        store.store('pyright', null);
+        store.store('pyright', { uri: 'file:///a.ts' });
+        store.store('pyright', { 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('pyright', {
+            uri: 'file:///warn.ts',
+            diagnostics: [makeDiagnostic(2, 'a warning')],
+        });
+        store.store('pyright', {
+            uri: 'file:///error.ts',
+            diagnostics: [makeDiagnostic(1, 'an error')],
+        });
+        store.store('pyright', {
+            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('pyright', { uri: 'file:///a.ts', diagnostics: [makeDiagnostic(1, 'ts issue')] });
+        store.store('pyright', { 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__/lifecycle-manager.test.js

@@ -7,7 +7,9 @@ jest.mock('../../detection/language-detector', () => ({
 }));
 jest.mock('../../detection/lsp-mapping', () => ({
     findAvailableLsp: jest.fn(),
-    getLspCandidates: jest.fn()
+    getLspCandidates: jest.fn(),
+    findAvailableLinter: jest.fn(),
+    getLinterCandidates: jest.fn().mockReturnValue([])
 }));
 jest.mock('../installer', () => ({
     installLsp: jest.fn()
@@ -287,4 +289,47 @@ describe('LifecycleManager', () => {
         expect(manager.getWorkspaceDiagnostics()).toEqual([]);
         await manager.shutdown();
     });
+    it('merges diagnostics from a linter server alongside the primary server for the same language', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const findAvailableLinter = jest.requireMock('../../detection/lsp-mapping').findAvailableLinter;
+        const getLinterCandidates = jest.requireMock('../../detection/lsp-mapping').getLinterCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const ruffCandidate = { cmd: 'ruff', args: ['server', '--quiet'], pkg: 'ruff', mgr: 'pip' };
+        const pyrightClient = new MockLspClient();
+        const ruffClient = new MockLspClient();
+        detectLanguages.mockResolvedValue([{ language: 'python', confidence: 'marker', markers: ['pyproject.toml'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'pyright-langserver', args: ['--stdio'], pkg: 'pyright', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        getLinterCandidates.mockReturnValue([ruffCandidate]);
+        findAvailableLinter.mockResolvedValue(ruffCandidate);
+        LspClient.mockImplementationOnce(() => pyrightClient);
+        LspClient.mockImplementationOnce(() => ruffClient);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        pyrightClient.emit('notification', 'textDocument/publishDiagnostics', {
+            uri: 'file:///workspace/project/app.py',
+            diagnostics: [{ message: 'Incompatible type', severity: 1, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }]
+        });
+        ruffClient.emit('notification', 'textDocument/publishDiagnostics', {
+            uri: 'file:///workspace/project/app.py',
+            diagnostics: [{ message: 'F401 unused import', severity: 2, range: { start: { line: 1, character: 0 }, end: { line: 1, character: 1 } } }]
+        });
+        expect(manager.getFileDiagnostics('/workspace/project/app.py').map((d) => d.message)).toEqual([
+            'Incompatible type',
+            'F401 unused import'
+        ]);
+        // Navigation/rename/format stay pinned to the primary server, not the linter.
+        expect(manager.getClient('python')).toBe(pyrightClient);
+        expect(manager.getReadyClients('python')).toEqual([pyrightClient]);
+        // Both servers are started and both surface in health.
+        expect(manager.getHealth()).toEqual([
+            { language: 'python', status: 'ready', capabilities: { hoverProvider: true } },
+            { language: 'python', status: 'ready', capabilities: { hoverProvider: true } }
+        ]);
+        // File-scope diagnostics touch every diagnostic-contributing server.
+        expect(manager.getDiagnosticClientsForFile('/workspace/project/app.py')).toEqual([pyrightClient, ruffClient]);
+        await manager.shutdown();
+    });
 });

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/diagnostic-store.js

@@ -8,29 +8,44 @@ const node_path_1 = __importDefault(require("node:path"));
 const language_registry_1 = require("../detection/language-registry");
 const uri_1 = require("../utils/uri");
 class DiagnosticStore {
+    // uri -> sourceId -> diagnostics. Keying by source lets multiple servers for the
+    // same language (e.g. pyright's type checks and ruff's lint rules) publish
+    // diagnostics for the same file without one server's publish overwriting another's.
     diagnostics = new Map();
-    store(params) {
+    store(sourceId, params) {
         if (!isPublishDiagnosticsParams(params)) {
             return;
         }
-        this.diagnostics.set(params.uri, cloneDiagnostics(params.diagnostics));
+        let bySource = this.diagnostics.get(params.uri);
+        if (!bySource) {
+            bySource = new Map();
+            this.diagnostics.set(params.uri, bySource);
+        }
+        bySource.set(sourceId, cloneDiagnostics(params.diagnostics));
     }
     getForFile(filePath) {
         const uri = (0, uri_1.pathToUri)(filePath);
-        return (this.diagnostics.get(uri) ?? []).map((diagnostic) => ({ ...diagnostic, uri }));
+        return this.flatten(uri);
     }
     getForWorkspace(language) {
         const allowedExtensions = language ? (0, language_registry_1.extensionsForLanguage)(language) : null;
-        return Array.from(this.diagnostics.entries())
-            .filter(([uri]) => {
+        return Array.from(this.diagnostics.keys())
+            .filter((uri) => {
             if (!allowedExtensions) {
                 return true;
             }
             return allowedExtensions.includes(node_path_1.default.extname((0, uri_1.uriToPath)(uri)).toLowerCase());
         })
-            .flatMap(([uri, diagnostics]) => diagnostics.map((diagnostic) => ({ ...diagnostic, uri })))
+            .flatMap((uri) => this.flatten(uri))
             .sort((left, right) => (left.severity ?? 4) - (right.severity ?? 4));
     }
+    flatten(uri) {
+        const bySource = this.diagnostics.get(uri);
+        if (!bySource) {
+            return [];
+        }
+        return Array.from(bySource.values()).flatMap((diagnostics) => diagnostics.map((diagnostic) => ({ ...diagnostic, uri })));
+    }
 }
 exports.DiagnosticStore = DiagnosticStore;
 function isPublishDiagnosticsParams(value) {

package/dist/lsp/lifecycle-manager.js

@@ -4,15 +4,22 @@ 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");
+const lsp_mapping_1 = require("../detection/lsp-mapping");
 const diagnostic_store_1 = require("./diagnostic-store");
 const server_supervisor_1 = require("./server-supervisor");
 class LifecycleManager {
     projectRoot;
     logLevel;
     supervisors = new Map();
+    // Secondary servers that run alongside the primary one for a language purely to
+    // contribute diagnostics (e.g. ruff's lint rules alongside pyright's type checks).
+    // They are never returned by getClient/getReadyClients, which stay scoped to the
+    // primary server so navigation/formatting/rename requests keep going to one place.
+    linterSupervisors = new Map();
     store = new diagnostic_store_1.DiagnosticStore();
     constructor(projectRoot, logLevel) {
         this.projectRoot = projectRoot;
@@ -23,12 +30,12 @@ class LifecycleManager {
         await promiseWithTimeout(startPromise, 30000, "Lifecycle start timed out");
     }
     async ensureLanguage(language) {
-        if (this.supervisors.has(language)) {
-            return;
+        if (!this.supervisors.has(language)) {
+            const supervisor = this.createSupervisor(language);
+            this.supervisors.set(language, supervisor);
+            await supervisor.start();
         }
-        const supervisor = this.createSupervisor(language);
-        this.supervisors.set(language, supervisor);
-        await supervisor.start();
+        await this.ensureLinter(language);
     }
     async ensureLanguageForFile(filePath) {
         const language = (0, language_registry_1.extensionToLanguage)(node_path_1.default.extname(filePath));
@@ -46,8 +53,26 @@ class LifecycleManager {
         }
         return null;
     }
+    // All ready clients contributing diagnostics for a file's language: the primary
+    // language server plus any linter servers (e.g. ruff for python). Used so a single
+    // lsp_diagnostics(file) call opens/saves the file on every diagnostic source instead
+    // of only the primary one.
+    getDiagnosticClientsForFile(filePath) {
+        const language = (0, language_registry_1.extensionToLanguage)(node_path_1.default.extname(filePath));
+        if (!language) {
+            return [];
+        }
+        return [this.supervisors.get(language), this.linterSupervisors.get(language)]
+            .filter((supervisor) => {
+            return !!supervisor && supervisor.getHealth().status === "ready";
+        })
+            .flatMap((supervisor) => {
+            const client = supervisor.getClient();
+            return client ? [client] : [];
+        });
+    }
     getHealth() {
-        return Array.from(this.supervisors.values()).map((supervisor) => supervisor.getHealth());
+        return this.allSupervisors().map((supervisor) => supervisor.getHealth());
     }
     getReadyClients(language) {
         return Array.from(this.supervisors.values())
@@ -68,21 +93,47 @@ class LifecycleManager {
         return this.store.getForWorkspace(language);
     }
     async analyzeWorkspace(language) {
-        await Promise.all(Array.from(this.supervisors.entries())
+        const results = await Promise.allSettled(this.allSupervisorEntries()
             .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]) => {
+        await Promise.all(this.allSupervisorEntries().map(async ([language, supervisor]) => {
             const client = supervisor.getClient();
             if (!client)
                 return;
@@ -91,7 +142,7 @@ class LifecycleManager {
         }));
     }
     async shutdown() {
-        const supervisors = Array.from(this.supervisors.values());
+        const supervisors = this.allSupervisors();
         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`);
@@ -104,14 +155,36 @@ class LifecycleManager {
             const supervisor = this.createSupervisor(entry.language);
             this.supervisors.set(entry.language, supervisor);
             await supervisor.start();
+            await this.ensureLinter(entry.language);
         }
     }
-    createSupervisor(language) {
+    async ensureLinter(language) {
+        if (this.linterSupervisors.has(language)) {
+            return;
+        }
+        if ((0, lsp_mapping_1.getLinterCandidates)(language).length === 0) {
+            return;
+        }
+        const supervisor = this.createSupervisor(language, true);
+        this.linterSupervisors.set(language, supervisor);
+        await supervisor.start();
+    }
+    allSupervisors() {
+        return this.allSupervisorEntries().map(([, supervisor]) => supervisor);
+    }
+    allSupervisorEntries() {
+        return [
+            ...Array.from(this.supervisors.entries()),
+            ...Array.from(this.linterSupervisors.entries()),
+        ];
+    }
+    createSupervisor(language, linter = false) {
+        const sourceId = linter ? `${language}:lint` : language;
         return new server_supervisor_1.ServerSupervisor(language, this.projectRoot, this.logLevel, (method, params) => {
             if (method === "textDocument/publishDiagnostics") {
-                this.store.store(params);
+                this.store.store(sourceId, params);
             }
-        });
+        }, linter);
     }
 }
 exports.LifecycleManager = LifecycleManager;

package/dist/lsp/lsp-client.js

@@ -117,7 +117,9 @@ class LspClient extends node_events_1.EventEmitter {
             this.ready = false;
             return;
         }
-        await this.request("shutdown", {}, 5000);
+        // The LSP spec defines shutdown as taking no params; strict servers (e.g. ruff,
+        // written in Rust with serde) reject an empty object `{}` as "expected unit".
+        await this.request("shutdown", null, 5000);
         this.notify("exit", {});
         this.ready = false;
         const currentProcess = this.process;
@@ -176,13 +178,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 +316,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/lsp/server-supervisor.js

@@ -15,12 +15,14 @@ class ServerSupervisor {
     projectRoot;
     logLevel;
     onDiagnostics;
+    linter;
     shuttingDown = false;
-    constructor(language, projectRoot, logLevel, onDiagnostics) {
+    constructor(language, projectRoot, logLevel, onDiagnostics, linter = false) {
         this.language = language;
         this.projectRoot = projectRoot;
         this.logLevel = logLevel;
         this.onDiagnostics = onDiagnostics;
+        this.linter = linter;
     }
     async start() {
         const serverDef = await this.resolveServer();
@@ -121,11 +123,15 @@ class ServerSupervisor {
         }
     }
     async resolveServer() {
-        const available = await (0, lsp_mapping_1.findAvailableLsp)(this.language);
+        const available = this.linter
+            ? await (0, lsp_mapping_1.findAvailableLinter)(this.language)
+            : await (0, lsp_mapping_1.findAvailableLsp)(this.language);
         if (available) {
             return available;
         }
-        const candidate = (0, lsp_mapping_1.getLspCandidates)(this.language)[0] ?? null;
+        const candidate = (this.linter
+            ? (0, lsp_mapping_1.getLinterCandidates)(this.language)
+            : (0, lsp_mapping_1.getLspCandidates)(this.language))[0] ?? null;
         if (!candidate) {
             return null;
         }

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({
@@ -455,13 +523,14 @@ function getHandler(registrar, name) {
 function createLifecycle(options) {
     return {
         getClientForFile: jest.fn((_) => options.fileClient ?? null),
+        getDiagnosticClientsForFile: jest.fn((_) => options.fileClient ? [options.fileClient] : []),
         getReadyClients: jest.fn((_) => options.workspaceClients ?? []),
         getFileDiagnostics: jest.fn((_) => (options.diagnostics ?? []).filter((diagnostic) => diagnostic.uri === "file:///workspace/src/index.ts")),
         getWorkspaceDiagnostics: jest.fn((_) => options.diagnostics ?? []),
         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

@@ -213,13 +213,14 @@ describe("registerWriteTools", () => {
         const registrar = new FakeRegistrar();
         const noClientLifecycle = {
             getClientForFile: jest.fn(() => null),
+            getDiagnosticClientsForFile: jest.fn(() => []),
             getReadyClients: jest.fn(() => []),
             getFileDiagnostics: jest.fn((_) => []),
             getWorkspaceDiagnostics: jest.fn(() => []),
             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({
@@ -296,13 +297,14 @@ function getHandler(registrar, name) {
 function createLifecycle(client) {
     return {
         getClientForFile: jest.fn((_) => client),
+        getDiagnosticClientsForFile: jest.fn((_) => [client]),
         getReadyClients: jest.fn(() => [client]),
         getFileDiagnostics: jest.fn((_) => []),
         getWorkspaceDiagnostics: jest.fn(() => []),
         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/server.js

@@ -190,6 +190,7 @@ class McpServer {
     createLifecycleProxy() {
         return {
             getClientForFile: (filePath) => this.requireManager().getClientForFile(filePath),
+            getDiagnosticClientsForFile: (filePath) => this.requireManager().getDiagnosticClientsForFile(filePath),
             getReadyClients: (language) => this.requireManager().getReadyClients(language),
             getFileDiagnostics: (filePath) => this.requireManager().getFileDiagnostics(filePath),
             getWorkspaceDiagnostics: (language) => this.requireManager().getWorkspaceDiagnostics(language),

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,50 @@ 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);
+                // Trigger analysis on every diagnostic source for this file's language
+                // (e.g. both pyright and ruff for python), not just the primary server,
+                // so the merged result includes type errors and lint findings alike.
+                const clients = lifecycleManager.getDiagnosticClientsForFile(filePath);
+                await Promise.all(clients.map(async (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.3.0",
   "description": "Universal LSP MCP server",
   "license": "Apache-2.0",
   "type": "commonjs",