@theupsider/lsp-mcp 1.2.0 → 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

@@ -2,32 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const diagnostic_store_1 = require("../diagnostic-store");
 describe('DiagnosticStore', () => {
-    it('replaces diagnostics wholesale per uri on each publish', () => {
+    it("replaces a source's 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')] });
+        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(null);
-        store.store({ uri: 'file:///a.ts' });
-        store.store({ diagnostics: [] });
+        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({
+        store.store('pyright', {
             uri: 'file:///warn.ts',
             diagnostics: [makeDiagnostic(2, 'a warning')],
         });
-        store.store({
+        store.store('pyright', {
             uri: 'file:///error.ts',
             diagnostics: [makeDiagnostic(1, 'an error')],
         });
-        store.store({
+        store.store('pyright', {
             uri: 'file:///hint.ts',
             diagnostics: [makeDiagnostic(4, 'a hint')],
         });
@@ -40,8 +58,8 @@ describe('DiagnosticStore', () => {
     });
     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')] });
+        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' },

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/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

@@ -8,12 +8,18 @@ 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;
@@ -24,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));
@@ -47,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())
@@ -69,7 +93,7 @@ class LifecycleManager {
         return this.store.getForWorkspace(language);
     }
     async analyzeWorkspace(language) {
-        const results = await Promise.allSettled(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);
@@ -109,7 +133,7 @@ class LifecycleManager {
         };
     }
     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;
@@ -118,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`);
@@ -131,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);
+        }
+    }
+    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);
     }
-    createSupervisor(language) {
+    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;

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

@@ -523,6 +523,7 @@ 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 ?? []),

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

@@ -213,6 +213,7 @@ describe("registerWriteTools", () => {
         const registrar = new FakeRegistrar();
         const noClientLifecycle = {
             getClientForFile: jest.fn(() => null),
+            getDiagnosticClientsForFile: jest.fn(() => []),
             getReadyClients: jest.fn(() => []),
             getFileDiagnostics: jest.fn((_) => []),
             getWorkspaceDiagnostics: jest.fn(() => []),
@@ -296,6 +297,7 @@ 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(() => []),

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

@@ -91,15 +91,18 @@ function registerReadTools(registrar, lifecycleManager, options) {
         try {
             if (filePath) {
                 await lifecycleManager.ensureLanguageForFile(filePath);
-                const client = lifecycleManager.getClientForFile(filePath);
-                if (client) {
+                // 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;

package/package.json

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