@theupsider/lsp-mcp 0.1.0

package/dist/mcp/__tests__/server.test.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockSetRequestHandler = jest.fn();
+const mockConnect = jest.fn().mockResolvedValue(undefined);
+jest.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
+    McpServer: jest.fn().mockImplementation(() => ({
+        connect: mockConnect,
+        server: {
+            setRequestHandler: mockSetRequestHandler
+        }
+    }))
+}));
+jest.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+    StdioServerTransport: jest.fn().mockImplementation(() => ({ kind: 'stdio' }))
+}));
+jest.mock('@modelcontextprotocol/sdk/server/zod-compat.js', () => ({
+    normalizeObjectSchema: jest.fn().mockReturnValue(null)
+}));
+jest.mock('@modelcontextprotocol/sdk/server/zod-json-schema-compat.js', () => ({
+    toJsonSchemaCompat: jest.fn().mockReturnValue({})
+}));
+jest.mock('../tools/read-tools', () => ({ registerReadTools: jest.fn() }));
+jest.mock('../tools/write-tools', () => ({ registerWriteTools: jest.fn() }));
+const server_1 = require("../server");
+function getHandler(schema) {
+    const call = mockSetRequestHandler.mock.calls.find(([s]) => s === schema);
+    if (!call)
+        throw new Error(`No handler registered for schema`);
+    return call[1];
+}
+describe('McpServer', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('registers request handlers and connects on start', async () => {
+        const server = new server_1.McpServer('info');
+        await server.start();
+        expect(mockSetRequestHandler).toHaveBeenCalledTimes(2);
+        expect(mockConnect).toHaveBeenCalledWith({ kind: 'stdio' });
+    });
+    it('lists all registered tools regardless of init state', async () => {
+        const readTools = jest.requireMock('../tools/read-tools').registerReadTools;
+        const writeTools = jest.requireMock('../tools/write-tools').registerWriteTools;
+        readTools.mockImplementationOnce((registrar) => {
+            registrar.registerTool('lsp_init', { description: 'init' }, async () => ({ content: [{ type: 'text', text: 'ok' }], raw: null }));
+            registrar.registerTool('lsp_hover', { description: 'hover' }, async () => ({ content: [{ type: 'text', text: 'hover' }], raw: null }));
+        });
+        writeTools.mockImplementationOnce(() => undefined);
+        const { ListToolsRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
+        const server = new server_1.McpServer('info');
+        await server.start();
+        const listHandler = getHandler(ListToolsRequestSchema);
+        const result = await listHandler({});
+        expect(result.tools.map((t) => t.name)).toContain('lsp_init');
+        expect(result.tools.map((t) => t.name)).toContain('lsp_hover');
+    });
+    it('lists all tools after initialization too', async () => {
+        const readTools = jest.requireMock('../tools/read-tools').registerReadTools;
+        const writeTools = jest.requireMock('../tools/write-tools').registerWriteTools;
+        readTools.mockImplementationOnce((registrar) => {
+            registrar.registerTool('lsp_init', { description: 'init' }, async () => ({ content: [{ type: 'text', text: 'ok' }], raw: null }));
+            registrar.registerTool('lsp_hover', { description: 'hover' }, async () => ({ content: [{ type: 'text', text: 'hover' }], raw: null }));
+        });
+        writeTools.mockImplementationOnce(() => undefined);
+        const { ListToolsRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
+        const server = new server_1.McpServer('info');
+        await server.start();
+        server.setManager({});
+        const listHandler = getHandler(ListToolsRequestSchema);
+        const result = await listHandler({});
+        expect(result.tools.map((t) => t.name)).toContain('lsp_init');
+        expect(result.tools.map((t) => t.name)).toContain('lsp_hover');
+    });
+    it('returns no-root error for non-init tools before lsp_init', async () => {
+        const readTools = jest.requireMock('../tools/read-tools').registerReadTools;
+        const writeTools = jest.requireMock('../tools/write-tools').registerWriteTools;
+        readTools.mockImplementationOnce((registrar) => {
+            registrar.registerTool('lsp_hover', { description: 'hover' }, async () => ({ content: [{ type: 'text', text: 'reachable' }], raw: null }));
+        });
+        writeTools.mockImplementationOnce(() => undefined);
+        const { CallToolRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
+        const server = new server_1.McpServer('info');
+        await server.start();
+        const callHandler = getHandler(CallToolRequestSchema);
+        const result = await callHandler({ params: { name: 'lsp_hover', arguments: {} } });
+        expect(result.content[0].text).toMatch(/No project root set/);
+    });
+    it('re-initializes with new root when lsp_init called again', async () => {
+        const readTools = jest.requireMock('../tools/read-tools').registerReadTools;
+        const writeTools = jest.requireMock('../tools/write-tools').registerWriteTools;
+        readTools.mockImplementationOnce((registrar) => {
+            registrar.registerTool('lsp_init', { description: 'init' }, async () => ({ content: [{ type: 'text', text: 'ok' }], raw: null }));
+        });
+        writeTools.mockImplementationOnce(() => undefined);
+        const { CallToolRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
+        const server = new server_1.McpServer('info');
+        await server.start();
+        server.setManager({});
+        const callHandler = getHandler(CallToolRequestSchema);
+        const result = await callHandler({ params: { name: 'lsp_init', arguments: { root: '/x' } } });
+        expect(result.content[0].text).toMatch(/Already initialized/);
+    });
+    it('shuts down the old manager before starting a new one', async () => {
+        const order = [];
+        const firstManager = {
+            start: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockImplementation(async () => { order.push('shutdown-first'); }),
+            getHealth: jest.fn().mockReturnValue([{ language: 'typescript', status: 'ready' }])
+        };
+        const secondManager = {
+            start: jest.fn().mockImplementation(async () => { order.push('start-second'); }),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            getHealth: jest.fn().mockReturnValue([{ language: 'python', status: 'ready' }])
+        };
+        const factory = jest.fn()
+            .mockReturnValueOnce(firstManager)
+            .mockReturnValueOnce(secondManager);
+        const server = new server_1.McpServer('debug', factory);
+        await expect(server.initializeManager('/workspace-one')).resolves.toEqual({
+            root: '/workspace-one',
+            health: [{ language: 'typescript', status: 'ready' }]
+        });
+        await expect(server.initializeManager('/workspace-two')).resolves.toEqual({
+            root: '/workspace-two',
+            health: [{ language: 'python', status: 'ready' }]
+        });
+        expect(order).toEqual(['shutdown-first', 'start-second']);
+    });
+    it('tolerates shutdown with no active manager', async () => {
+        const server = new server_1.McpServer('info');
+        await expect(server.shutdown()).resolves.toBeUndefined();
+    });
+    it('shuts down active manager on server shutdown', async () => {
+        const manager = { shutdown: jest.fn().mockResolvedValue(undefined) };
+        const server = new server_1.McpServer('info');
+        server.setManager(manager);
+        await server.shutdown();
+        expect(manager.shutdown).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const shared_1 = require("../tools/shared");
+const write_tools_1 = require("../tools/write-tools");
+jest.mock('node:fs/promises', () => ({
+    access: jest.fn(),
+    readFile: jest.fn(),
+    writeFile: jest.fn()
+}));
+class FakeRegistrar {
+    tools = new Map();
+    registerTool(name, _config, handler) {
+        this.tools.set(name, { handler });
+    }
+}
+describe('registerWriteTools', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        (0, shared_1.clearOpenedFiles)();
+        promises_1.access.mockResolvedValue(undefined);
+        promises_1.readFile.mockImplementation(async (filePath) => {
+            const pathText = String(filePath);
+            if (pathText.endsWith('.editorconfig')) {
+                return 'root = true\n[*]\nindent_size = 2\nindent_style = space\n';
+            }
+            return 'const foo = oldName\n';
+        });
+        promises_1.writeFile.mockResolvedValue(undefined);
+    });
+    it('renames symbols when the server supports rename and saves the changed file', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient({
+            changes: {
+                'file:///workspace/src/index.ts': [{ range: { start: { line: 0, character: 12 }, end: { line: 0, character: 19 } }, newText: 'newName' }]
+            }
+        });
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        const result = await getHandler(registrar, 'lsp_rename')({ file: '/workspace/src/index.ts', line: 0, character: 12, newName: 'newName' });
+        expect(client.request).toHaveBeenCalledWith('textDocument/rename', {
+            textDocument: { uri: 'file:///workspace/src/index.ts' },
+            position: { line: 0, character: 12 },
+            newName: 'newName'
+        }, 15000);
+        expect(promises_1.writeFile).toHaveBeenCalledWith('/workspace/src/index.ts', 'const foo = newName\n', 'utf8');
+        expect(client.notify).toHaveBeenCalledWith('textDocument/didSave', { textDocument: { uri: 'file:///workspace/src/index.ts' } });
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Applied workspace edit to 1 file(s)' }],
+            raw: { changedFiles: ['/workspace/src/index.ts'] }
+        });
+    });
+    it('returns an error when rename is unsupported', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient(null, { renameProvider: false });
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        await expect(getHandler(registrar, 'lsp_rename')({ file: '/workspace/src/index.ts', line: 0, character: 0, newName: 'x' })).resolves.toEqual({
+            content: [{ type: 'text', text: 'Rename is not supported by the active language server.' }],
+            error: true,
+            raw: null
+        });
+    });
+    it('lists code actions without applying them', async () => {
+        const registrar = new FakeRegistrar();
+        const actions = [{ title: 'Fix import', kind: 'quickfix' }];
+        const client = createClient(actions);
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        await expect(getHandler(registrar, 'lsp_code_action')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
+            content: [{ type: 'text', text: 'Available code actions:\n- [0] Fix import' }],
+            raw: actions
+        });
+        expect(promises_1.writeFile).not.toHaveBeenCalled();
+    });
+    it('applies the selected code action edit and command', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient([
+            {
+                title: 'Fix import',
+                edit: {
+                    changes: {
+                        'file:///workspace/src/index.ts': [{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 5 } }, newText: 'let' }]
+                    }
+                },
+                command: { command: 'workspace.applyFix', arguments: ['x'] }
+            }
+        ]);
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        const result = await getHandler(registrar, 'lsp_code_action')({ file: '/workspace/src/index.ts', line: 0, character: 0, apply: true });
+        expect(client.request).toHaveBeenCalledWith('workspace/executeCommand', { command: 'workspace.applyFix', arguments: ['x'] }, 15000);
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Applied code action: Fix import' }],
+            raw: { title: 'Fix import', changedFiles: ['/workspace/src/index.ts'] }
+        });
+    });
+    it('formats a file using editorconfig defaults', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient([{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 21 } }, newText: 'const foo = oldName;\n' }]);
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        await getHandler(registrar, 'lsp_formatting')({ file: '/workspace/src/index.ts' });
+        expect(client.request).toHaveBeenCalledWith('textDocument/formatting', {
+            textDocument: { uri: 'file:///workspace/src/index.ts' },
+            options: { tabSize: 2, insertSpaces: true }
+        }, 15000);
+    });
+    it('formats a range with explicit options', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient([{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 21 } }, newText: 'const foo = oldName;\n' }]);
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        await getHandler(registrar, 'lsp_range_formatting')({
+            file: '/workspace/src/index.ts',
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 21 } },
+            options: { tabSize: 4, insertSpaces: false }
+        });
+        expect(client.request).toHaveBeenCalledWith('textDocument/rangeFormatting', {
+            textDocument: { uri: 'file:///workspace/src/index.ts' },
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 21 } },
+            options: { tabSize: 4, insertSpaces: false }
+        }, 15000);
+    });
+    it('applies a raw workspace edit across files', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient(null);
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        const edit = {
+            changes: {
+                'file:///workspace/src/index.ts': [{ range: { start: { line: 0, character: 6 }, end: { line: 0, character: 9 } }, newText: 'bar' }]
+            }
+        };
+        await expect(getHandler(registrar, 'lsp_apply_workspace_edit')({ edit })).resolves.toEqual({
+            content: [{ type: 'text', text: 'Applied workspace edit to 1 file(s)' }],
+            raw: { changedFiles: ['/workspace/src/index.ts'] }
+        });
+    });
+    it('supports indexed code actions, empty edits, and document changes', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient([
+            { title: 'Skip me' },
+            {
+                title: 'Apply me',
+                edit: {
+                    documentChanges: [
+                        {
+                            textDocument: { uri: 'file:///workspace/src/index.ts', version: 1 },
+                            edits: [{ range: { start: { line: 0, character: 6 }, end: { line: 0, character: 9 } }, newText: 'bar' }]
+                        }
+                    ]
+                }
+            }
+        ]);
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        await expect(getHandler(registrar, 'lsp_code_action')({ file: '/workspace/src/index.ts', line: 0, character: 0, apply: { index: 1 } })).resolves.toEqual({
+            content: [{ type: 'text', text: 'Applied code action: Apply me' }],
+            raw: { title: 'Apply me', changedFiles: ['/workspace/src/index.ts'] }
+        });
+        client.request.mockResolvedValueOnce(null);
+        await expect(getHandler(registrar, 'lsp_apply_workspace_edit')({ edit: null })).resolves.toEqual({
+            content: [{ type: 'text', text: 'No result' }],
+            raw: null
+        });
+    });
+    it('returns an error when no write-capable client is ready', async () => {
+        const registrar = new FakeRegistrar();
+        (0, write_tools_1.registerWriteTools)(registrar, {
+            getClientForFile: jest.fn(() => null),
+            getReadyClients: jest.fn(() => []),
+            getFileDiagnostics: jest.fn((_) => []),
+            getWorkspaceDiagnostics: jest.fn(() => []),
+            getHealth: jest.fn(() => []),
+            ensureLanguageForFile: jest.fn().mockResolvedValue(undefined)
+        });
+        await expect(getHandler(registrar, 'lsp_apply_workspace_edit')({ edit: {} })).resolves.toEqual({
+            content: [{ type: 'text', text: 'No language servers are ready. Run lsp_health for details.' }],
+            error: true,
+            raw: null
+        });
+    });
+    it('handles missing clients, formatter defaults, and empty code actions', async () => {
+        const registrar = new FakeRegistrar();
+        const noClientLifecycle = {
+            getClientForFile: jest.fn(() => null),
+            getReadyClients: jest.fn(() => []),
+            getFileDiagnostics: jest.fn((_) => []),
+            getWorkspaceDiagnostics: jest.fn(() => []),
+            getHealth: jest.fn(() => []),
+            ensureLanguageForFile: jest.fn().mockResolvedValue(undefined)
+        };
+        (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({
+            content: [{ type: 'text', text: 'No language server available for .md files. Run lsp_health for details.' }],
+            error: true,
+            raw: null
+        });
+        await expect(getHandler(registrar, 'lsp_code_action')({ file: '/workspace/README.md', line: 0, character: 0 })).resolves.toEqual({
+            content: [{ type: 'text', text: 'No language server available for .md files. Run lsp_health for details.' }],
+            error: true,
+            raw: null
+        });
+        await expect(getHandler(registrar, 'lsp_formatting')({ file: '/workspace/README.md' })).resolves.toEqual({
+            content: [{ type: 'text', text: 'No language server available for .md files. Run lsp_health for details.' }],
+            error: true,
+            raw: null
+        });
+        const secondRegistrar = new FakeRegistrar();
+        const client = createClient([]);
+        promises_1.access.mockRejectedValue(new Error('missing'));
+        (0, write_tools_1.registerWriteTools)(secondRegistrar, createLifecycle(client));
+        await expect(getHandler(secondRegistrar, 'lsp_formatting')({ file: '/workspace/src/index.ts' })).resolves.toEqual({
+            content: [{ type: 'text', text: 'Applied workspace edit to 0 file(s)' }],
+            raw: { changedFiles: [] }
+        });
+        await expect(getHandler(secondRegistrar, 'lsp_code_action')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
+            content: [{ type: 'text', text: 'No result' }],
+            raw: []
+        });
+    });
+    it('maps write failures to timeout guidance', async () => {
+        const registrar = new FakeRegistrar();
+        const client = createClient(new Error('LSP request timed out: textDocument/rename'));
+        (0, write_tools_1.registerWriteTools)(registrar, createLifecycle(client));
+        await expect(getHandler(registrar, 'lsp_rename')({ file: '/workspace/src/index.ts', line: 0, character: 0, newName: 'x' })).resolves.toEqual({
+            content: [{ type: 'text', text: 'Operation timed out after 15s — try a more specific query or check the LSP server health' }],
+            error: true,
+            raw: null
+        });
+    });
+});
+function getHandler(registrar, name) {
+    const tool = registrar.tools.get(name);
+    if (!tool) {
+        throw new Error(`Missing tool ${name}`);
+    }
+    return tool.handler;
+}
+function createLifecycle(client) {
+    return {
+        getClientForFile: jest.fn((_) => client),
+        getReadyClients: jest.fn(() => [client]),
+        getFileDiagnostics: jest.fn((_) => []),
+        getWorkspaceDiagnostics: jest.fn(() => []),
+        getHealth: jest.fn(() => []),
+        ensureLanguageForFile: jest.fn().mockResolvedValue(undefined)
+    };
+}
+function createClient(result, capabilities = { renameProvider: true }) {
+    return {
+        request: jest.fn().mockImplementation(async (method) => {
+            if (method === 'workspace/executeCommand') {
+                return null;
+            }
+            if (result instanceof Error) {
+                throw result;
+            }
+            return result;
+        }),
+        notify: jest.fn(),
+        getCapabilities: jest.fn(() => capabilities)
+    };
+}

