@theupsider/lsp-mcp 0.1.1 → 0.1.4

package/README.md

@@ -41,6 +41,8 @@ A Model Context Protocol (MCP) server that gives language models access to **Lan
 
 ## Installation
 
+> **Important:** Install `lsp-mcp` on the **same machine where your code lives**. The language servers it manages need direct filesystem access to your codebase — they cannot work over a remote connection or on a different machine than your source files.
+
 ```bash
 # npm
 npm install -g @theupsider/lsp-mcp
@@ -107,7 +109,6 @@ lsp_init({ root: "/path/to/project", languages: ["python", "typescript"] })
 
 | Environment Variable | Description                         | Default      |
 | -------------------- | ----------------------------------- | ------------ |
-| `LSP_MCP_ROOT`       | Project root (auto-calls `lsp_init` on startup) | _(optional)_ |
 | `LSP_MCP_LOG_LEVEL`  | Log level: `error`, `info`, `debug` | `info`       |
 
 ## Setup Scripts
@@ -152,7 +153,7 @@ gem install solargraph
 
 ### Server not detecting language
 
-Ensure your project root contains a language marker file (e.g., `package.json` for TypeScript, `Cargo.toml` for Rust). The server scans the `LSP_MCP_ROOT` directory for these markers.
+Ensure your project root contains a language marker file (e.g., `package.json` for TypeScript, `Cargo.toml` for Rust). The server scans the directory passed to `lsp_init` for these markers.
 
 ### High memory usage
 

package/dist/__tests__/index.test.js

@@ -12,7 +12,7 @@ describe('index entrypoint', () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
-    it('starts and waits for lsp_init when LSP_MCP_ROOT is missing', async () => {
+    it('starts and waits for lsp_init', async () => {
         const stderr = jest.fn();
         const exit = jest.fn();
         const McpServer = jest.requireMock('../mcp/server').McpServer;
@@ -26,19 +26,17 @@ describe('index entrypoint', () => {
     it('prints version and exits for --version', async () => {
         const stdout = jest.fn();
         const exit = jest.fn();
+        const { version } = jest.requireActual('../../package.json');
         await (0, index_1.main)(['--version'], {}, { stdout, exit });
-        expect(stdout).toHaveBeenCalledWith('0.1.0\n');
+        expect(stdout).toHaveBeenCalledWith(`${version}\n`);
         expect(exit).toHaveBeenCalledWith(0);
     });
-    it('boots lifecycle, logs startup report, and starts the MCP server', async () => {
+    it('uses LSP_MCP_LOG_LEVEL and registers signals', async () => {
         const stderr = jest.fn();
         const onSignal = jest.fn();
         const McpServer = jest.requireMock('../mcp/server').McpServer;
-        await (0, index_1.main)([], { LSP_MCP_ROOT: '/workspace', LSP_MCP_LOG_LEVEL: 'debug' }, { stderr, onSignal });
-        const serverInstance = McpServer.mock.results[0]?.value;
+        await (0, index_1.main)([], { LSP_MCP_LOG_LEVEL: 'debug' }, { stderr, onSignal });
         expect(McpServer).toHaveBeenCalledWith('debug');
-        expect(serverInstance.initializeManager).toHaveBeenCalledWith('/workspace');
-        expect(stderr).toHaveBeenCalledWith(`${JSON.stringify({ languages: ['typescript'], started: ['typescript'], errors: [] })}\n`);
         expect(McpServer).toHaveBeenCalledTimes(1);
         expect(onSignal).toHaveBeenCalledTimes(2);
     });

package/dist/detection/language-detector.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectLanguages = detectLanguages;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
+const language_registry_1 = require("./language-registry");
 const MARKER_DEFINITIONS = [
     { language: 'javascript', markers: ['package.json'] },
     { language: 'typescript', markers: ['tsconfig.json'] },
@@ -19,10 +20,7 @@ const MARKER_DEFINITIONS = [
     { language: 'kotlin', markers: ['build.gradle.kts'] },
     { language: 'swift', markers: ['Package.swift'] }
 ];
-const EXTENSION_DEFINITIONS = [
-    { language: 'c', extensions: ['.c', '.h'] },
-    { language: 'cpp', extensions: ['.cpp', '.hpp', '.cc'] }
-];
+const EXTENSION_LANGUAGES = ['c', 'cpp'];
 async function detectLanguages(projectRoot) {
     const entries = await collectEntries(projectRoot, projectRoot);
     const markerMatches = new Map();
@@ -64,14 +62,15 @@ async function detectLanguages(projectRoot) {
             });
         }
     }
-    for (const definition of EXTENSION_DEFINITIONS) {
+    for (const language of EXTENSION_LANGUAGES) {
+        const extensions = (0, language_registry_1.extensionsForLanguage)(language);
         const matches = entries
-            .filter((entry) => definition.extensions.some((extension) => entry.relativePath.endsWith(extension)))
+            .filter((entry) => extensions.some((extension) => entry.relativePath.endsWith(extension)))
             .map((entry) => entry.relativePath)
-            .sort((left, right) => compareByExtensionPriority(left, right, definition.extensions));
+            .sort((left, right) => compareByExtensionPriority(left, right, extensions));
         if (matches.length > 0) {
             detected.push({
-                language: definition.language,
+                language,
                 confidence: 'extension',
                 markers: matches
             });

package/dist/detection/language-registry.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_EXTENSIONS = void 0;
+exports.extensionToLanguage = extensionToLanguage;
+exports.extensionToLanguageId = extensionToLanguageId;
+exports.extensionsForLanguage = extensionsForLanguage;
+const EXTENSION_MAP = {
+    '.ts': { language: 'typescript', languageId: 'typescript' },
+    '.tsx': { language: 'typescript', languageId: 'typescriptreact' },
+    '.js': { language: 'javascript', languageId: 'javascript' },
+    '.jsx': { language: 'javascript', languageId: 'javascriptreact' },
+    '.py': { language: 'python', languageId: 'python' },
+    '.cs': { language: 'csharp', languageId: 'csharp' },
+    '.java': { language: 'java', languageId: 'java' },
+    '.go': { language: 'go', languageId: 'go' },
+    '.rs': { language: 'rust', languageId: 'rust' },
+    '.c': { language: 'c', languageId: 'c' },
+    '.h': { language: 'c', languageId: 'c' },
+    '.cpp': { language: 'cpp', languageId: 'cpp' },
+    '.hpp': { language: 'cpp', languageId: 'cpp' },
+    '.cc': { language: 'cpp', languageId: 'cpp' },
+    '.rb': { language: 'ruby', languageId: 'ruby' },
+    '.php': { language: 'php', languageId: 'php' },
+    '.kt': { language: 'kotlin', languageId: 'kotlin' },
+    '.swift': { language: 'swift', languageId: 'swift' }
+};
+function extensionToLanguage(ext) {
+    return EXTENSION_MAP[ext.toLowerCase()]?.language;
+}
+function extensionToLanguageId(ext) {
+    return EXTENSION_MAP[ext.toLowerCase()]?.languageId ?? 'plaintext';
+}
+function extensionsForLanguage(language) {
+    return Object.entries(EXTENSION_MAP)
+        .filter(([, entry]) => entry.language === language)
+        .map(([ext]) => ext);
+}
+exports.KNOWN_EXTENSIONS = new Set(Object.keys(EXTENSION_MAP));

package/dist/index.js

@@ -22,17 +22,9 @@ async function main(argv = process.argv.slice(2), env = process.env, overrides =
         exit(0);
         return;
     }
-    const projectRoot = env.LSP_MCP_ROOT;
     const logLevel = env.LSP_MCP_LOG_LEVEL ?? 'info';
     const mcpServer = new server_1.McpServer(logLevel);
-    if (projectRoot) {
-        const initialized = await mcpServer.initializeManager(projectRoot);
-        const startupReport = summarizeHealth(initialized.health);
-        stderr(`${JSON.stringify(startupReport)}\n`);
-    }
-    else {
-        stderr(`${JSON.stringify({ event: 'startup', status: 'waiting-for-init' })}\n`);
-    }
+    stderr(`${JSON.stringify({ event: 'startup', status: 'waiting-for-init' })}\n`);
     await mcpServer.start();
     const shutdown = async () => {
         await mcpServer.shutdown();
@@ -41,13 +33,6 @@ async function main(argv = process.argv.slice(2), env = process.env, overrides =
     onSignal('SIGINT', shutdown);
     onSignal('SIGTERM', shutdown);
 }
-function summarizeHealth(health) {
-    return {
-        languages: health.map((entry) => entry.language),
-        started: health.filter((entry) => entry.status === 'ready').map((entry) => entry.language),
-        errors: health.filter((entry) => entry.status === 'error' && entry.error).map((entry) => entry.error)
-    };
-}
 function readVersion() {
     const packageJsonPath = node_path_1.default.resolve(__dirname, '..', 'package.json');
     return JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf8')).version;

package/dist/lsp/__tests__/lifecycle-manager.test.js

@@ -21,6 +21,8 @@ class MockLspClient extends node_events_1.EventEmitter {
     request = jest.fn().mockResolvedValue({ items: [] });
     isReady = jest.fn().mockReturnValue(true);
     getCapabilities = jest.fn().mockReturnValue({ hoverProvider: true });
+    ensureDidOpen = jest.fn().mockResolvedValue(undefined);
+    waitForDiagnosticsPublish = jest.fn().mockResolvedValue(undefined);
 }
 describe('LifecycleManager', () => {
     beforeEach(() => {
@@ -116,7 +118,7 @@ describe('LifecycleManager', () => {
         const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
         const LspClient = jest.requireMock('../lsp-client').LspClient;
         const firstClient = new MockLspClient();
-        firstClient.request.mockRejectedValueOnce(new Error('ping timeout'));
+        firstClient.isReady.mockReturnValue(false);
         const secondClient = new MockLspClient();
         detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
         findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
@@ -126,7 +128,7 @@ describe('LifecycleManager', () => {
         const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
         await manager.start();
         await jest.advanceTimersByTimeAsync(30000);
-        expect(firstClient.request).toHaveBeenCalledWith('workspace/symbol', { query: '__lsp_mcp_healthcheck__' }, 5000);
+        expect(firstClient.isReady).toHaveBeenCalled();
         expect(secondClient.start).toHaveBeenCalled();
         expect(manager.getClient('typescript')).toBe(secondClient);
         await manager.shutdown();
@@ -222,13 +224,13 @@ describe('LifecycleManager', () => {
         const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
         await manager.start();
         const managerAccess = manager;
-        const state = managerAccess.states.get('typescript');
-        expect(state).toBeDefined();
-        if (!state) {
-            throw new Error('Expected typescript state');
+        const supervisor = managerAccess.supervisors.get('typescript');
+        expect(supervisor).toBeDefined();
+        if (!supervisor) {
+            throw new Error('Expected typescript supervisor');
         }
-        state.restartCount = 3;
-        await managerAccess.restartLanguage(state, 'too many restarts');
+        supervisor.restartCount = 3;
+        await supervisor.restart('too many restarts');
         expect(manager.getClient('typescript')).toBeNull();
         expect(manager.getHealth()).toEqual([
             {

package/dist/lsp/diagnostic-store.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticStore = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const language_registry_1 = require("../detection/language-registry");
+const uri_1 = require("../utils/uri");
+class DiagnosticStore {
+    diagnostics = new Map();
+    store(params) {
+        if (!isPublishDiagnosticsParams(params)) {
+            return;
+        }
+        this.diagnostics.set(params.uri, cloneDiagnostics(params.diagnostics));
+    }
+    getForFile(filePath) {
+        const uri = (0, uri_1.pathToUri)(filePath);
+        return (this.diagnostics.get(uri) ?? []).map((diagnostic) => ({ ...diagnostic, uri }));
+    }
+    getForWorkspace(language) {
+        const allowedExtensions = language ? (0, language_registry_1.extensionsForLanguage)(language) : null;
+        return Array.from(this.diagnostics.entries())
+            .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 })))
+            .sort((left, right) => (left.severity ?? 4) - (right.severity ?? 4));
+    }
+}
+exports.DiagnosticStore = DiagnosticStore;
+function isPublishDiagnosticsParams(value) {
+    return typeof value === 'object' && value !== null
+        && 'uri' in value && typeof value.uri === 'string'
+        && 'diagnostics' in value && Array.isArray(value.diagnostics);
+}
+function cloneDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        range: {
+            start: { ...diagnostic.range.start },
+            end: { ...diagnostic.range.end }
+        }
+    }));
+}

package/dist/lsp/lifecycle-manager.js

@@ -6,35 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LifecycleManager = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const language_detector_1 = require("../detection/language-detector");
-const lsp_mapping_1 = require("../detection/lsp-mapping");
-const uri_1 = require("../utils/uri");
-const installer_1 = require("./installer");
-const lsp_client_1 = require("./lsp-client");
-const EXTENSION_LANGUAGE_MAP = {
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.py': 'python',
-    '.cs': 'csharp',
-    '.java': 'java',
-    '.go': 'go',
-    '.rs': 'rust',
-    '.c': 'c',
-    '.h': 'c',
-    '.cpp': 'cpp',
-    '.hpp': 'cpp',
-    '.cc': 'cpp',
-    '.rb': 'ruby',
-    '.php': 'php',
-    '.kt': 'kotlin',
-    '.swift': 'swift'
-};
+const language_registry_1 = require("../detection/language-registry");
+const diagnostic_store_1 = require("./diagnostic-store");
+const server_supervisor_1 = require("./server-supervisor");
 class LifecycleManager {
     projectRoot;
     logLevel;
-    states = new Map();
-    diagnostics = new Map();
+    supervisors = new Map();
+    store = new diagnostic_store_1.DiagnosticStore();
     constructor(projectRoot, logLevel) {
         this.projectRoot = projectRoot;
         this.logLevel = normalizeLogLevel(logLevel);
@@ -44,197 +23,80 @@ class LifecycleManager {
         await promiseWithTimeout(startPromise, 30000, 'Lifecycle start timed out');
     }
     async ensureLanguage(language) {
-        if (this.states.has(language)) {
+        if (this.supervisors.has(language)) {
             return;
         }
-        const state = {
-            language,
-            client: null,
-            status: 'starting',
-            serverDef: null,
-            restartCount: 0,
-            healthInterval: null
-        };
-        this.states.set(language, state);
-        await this.startLanguage(state);
+        const supervisor = this.createSupervisor(language);
+        this.supervisors.set(language, supervisor);
+        await supervisor.start();
     }
     async ensureLanguageForFile(filePath) {
-        const language = EXTENSION_LANGUAGE_MAP[node_path_1.default.extname(filePath).toLowerCase()];
+        const language = (0, language_registry_1.extensionToLanguage)(node_path_1.default.extname(filePath));
         if (language) {
             await this.ensureLanguage(language);
         }
     }
     getClient(language) {
-        return this.states.get(language)?.client ?? null;
+        return this.supervisors.get(language)?.getClient() ?? null;
     }
     getClientForFile(filePath) {
-        const language = EXTENSION_LANGUAGE_MAP[node_path_1.default.extname(filePath).toLowerCase()];
+        const language = (0, language_registry_1.extensionToLanguage)(node_path_1.default.extname(filePath));
         if (language) {
             return this.getClient(language);
         }
         return null;
     }
     getHealth() {
-        return Array.from(this.states.values()).map((state) => ({
-            language: state.language,
-            status: state.status,
-            error: state.error,
-            capabilities: state.capabilities
-        }));
+        return Array.from(this.supervisors.values()).map((supervisor) => supervisor.getHealth());
     }
     getReadyClients(language) {
-        return Array.from(this.states.values())
-            .filter((state) => state.status === 'ready' && state.client && (!language || state.language === language))
-            .flatMap((state) => state.client ? [state.client] : []);
+        return Array.from(this.supervisors.values())
+            .filter((supervisor) => {
+            const health = supervisor.getHealth();
+            return health.status === 'ready' && (!language || supervisor.language === language);
+        })
+            .flatMap((supervisor) => {
+            const client = supervisor.getClient();
+            return client ? [client] : [];
+        });
     }
     getFileDiagnostics(filePath) {
-        const uri = (0, uri_1.pathToUri)(filePath);
-        return (this.diagnostics.get(uri) ?? []).map((diagnostic) => ({ ...diagnostic, uri }));
+        return this.store.getForFile(filePath);
     }
     getWorkspaceDiagnostics(language) {
-        const allowedExtensions = language
-            ? Object.entries(EXTENSION_LANGUAGE_MAP)
-                .filter(([, mappedLanguage]) => mappedLanguage === language)
-                .map(([extension]) => extension)
-            : null;
-        return Array.from(this.diagnostics.entries())
-            .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 })))
-            .sort((left, right) => (left.severity ?? 4) - (right.severity ?? 4));
+        return this.store.getForWorkspace(language);
+    }
+    async ensureSeedFilesOpen() {
+        await Promise.all(Array.from(this.supervisors.entries()).map(async ([language, supervisor]) => {
+            const client = supervisor.getClient();
+            if (!client)
+                return;
+            const extensions = (0, language_registry_1.extensionsForLanguage)(language);
+            await client.ensureSeedFileOpen(extensions);
+        }));
     }
     async shutdown() {
-        const clients = Array.from(this.states.values()).flatMap((state) => {
-            if (state.healthInterval) {
-                clearInterval(state.healthInterval);
-                state.healthInterval = null;
-            }
-            return state.client ? [state.client] : [];
-        });
-        const results = await Promise.allSettled(clients.map(async (client) => await promiseWithTimeout(client.shutdown(), 5000, 'LSP shutdown timed out')));
+        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;
-        process.stderr.write(`{"timestamp":"${new Date().toISOString()}","level":"info","event":"Shutdown: ${clients.length - errors} LSP-Server beendet, ${errors} Fehler"}\n`);
+        process.stderr.write(`{"timestamp":"${new Date().toISOString()}","level":"info","event":"Shutdown: ${supervisors.length - errors} LSP-Server beendet, ${errors} Fehler"}\n`);
     }
     async startInternal(languages) {
         const detected = languages
             ? languages.map((language) => ({ language }))
             : await (0, language_detector_1.detectLanguages)(this.projectRoot);
         for (const entry of detected) {
-            const state = {
-                language: entry.language,
-                client: null,
-                status: 'starting',
-                serverDef: null,
-                restartCount: 0,
-                healthInterval: null
-            };
-            this.states.set(entry.language, state);
-            await this.startLanguage(state);
+            const supervisor = this.createSupervisor(entry.language);
+            this.supervisors.set(entry.language, supervisor);
+            await supervisor.start();
         }
     }
-    async startLanguage(state) {
-        const serverDef = await this.resolveServer(state.language);
-        if (!serverDef) {
-            state.status = 'error';
-            state.error = `No LSP server available for ${state.language}`;
-            return;
-        }
-        state.serverDef = serverDef;
-        const client = new lsp_client_1.LspClient(serverDef, this.projectRoot, this.logLevel);
-        state.client = client;
-        client.on('crash', async () => {
-            await this.restartLanguage(state, `LSP server crashed for ${state.language}`);
-        });
-        client.on('error', (error) => {
-            state.status = 'error';
-            state.error = error instanceof Error ? error.message : 'Unknown LSP error';
-        });
-        client.on('notification', (method, params) => {
+    createSupervisor(language) {
+        return new server_supervisor_1.ServerSupervisor(language, this.projectRoot, this.logLevel, (method, params) => {
             if (method === 'textDocument/publishDiagnostics') {
-                this.storeDiagnostics(params);
+                this.store.store(params);
             }
         });
-        try {
-            await client.start();
-            state.status = 'ready';
-            state.error = undefined;
-            state.capabilities = client.getCapabilities() ?? undefined;
-            this.startHealthChecks(state);
-        }
-        catch (error) {
-            state.status = 'error';
-            state.error = error instanceof Error ? error.message : 'Unknown LSP startup error';
-        }
-    }
-    startHealthChecks(state) {
-        if (state.healthInterval) {
-            clearInterval(state.healthInterval);
-        }
-        state.healthInterval = setInterval(() => {
-            void this.runHealthCheck(state);
-        }, 30000);
-    }
-    async runHealthCheck(state) {
-        if (!state.client || state.status !== 'ready') {
-            return;
-        }
-        try {
-            await state.client.request('workspace/symbol', { query: '__lsp_mcp_healthcheck__' }, 5000);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'LSP health check failed';
-            await this.restartLanguage(state, message);
-        }
-    }
-    async restartLanguage(state, reason) {
-        if (state.healthInterval) {
-            clearInterval(state.healthInterval);
-            state.healthInterval = null;
-        }
-        if (state.restartCount >= 3) {
-            state.status = 'error';
-            state.error = reason;
-            state.client = null;
-            return;
-        }
-        state.restartCount += 1;
-        state.status = 'starting';
-        state.error = reason;
-        if (state.client) {
-            try {
-                await promiseWithTimeout(state.client.shutdown(), 5000, 'LSP shutdown timed out');
-            }
-            catch {
-                // Ignore shutdown failures during restart.
-            }
-        }
-        state.client = null;
-        await this.startLanguage(state);
-    }
-    async resolveServer(language) {
-        const available = await (0, lsp_mapping_1.findAvailableLsp)(language);
-        if (available) {
-            return available;
-        }
-        const candidate = (0, lsp_mapping_1.getLspCandidates)(language)[0] ?? null;
-        if (!candidate) {
-            return null;
-        }
-        const installation = await (0, installer_1.installLsp)(candidate);
-        if (!installation.success) {
-            return null;
-        }
-        return candidate;
-    }
-    storeDiagnostics(params) {
-        if (!isPublishDiagnosticsParams(params)) {
-            return;
-        }
-        this.diagnostics.set(params.uri, cloneDiagnostics(params.diagnostics));
     }
 }
 exports.LifecycleManager = LifecycleManager;
@@ -244,20 +106,6 @@ function normalizeLogLevel(level) {
     }
     return 'info';
 }
-function isPublishDiagnosticsParams(value) {
-    return typeof value === 'object' && value !== null
-        && 'uri' in value && typeof value.uri === 'string'
-        && 'diagnostics' in value && Array.isArray(value.diagnostics);
-}
-function cloneDiagnostics(diagnostics) {
-    return diagnostics.map((diagnostic) => ({
-        ...diagnostic,
-        range: {
-            start: { ...diagnostic.range.start },
-            end: { ...diagnostic.range.end }
-        }
-    }));
-}
 async function promiseWithTimeout(promise, timeoutMs, message) {
     return await new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(message)), timeoutMs);