@theupsider/lsp-mcp 0.1.1 → 0.1.3

package/dist/lsp/lsp-client.js

@@ -5,8 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LspClient = void 0;
 const node_events_1 = require("node:events");
+const promises_1 = require("node:fs/promises");
 const node_child_process_1 = require("node:child_process");
 const node_path_1 = __importDefault(require("node:path"));
+const language_registry_1 = require("../detection/language-registry");
 const uri_1 = require("../utils/uri");
 class LspClient extends node_events_1.EventEmitter {
     serverDef;
@@ -21,6 +23,7 @@ class LspClient extends node_events_1.EventEmitter {
     exitExpected = false;
     initializeResult = null;
     forcedKillTimer = null;
+    openedFiles = new Set();
     constructor(serverDef, projectRoot, logLevel) {
         super();
         this.serverDef = serverDef;
@@ -34,35 +37,46 @@ class LspClient extends node_events_1.EventEmitter {
         this.process = (0, node_child_process_1.spawn)(this.serverDef.cmd, this.serverDef.args, {
             cwd: this.projectRoot,
             env: { ...process.env },
-            stdio: 'pipe'
+            stdio: "pipe",
         });
-        this.process.stdout.on('data', (chunk) => {
+        this.process.stdout.on("data", (chunk) => {
             this.handleData(chunk);
         });
-        this.process.on('error', (error) => {
-            this.log('error', 'lsp_process_error', { error: error.message });
-            this.emit('error', error);
+        this.process.on("error", (error) => {
+            this.log("error", "lsp_process_error", { error: error.message });
+            this.emit("error", error);
         });
-        this.process.on('exit', (code, signal) => {
+        this.process.on("exit", (code, signal) => {
             this.handleExit(code, signal);
         });
-        this.log('info', 'lsp_starting', { language: this.serverDef.cmd });
-        const initializeResult = await this.request('initialize', {
+        this.log("info", "lsp_starting", { language: this.serverDef.cmd });
+        const initializeResult = await this.request("initialize", {
             processId: process.pid,
-            clientInfo: { name: 'lsp-mcp', version: '0.1.0' },
+            clientInfo: { name: "lsp-mcp", version: "0.1.0" },
             rootUri: (0, uri_1.pathToUri)(this.projectRoot),
             workspaceFolders: [
                 {
                     uri: (0, uri_1.pathToUri)(this.projectRoot),
-                    name: node_path_1.default.basename(this.projectRoot)
-                }
+                    name: node_path_1.default.basename(this.projectRoot),
+                },
             ],
-            capabilities: {}
+            capabilities: {
+                textDocument: {
+                    publishDiagnostics: {
+                        relatedInformation: true,
+                        versionSupport: false,
+                        tagSupport: { valueSet: [1, 2] },
+                    },
+                    synchronization: {
+                        didSave: true,
+                    },
+                },
+            },
         }, 30000);
         this.initializeResult = initializeResult;
-        this.notify('initialized', {});
+        this.notify("initialized", {});
         this.ready = true;
-        this.log('info', 'lsp_ready', { language: this.serverDef.cmd });
+        this.log("info", "lsp_ready", { language: this.serverDef.cmd });
     }
     isReady() {
         return this.ready;
@@ -71,10 +85,10 @@ class LspClient extends node_events_1.EventEmitter {
         const id = this.nextRequestId;
         this.nextRequestId += 1;
         const message = {
-            jsonrpc: '2.0',
+            jsonrpc: "2.0",
             id,
             method,
-            params
+            params,
         };
         return await new Promise((resolve, reject) => {
             const timeoutHandle = setTimeout(() => {
@@ -84,16 +98,16 @@ class LspClient extends node_events_1.EventEmitter {
             this.pendingRequests.set(id, {
                 resolve: (value) => resolve(value),
                 reject,
-                timeoutHandle
+                timeoutHandle,
             });
             this.sendMessage(message);
         });
     }
     notify(method, params) {
         const message = {
-            jsonrpc: '2.0',
+            jsonrpc: "2.0",
             method,
-            params
+            params,
         };
         this.sendMessage(message);
     }
@@ -103,65 +117,108 @@ class LspClient extends node_events_1.EventEmitter {
             this.ready = false;
             return;
         }
-        await this.request('shutdown', {}, 5000);
-        this.notify('exit', {});
+        await this.request("shutdown", {}, 5000);
+        this.notify("exit", {});
         this.ready = false;
         const currentProcess = this.process;
         this.forcedKillTimer = setTimeout(() => {
-            currentProcess.kill('SIGKILL');
+            currentProcess.kill("SIGKILL");
         }, 5000);
     }
     getCapabilities() {
         return this.initializeResult?.capabilities ?? null;
     }
+    waitForDiagnosticsPublish(filePath, timeoutMs) {
+        const uri = (0, uri_1.pathToUri)(filePath);
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, timeoutMs);
+            const handler = (method, params) => {
+                if (method === "textDocument/publishDiagnostics") {
+                    const p = params;
+                    if (p?.uri === uri) {
+                        clearTimeout(timer);
+                        this.off("notification", handler);
+                        resolve();
+                    }
+                }
+            };
+            this.on("notification", handler);
+        });
+    }
+    async ensureDidOpen(filePath) {
+        if (this.openedFiles.has(filePath)) {
+            return;
+        }
+        const text = await (0, promises_1.readFile)(filePath, "utf8");
+        this.notify("textDocument/didOpen", {
+            textDocument: {
+                uri: (0, uri_1.pathToUri)(filePath),
+                languageId: (0, language_registry_1.extensionToLanguageId)(node_path_1.default.extname(filePath)),
+                version: 1,
+                text,
+            },
+        });
+        this.openedFiles.add(filePath);
+    }
+    async ensureSeedFileOpen(extensions) {
+        if (this.openedFiles.size > 0) {
+            return;
+        }
+        const file = await findFirstFileWithExtension(this.projectRoot, extensions);
+        if (file) {
+            await this.ensureDidOpen(file);
+        }
+    }
     sendMessage(message) {
         if (!this.process) {
-            throw new Error('LSP process is not running');
+            throw new Error("LSP process is not running");
         }
         const body = JSON.stringify(message);
-        const content = `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
+        const content = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
         this.process.stdin.write(content);
     }
     handleData(chunk) {
-        const incoming = typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk;
+        const incoming = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
         this.buffer = Buffer.concat([this.buffer, incoming]);
         while (true) {
             if (this.contentLength === null) {
-                const headerEnd = this.buffer.indexOf('\r\n\r\n');
+                const headerEnd = this.buffer.indexOf("\r\n\r\n");
                 if (headerEnd === -1) {
                     return;
                 }
-                const header = this.buffer.subarray(0, headerEnd).toString('utf8');
+                const header = this.buffer.subarray(0, headerEnd).toString("utf8");
                 this.buffer = this.buffer.subarray(headerEnd + 4);
                 const contentLengthLine = header
-                    .split('\r\n')
-                    .find((line) => line.toLowerCase().startsWith('content-length:'));
+                    .split("\r\n")
+                    .find((line) => line.toLowerCase().startsWith("content-length:"));
                 if (!contentLengthLine) {
-                    const error = new Error('Missing Content-Length header');
-                    this.emit('error', error);
+                    const error = new Error("Missing Content-Length header");
+                    this.emit("error", error);
                     return;
                 }
-                const value = Number.parseInt(contentLengthLine.slice('Content-Length:'.length).trim(), 10);
+                const value = Number.parseInt(contentLengthLine.slice("Content-Length:".length).trim(), 10);
                 this.contentLength = value;
             }
             if (this.buffer.byteLength < this.contentLength) {
                 return;
             }
-            const messageBody = this.buffer.subarray(0, this.contentLength).toString('utf8');
+            const messageBody = this.buffer
+                .subarray(0, this.contentLength)
+                .toString("utf8");
             this.buffer = this.buffer.subarray(this.contentLength);
             this.contentLength = null;
             this.handleMessage(JSON.parse(messageBody));
         }
     }
     handleMessage(message) {
-        if (!message || typeof message !== 'object') {
+        if (!message || typeof message !== "object") {
             return;
         }
-        if ('method' in message) {
-            this.emit('notification', message.method, message.params);
+        if ("method" in message) {
+            this.emit("notification", message.method, message.params);
             return;
         }
-        if ('id' in message && 'error' in message && message.id !== null) {
+        if ("id" in message && "error" in message && message.id !== null) {
             const pending = this.pendingRequests.get(message.id);
             if (!pending) {
                 return;
@@ -171,7 +228,7 @@ class LspClient extends node_events_1.EventEmitter {
             pending.reject(new Error(message.error.message));
             return;
         }
-        if ('id' in message && 'result' in message) {
+        if ("id" in message && "result" in message) {
             const pending = this.pendingRequests.get(message.id);
             if (!pending) {
                 return;
@@ -186,13 +243,16 @@ class LspClient extends node_events_1.EventEmitter {
             clearTimeout(this.forcedKillTimer);
             this.forcedKillTimer = null;
         }
-        this.rejectAllPending(new Error(`LSP server exited (code: ${code ?? 'null'}, signal: ${signal ?? 'null'})`));
+        this.rejectAllPending(new Error(`LSP server exited (code: ${code ?? "null"}, signal: ${signal ?? "null"})`));
         this.ready = false;
         this.process = null;
         if (!this.exitExpected) {
-            const error = new Error(`LSP server exited unexpectedly (code: ${code ?? 'null'}, signal: ${signal ?? 'null'})`);
-            this.log('error', 'lsp_crash', { error: error.message, language: this.serverDef.cmd });
-            this.emit('crash', error);
+            const error = new Error(`LSP server exited unexpectedly (code: ${code ?? "null"}, signal: ${signal ?? "null"})`);
+            this.log("error", "lsp_crash", {
+                error: error.message,
+                language: this.serverDef.cmd,
+            });
+            this.emit("crash", error);
         }
     }
     rejectAllPending(error) {
@@ -210,7 +270,7 @@ class LspClient extends node_events_1.EventEmitter {
             timestamp: new Date().toISOString(),
             level,
             event,
-            ...extra
+            ...extra,
         };
         process.stderr.write(`${JSON.stringify(payload)}\n`);
     }
@@ -220,7 +280,34 @@ function shouldLog(configuredLevel, messageLevel) {
     const order = {
         error: 0,
         info: 1,
-        debug: 2
+        debug: 2,
     };
     return order[messageLevel] <= order[configuredLevel];
 }
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'out', '.next',
+    'coverage', '__pycache__', 'target', '.cache', 'vendor',
+]);
+async function findFirstFileWithExtension(dir, extensions) {
+    const extensionSet = new Set(extensions.map((e) => e.toLowerCase()));
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (entry.isFile() && extensionSet.has(node_path_1.default.extname(entry.name).toLowerCase())) {
+            return node_path_1.default.join(dir, entry.name);
+        }
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+            const result = await findFirstFileWithExtension(node_path_1.default.join(dir, entry.name), extensions);
+            if (result)
+                return result;
+        }
+    }
+    return null;
+}

package/dist/lsp/server-supervisor.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerSupervisor = void 0;
+const lsp_mapping_1 = require("../detection/lsp-mapping");
+const installer_1 = require("./installer");
+const lsp_client_1 = require("./lsp-client");
+class ServerSupervisor {
+    language;
+    restartCount = 0;
+    client = null;
+    status = 'starting';
+    error = undefined;
+    capabilities = undefined;
+    serverDef = null;
+    healthInterval = null;
+    projectRoot;
+    logLevel;
+    onDiagnostics;
+    shuttingDown = false;
+    constructor(language, projectRoot, logLevel, onDiagnostics) {
+        this.language = language;
+        this.projectRoot = projectRoot;
+        this.logLevel = logLevel;
+        this.onDiagnostics = onDiagnostics;
+    }
+    async start() {
+        const serverDef = await this.resolveServer();
+        if (!serverDef) {
+            this.status = 'error';
+            this.error = `No LSP server available for ${this.language}`;
+            return;
+        }
+        this.serverDef = serverDef;
+        const client = new lsp_client_1.LspClient(serverDef, this.projectRoot, this.logLevel);
+        this.client = client;
+        client.on('crash', async () => {
+            if (this.shuttingDown) {
+                return;
+            }
+            await this.restart(`LSP server crashed for ${this.language}`);
+        });
+        client.on('error', (error) => {
+            this.status = 'error';
+            this.error = error instanceof Error ? error.message : 'Unknown LSP error';
+        });
+        client.on('notification', (method, params) => {
+            this.onDiagnostics(method, params);
+        });
+        try {
+            await client.start();
+            this.status = 'ready';
+            this.error = undefined;
+            this.capabilities = client.getCapabilities() ?? undefined;
+            this.startHealthChecks();
+        }
+        catch (error) {
+            this.status = 'error';
+            this.error = error instanceof Error ? error.message : 'Unknown LSP startup error';
+        }
+    }
+    async restart(reason) {
+        if (this.healthInterval) {
+            clearInterval(this.healthInterval);
+            this.healthInterval = null;
+        }
+        if (this.restartCount >= 3) {
+            this.status = 'error';
+            this.error = reason;
+            this.client = null;
+            return;
+        }
+        this.restartCount += 1;
+        this.status = 'starting';
+        this.error = reason;
+        if (this.client) {
+            try {
+                await promiseWithTimeout(this.client.shutdown(), 5000, 'LSP shutdown timed out');
+            }
+            catch {
+                // Ignore shutdown failures during restart.
+            }
+        }
+        this.client = null;
+        await this.start();
+    }
+    async shutdown() {
+        this.shuttingDown = true;
+        if (this.healthInterval) {
+            clearInterval(this.healthInterval);
+            this.healthInterval = null;
+        }
+        if (this.client) {
+            await this.client.shutdown();
+            this.client = null;
+        }
+    }
+    getClient() {
+        return this.client;
+    }
+    getHealth() {
+        return {
+            language: this.language,
+            status: this.status,
+            error: this.error,
+            capabilities: this.capabilities
+        };
+    }
+    startHealthChecks() {
+        if (this.healthInterval) {
+            clearInterval(this.healthInterval);
+        }
+        this.healthInterval = setInterval(() => {
+            void this.runHealthCheck();
+        }, 30000);
+    }
+    async runHealthCheck() {
+        if (!this.client || this.status !== 'ready') {
+            return;
+        }
+        if (!this.client.isReady()) {
+            await this.restart('LSP client lost ready state');
+        }
+    }
+    async resolveServer() {
+        const available = await (0, lsp_mapping_1.findAvailableLsp)(this.language);
+        if (available) {
+            return available;
+        }
+        const candidate = (0, lsp_mapping_1.getLspCandidates)(this.language)[0] ?? null;
+        if (!candidate) {
+            return null;
+        }
+        const installation = await (0, installer_1.installLsp)(candidate);
+        if (!installation.success) {
+            return null;
+        }
+        return candidate;
+    }
+}
+exports.ServerSupervisor = ServerSupervisor;
+async function promiseWithTimeout(promise, timeoutMs, message) {
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}

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

@@ -133,7 +133,7 @@ describe('mcp formatters', () => {
         expect((0, formatters_1.formatDefinition)(null)).toBe('No result');
         expect((0, formatters_1.formatReferences)([])).toBe('No result');
         expect((0, formatters_1.formatSymbols)(null)).toBe('No result');
-        expect((0, formatters_1.formatDiagnostics)([], 'file')).toBe('No result');
+        expect((0, formatters_1.formatDiagnostics)([], 'file')).toBe('No diagnostics found');
         expect((0, formatters_1.formatCompletion)(null)).toBe('No result');
         expect((0, formatters_1.formatHealth)([])).toBe('No result');
     });

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

@@ -4,7 +4,6 @@ const promises_1 = require("node:fs/promises");
 const read_tools_1 = require("../tools/read-tools");
 const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
 jest.mock('node:fs/promises', () => ({
-    readFile: jest.fn(),
     stat: jest.fn()
 }));
 class FakeRegistrar {
@@ -16,7 +15,6 @@ class FakeRegistrar {
 describe('registerReadTools', () => {
     beforeEach(() => {
         jest.clearAllMocks();
-        promises_1.readFile.mockResolvedValue('const foo = 1;');
         promises_1.stat.mockResolvedValue({ isDirectory: () => true });
     });
     it('initializes LSP with a valid root and reports health', async () => {
@@ -94,10 +92,8 @@ describe('registerReadTools', () => {
         (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
         const hover = await getHandler(registrar, 'lsp_hover')({ file: '/workspace/src/index.ts', line: 2, character: 4 });
         await getHandler(registrar, 'lsp_hover')({ file: '/workspace/src/index.ts', line: 2, character: 4 });
-        expect(promises_1.readFile).toHaveBeenCalledTimes(1);
-        expect(client.notify).toHaveBeenCalledWith('textDocument/didOpen', expect.objectContaining({
-            textDocument: expect.objectContaining({ uri: 'file:///workspace/src/index.ts', text: 'const foo = 1;' })
-        }));
+        expect(client.ensureDidOpen).toHaveBeenCalledTimes(2);
+        expect(client.ensureDidOpen).toHaveBeenCalledWith('/workspace/src/index.ts');
         expect(client.request).toHaveBeenCalledWith('textDocument/hover', {
             textDocument: { uri: 'file:///workspace/src/index.ts' },
             position: { line: 2, character: 4 }
@@ -143,8 +139,10 @@ describe('registerReadTools', () => {
         const registrar = new FakeRegistrar();
         const firstClient = createClient([{ name: 'UserService', kind: 5, location: { uri: 'file:///workspace/src/user.ts', range: { start: { line: 0, character: 0 }, end: { line: 0, character: 4 } } } }]);
         const secondClient = createClient([{ name: 'login', kind: 12, location: { uri: 'file:///workspace/src/auth.ts', range: { start: { line: 1, character: 0 }, end: { line: 1, character: 3 } } } }]);
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ workspaceClients: [firstClient, secondClient] }), { initializeManager: jest.fn() });
+        const lifecycle = createLifecycle({ workspaceClients: [firstClient, secondClient] });
+        (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
         const result = await getHandler(registrar, 'lsp_workspace_symbols')({ query: 'log' });
+        expect(lifecycle.ensureSeedFilesOpen).toHaveBeenCalledTimes(1);
         expect(firstClient.request).toHaveBeenCalledWith('workspace/symbol', { query: 'log' }, 30000);
         expect(secondClient.request).toHaveBeenCalledWith('workspace/symbol', { query: 'log' }, 30000);
         expect(result).toEqual({
@@ -267,7 +265,8 @@ function createLifecycle(options) {
         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)
+        ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
+        ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined)
     };
 }
 function createClient(result) {
@@ -276,6 +275,9 @@ function createClient(result) {
             ? jest.fn().mockRejectedValue(result)
             : jest.fn().mockResolvedValue(result),
         notify: jest.fn(),
-        getCapabilities: jest.fn(() => ({ renameProvider: true }))
+        getCapabilities: jest.fn(() => ({ renameProvider: true })),
+        ensureDidOpen: jest.fn().mockResolvedValue(undefined),
+        waitForDiagnosticsPublish: jest.fn().mockResolvedValue(undefined),
+        ensureSeedFileOpen: jest.fn().mockResolvedValue(undefined)
     };
 }

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

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const mockRegisterCapabilities = jest.fn();
 const mockSetRequestHandler = jest.fn();
 const mockConnect = jest.fn().mockResolvedValue(undefined);
 jest.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
     McpServer: jest.fn().mockImplementation(() => ({
         connect: mockConnect,
         server: {
+            registerCapabilities: mockRegisterCapabilities,
             setRequestHandler: mockSetRequestHandler
         }
     }))
@@ -32,9 +34,10 @@ describe('McpServer', () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
-    it('registers request handlers and connects on start', async () => {
+    it('registers tool capabilities, request handlers, and connects on start', async () => {
         const server = new server_1.McpServer('info');
         await server.start();
+        expect(mockRegisterCapabilities).toHaveBeenCalledWith({ tools: {} });
         expect(mockSetRequestHandler).toHaveBeenCalledTimes(2);
         expect(mockConnect).toHaveBeenCalledWith({ kind: 'stdio' });
     });

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

@@ -1,7 +1,6 @@
 "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(),
@@ -17,7 +16,6 @@ class FakeRegistrar {
 describe('registerWriteTools', () => {
     beforeEach(() => {
         jest.clearAllMocks();
-        (0, shared_1.clearOpenedFiles)();
         promises_1.access.mockResolvedValue(undefined);
         promises_1.readFile.mockImplementation(async (filePath) => {
             const pathText = String(filePath);
@@ -165,7 +163,8 @@ describe('registerWriteTools', () => {
             getFileDiagnostics: jest.fn((_) => []),
             getWorkspaceDiagnostics: jest.fn(() => []),
             getHealth: jest.fn(() => []),
-            ensureLanguageForFile: jest.fn().mockResolvedValue(undefined)
+            ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
+            ensureSeedFilesOpen: 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.' }],
@@ -181,7 +180,8 @@ describe('registerWriteTools', () => {
             getFileDiagnostics: jest.fn((_) => []),
             getWorkspaceDiagnostics: jest.fn(() => []),
             getHealth: jest.fn(() => []),
-            ensureLanguageForFile: jest.fn().mockResolvedValue(undefined)
+            ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
+            ensureSeedFilesOpen: 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({
@@ -237,7 +237,8 @@ function createLifecycle(client) {
         getFileDiagnostics: jest.fn((_) => []),
         getWorkspaceDiagnostics: jest.fn(() => []),
         getHealth: jest.fn(() => []),
-        ensureLanguageForFile: jest.fn().mockResolvedValue(undefined)
+        ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
+        ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined)
     };
 }
 function createClient(result, capabilities = { renameProvider: true }) {
@@ -252,6 +253,9 @@ function createClient(result, capabilities = { renameProvider: true }) {
             return result;
         }),
         notify: jest.fn(),
-        getCapabilities: jest.fn(() => capabilities)
+        getCapabilities: jest.fn(() => capabilities),
+        ensureDidOpen: jest.fn().mockResolvedValue(undefined),
+        waitForDiagnosticsPublish: jest.fn().mockResolvedValue(undefined),
+        ensureSeedFileOpen: jest.fn().mockResolvedValue(undefined)
     };
 }

package/dist/mcp/formatters.js

@@ -116,7 +116,7 @@ function formatSymbols(symbols) {
 }
 function formatDiagnostics(diagnostics, scope) {
     if (!diagnostics || diagnostics.length === 0) {
-        return 'No result';
+        return scope === 'workspace' ? 'No diagnostics found in workspace' : 'No diagnostics found';
     }
     const grouped = new Map();
     const ordered = [...diagnostics].sort((left, right) => (left.severity ?? 4) - (right.severity ?? 4));

package/dist/mcp/server.js

@@ -28,8 +28,7 @@ class McpServer {
         const registrar = {
             registerTool: (name, config, handler) => {
                 this.tools.set(name, { name, description: config.description, inputSchema: config.inputSchema, handler });
-            },
-            fromJsonSchema: (schema) => schema
+            }
         };
         (0, read_tools_1.registerReadTools)(registrar, lifecycleProxy, { initializeManager: async (root, languages) => await this.initializeManager(root, languages) });
         (0, write_tools_1.registerWriteTools)(registrar, lifecycleProxy);
@@ -64,6 +63,7 @@ class McpServer {
         }
     }
     configureToolHandlers() {
+        this.server.server.registerCapabilities({ tools: {} });
         this.server.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: this.listTools() }));
         this.server.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const toolName = request.params.name;
@@ -101,7 +101,8 @@ class McpServer {
             getFileDiagnostics: (filePath) => this.requireManager().getFileDiagnostics(filePath),
             getWorkspaceDiagnostics: (language) => this.requireManager().getWorkspaceDiagnostics(language),
             getHealth: () => this.requireManager().getHealth(),
-            ensureLanguageForFile: async (filePath) => await this.requireManager().ensureLanguageForFile(filePath)
+            ensureLanguageForFile: async (filePath) => await this.requireManager().ensureLanguageForFile(filePath),
+            ensureSeedFilesOpen: async () => await this.requireManager().ensureSeedFilesOpen()
         };
     }
     requireManager() {