package/dist/mcp/formatters.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHover = formatHover;
+exports.formatDefinition = formatDefinition;
+exports.formatReferences = formatReferences;
+exports.formatSymbols = formatSymbols;
+exports.formatDiagnostics = formatDiagnostics;
+exports.formatCompletion = formatCompletion;
+exports.formatHealth = formatHealth;
+exports.formatError = formatError;
+const uri_1 = require("../utils/uri");
+const SYMBOL_KIND_ICONS = {
+    1: '📄',
+    2: '📦',
+    3: '🔖',
+    4: '🧩',
+    5: '📦',
+    6: '🔧',
+    7: '🏗️',
+    8: '🧠',
+    9: '📐',
+    10: '📚',
+    11: '🔌',
+    12: 'ƒ',
+    13: '≡',
+    14: '🔒',
+    15: '📝',
+    16: '№',
+    17: '🧮',
+    18: '📏',
+    19: '🧱',
+    20: '🔑',
+    21: '❌',
+    22: '🧩',
+    23: '➡️',
+    24: '🎯',
+    25: '📦',
+    26: '🔎'
+};
+const COMPLETION_KIND_LABELS = {
+    2: 'Methods',
+    3: 'Functions',
+    4: 'Constructors',
+    5: 'Fields',
+    6: 'Variables',
+    7: 'Classes',
+    8: 'Interfaces',
+    9: 'Modules',
+    10: 'Properties',
+    11: 'Units',
+    12: 'Values',
+    13: 'Enums',
+    14: 'Keywords',
+    15: 'Snippets',
+    16: 'Colors',
+    17: 'Files',
+    18: 'References',
+    19: 'Folders',
+    20: 'Enum members',
+    21: 'Constants',
+    22: 'Structs',
+    23: 'Events',
+    24: 'Operators',
+    25: 'Type parameters'
+};
+const DIAGNOSTIC_SEVERITY_LABELS = {
+    1: 'Errors',
+    2: 'Warnings',
+    3: 'Information',
+    4: 'Hints'
+};
+function formatHover(result) {
+    if (!result) {
+        return 'No result';
+    }
+    const rawText = hoverContentsToText(result.contents).trim();
+    if (!rawText) {
+        return 'No result';
+    }
+    const codeBlocks = Array.from(rawText.matchAll(/```(?<lang>[^\n`]*)\n(?<code>[\s\S]*?)```/g));
+    const firstCode = codeBlocks[0]?.groups?.code?.trim();
+    const firstLang = codeBlocks[0]?.groups?.lang?.trim() ?? '';
+    const summarySource = rawText.replace(/```[\s\S]*?```/g, '').trim();
+    const summaryLine = summarySource.split(/\n+/).find(Boolean) ?? '';
+    if (firstCode && summaryLine) {
+        return `**${firstCode}** — ${summaryLine}\n\n\`\`\`${firstLang}\n${firstCode}\n\`\`\``;
+    }
+    return summaryLine || firstCode || rawText;
+}
+function formatDefinition(locations) {
+    if (!locations || locations.length === 0) {
+        return 'No result';
+    }
+    if (locations.length === 1) {
+        return `Found 1 definition: \`${formatLocation(locations[0])}\``;
+    }
+    return ['Found definitions:', ...locations.map((location) => `- \`${formatLocation(location)}\``)].join('\n');
+}
+function formatReferences(locations) {
+    if (!locations || locations.length === 0) {
+        return 'No result';
+    }
+    return [`Found ${locations.length} references:`, ...locations.map((location) => `- \`${formatLocation(location)}\``)].join('\n');
+}
+function formatSymbols(symbols) {
+    if (!symbols || symbols.length === 0) {
+        return 'No result';
+    }
+    return symbols.map((symbol) => {
+        const icon = SYMBOL_KIND_ICONS[symbol.kind] ?? '•';
+        const detail = 'location' in symbol
+            ? formatLocation(symbol.location)
+            : `${symbol.name}`;
+        return `- ${icon} \`${symbol.name}\`${'location' in symbol ? ` — ${detail}` : ''}`;
+    }).join('\n');
+}
+function formatDiagnostics(diagnostics, scope) {
+    if (!diagnostics || diagnostics.length === 0) {
+        return 'No result';
+    }
+    const grouped = new Map();
+    const ordered = [...diagnostics].sort((left, right) => (left.severity ?? 4) - (right.severity ?? 4));
+    for (const diagnostic of ordered) {
+        const severity = diagnostic.severity ?? 4;
+        const bucket = grouped.get(severity) ?? [];
+        bucket.push(diagnostic);
+        grouped.set(severity, bucket);
+    }
+    const lines = [`${scope === 'workspace' ? 'Workspace' : 'File'} diagnostics: ${diagnostics.length} issue(s)`];
+    for (const severity of [1, 2, 3, 4]) {
+        const bucket = grouped.get(severity);
+        if (!bucket || bucket.length === 0) {
+            continue;
+        }
+        lines.push('', `### ${DIAGNOSTIC_SEVERITY_LABELS[severity]}`);
+        for (const diagnostic of bucket) {
+            lines.push(`- ${formatDiagnostic(diagnostic)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatCompletion(items) {
+    if (!items || items.length === 0) {
+        return 'No result';
+    }
+    const limited = items.slice(0, 50);
+    const grouped = new Map();
+    for (const item of limited) {
+        const label = COMPLETION_KIND_LABELS[item.kind ?? 1] ?? 'Other';
+        const bucket = grouped.get(label) ?? [];
+        bucket.push(item);
+        grouped.set(label, bucket);
+    }
+    const lines = [`Showing ${limited.length} of ${items.length} completion item(s)`];
+    for (const [label, bucket] of grouped.entries()) {
+        lines.push('', `### ${label}`);
+        for (const item of bucket) {
+            lines.push(`- \`${item.label}\`${item.detail ? ` — ${item.detail}` : ''}`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatHealth(healths) {
+    if (healths.length === 0) {
+        return 'No result';
+    }
+    return [
+        '| Language | Status | Error |',
+        '| --- | --- | --- |',
+        ...healths.map((health) => `| ${health.language} | ${health.status} | ${health.error ?? ''} |`)
+    ].join('\n');
+}
+function formatError(error) {
+    return {
+        error: true,
+        text: error instanceof Error ? error.message : String(error),
+        raw: error
+    };
+}
+function hoverContentsToText(contents) {
+    if (typeof contents === 'string') {
+        return contents;
+    }
+    if (Array.isArray(contents)) {
+        return contents.map(markedStringToText).join('\n\n');
+    }
+    if ('kind' in contents) {
+        return contents.value;
+    }
+    return markedStringToText(contents);
+}
+function markedStringToText(value) {
+    return typeof value === 'string' ? value : `\`\`\`${value.language}\n${value.value}\n\`\`\``;
+}
+function formatLocation(location) {
+    return `${(0, uri_1.uriToPath)(location.uri)}:${location.range.start.line + 1}:${location.range.start.character + 1}`;
+}
+function formatDiagnostic(diagnostic) {
+    const location = diagnostic.uri ? `\`${(0, uri_1.uriToPath)(diagnostic.uri)}:${diagnostic.range.start.line + 1}:${diagnostic.range.start.character + 1}\` ` : '';
+    const source = diagnostic.source ? `${diagnostic.source}: ` : '';
+    return `${location}${source}${diagnostic.message}`.trim();
+}