@theupsider/lsp-mcp 1.0.1 → 1.0.8

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

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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', () => ({
-    stat: jest.fn()
+jest.mock("node:fs/promises", () => ({
+    stat: jest.fn(),
 }));
 class FakeRegistrar {
     tools = new Map();
@@ -12,242 +12,436 @@ class FakeRegistrar {
         this.tools.set(name, { description: config.description, handler });
     }
 }
-describe('registerReadTools', () => {
+describe("registerReadTools", () => {
     beforeEach(() => {
         jest.clearAllMocks();
-        promises_1.stat.mockResolvedValue({ isDirectory: () => true });
+        promises_1.stat.mockResolvedValue({
+            isDirectory: () => true,
+        });
     });
-    it('initializes LSP with a valid root and reports health', async () => {
+    it("initializes LSP with a valid root and reports health", async () => {
         const registrar = new FakeRegistrar();
         const initializeManager = jest.fn().mockResolvedValue({
-            root: '/workspace',
+            root: "/workspace",
             health: [
-                { language: 'typescript', status: 'ready' },
-                { language: 'python', status: 'error', error: 'missing pylsp' }
-            ]
-        });
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), { initializeManager });
-        await expect(getHandler(registrar, 'lsp_init')({ root: '/workspace' })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Initialized LSP for /workspace. Detected languages: Typescript, Python. LSP servers: 1 started, 1 errors.' }],
-            text: 'Initialized LSP for /workspace. Detected languages: Typescript, Python. LSP servers: 1 started, 1 errors.',
+                { language: "typescript", status: "ready" },
+                { language: "python", status: "error", error: "missing pylsp" },
+            ],
+        });
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), {
+            initializeManager,
+        });
+        await expect(getHandler(registrar, "lsp_init")({ root: "/workspace" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Initialized LSP for /workspace. Detected languages: Typescript, Python. LSP servers: 1 started, 1 errors.",
+                },
+            ],
+            text: "Initialized LSP for /workspace. Detected languages: Typescript, Python. LSP servers: 1 started, 1 errors.",
             raw: {
-                root: '/workspace',
-                languages: ['Typescript', 'Python'],
+                root: "/workspace",
+                languages: ["Typescript", "Python"],
                 health: [
-                    { language: 'typescript', status: 'ready' },
-                    { language: 'python', status: 'error', error: 'missing pylsp' }
-                ]
-            }
+                    { language: "typescript", status: "ready" },
+                    { language: "python", status: "error", error: "missing pylsp" },
+                ],
+            },
         });
-        expect(initializeManager).toHaveBeenCalledWith('/workspace', undefined);
+        expect(initializeManager).toHaveBeenCalledWith("/workspace", undefined);
     });
-    it('rejects invalid lsp_init roots clearly', async () => {
+    it("rejects invalid lsp_init roots clearly", async () => {
         const registrar = new FakeRegistrar();
         const initializeManager = jest.fn();
-        promises_1.stat.mockRejectedValueOnce(new Error('ENOENT'));
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), { initializeManager });
-        await expect(getHandler(registrar, 'lsp_init')({ root: '/missing/project' })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Project root does not exist: /missing/project' }],
+        promises_1.stat.mockRejectedValueOnce(new Error("ENOENT"));
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), {
+            initializeManager,
+        });
+        await expect(getHandler(registrar, "lsp_init")({ root: "/missing/project" })).resolves.toEqual({
+            content: [
+                { type: "text", text: "Project root does not exist: /missing/project" },
+            ],
             error: true,
-            raw: null
+            raw: null,
         });
         expect(initializeManager).not.toHaveBeenCalled();
     });
-    it('rejects missing, relative, and non-directory lsp_init roots', async () => {
+    it("rejects missing, relative, and non-directory lsp_init roots", async () => {
         const registrar = new FakeRegistrar();
         const initializeManager = jest.fn();
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), { initializeManager });
-        await expect(getHandler(registrar, 'lsp_init')({})).resolves.toEqual({
-            content: [{ type: 'text', text: 'Project root is required. Provide lsp_init({ root: \'/absolute/path\' }).' }],
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), {
+            initializeManager,
+        });
+        await expect(getHandler(registrar, "lsp_init")({})).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Project root is required. Provide lsp_init({ root: '/absolute/path' }).",
+                },
+            ],
             error: true,
-            raw: null
+            raw: null,
         });
-        await expect(getHandler(registrar, 'lsp_init')({ root: 'relative/path' })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Project root must be an absolute path: relative/path' }],
+        await expect(getHandler(registrar, "lsp_init")({ root: "relative/path" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Project root must be an absolute path: relative/path",
+                },
+            ],
             error: true,
-            raw: null
+            raw: null,
+        });
+        promises_1.stat.mockResolvedValueOnce({
+            isDirectory: () => false,
         });
-        promises_1.stat.mockResolvedValueOnce({ isDirectory: () => false });
-        await expect(getHandler(registrar, 'lsp_init')({ root: '/workspace/file.ts' })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Project root is not a directory: /workspace/file.ts' }],
+        await expect(getHandler(registrar, "lsp_init")({ root: "/workspace/file.ts" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Project root is not a directory: /workspace/file.ts",
+                },
+            ],
             error: true,
-            raw: null
+            raw: null,
         });
         expect(initializeManager).not.toHaveBeenCalled();
     });
-    it('maps lsp_init startup failures into tool errors', async () => {
+    it("maps lsp_init startup failures into tool errors", async () => {
         const registrar = new FakeRegistrar();
-        const initializeManager = jest.fn().mockRejectedValue(new Error('Lifecycle start timed out'));
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), { initializeManager });
-        await expect(getHandler(registrar, 'lsp_init')({ root: '/workspace' })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Operation timed out after 30s — try a more specific query or check the LSP server health' }],
+        const initializeManager = jest
+            .fn()
+            .mockRejectedValue(new Error("Lifecycle start timed out"));
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), {
+            initializeManager,
+        });
+        await expect(getHandler(registrar, "lsp_init")({ root: "/workspace" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Operation timed out after 30s — try a more specific query or check the LSP server health",
+                },
+            ],
             error: true,
-            raw: null
+            raw: null,
         });
     });
-    it('sends didOpen once and returns formatted hover results', async () => {
+    it("sends didOpen and returns formatted definition results", async () => {
         const registrar = new FakeRegistrar();
-        const client = createClient({ contents: 'hover docs' });
+        const client = createClient({
+            uri: "file:///workspace/src/defs.ts",
+            range: {
+                start: { line: 3, character: 1 },
+                end: { line: 3, character: 2 },
+            },
+        });
         const lifecycle = createLifecycle({ fileClient: client });
         (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 });
+        const definition = await getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 2, character: 4 });
+        await getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 2, character: 4 });
         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 }
+        expect(client.ensureDidOpen).toHaveBeenCalledWith("/workspace/src/index.ts");
+        expect(client.request).toHaveBeenCalledWith("textDocument/definition", {
+            textDocument: { uri: "file:///workspace/src/index.ts" },
+            position: { line: 2, character: 4 },
         }, 5000);
-        expect(hover).toEqual({
-            content: [{ type: 'text', text: 'hover docs' }],
-            raw: { contents: 'hover docs' }
+        expect(definition).toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Found 1 definition: `/workspace/src/defs.ts:4:2`",
+                },
+            ],
+            raw: [
+                {
+                    path: "/workspace/src/defs.ts",
+                    range: {
+                        start: { line: 3, character: 1 },
+                        end: { line: 3, character: 2 },
+                    },
+                },
+            ],
         });
     });
-    it('formats definitions and converts URIs back to paths', async () => {
+    it("formats definitions and converts URIs back to paths", async () => {
         const registrar = new FakeRegistrar();
         const lifecycle = createLifecycle({
             fileClient: createClient([
                 {
-                    uri: 'file:///workspace/src/defs.ts',
-                    range: { start: { line: 3, character: 1 }, end: { line: 3, character: 2 } }
-                }
-            ])
+                    uri: "file:///workspace/src/defs.ts",
+                    range: {
+                        start: { line: 3, character: 1 },
+                        end: { line: 3, character: 2 },
+                    },
+                },
+            ]),
         });
         (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_definition')({ file: '/workspace/src/index.ts', line: 1, character: 1 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Found 1 definition: `/workspace/src/defs.ts:4:2`' }],
+        await expect(getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 1, character: 1 })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Found 1 definition: `/workspace/src/defs.ts:4:2`",
+                },
+            ],
             raw: [
                 {
-                    path: '/workspace/src/defs.ts',
-                    range: { start: { line: 3, character: 1 }, end: { line: 3, character: 2 } }
-                }
-            ]
+                    path: "/workspace/src/defs.ts",
+                    range: {
+                        start: { line: 3, character: 1 },
+                        end: { line: 3, character: 2 },
+                    },
+                },
+            ],
         });
     });
-    it('uses the declaration flag when requesting references', async () => {
+    it("uses the declaration flag when requesting references", async () => {
         const registrar = new FakeRegistrar();
         const client = createClient([]);
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), { initializeManager: jest.fn() });
-        await getHandler(registrar, 'lsp_references')({ file: '/workspace/src/index.ts', line: 0, character: 0, includeDeclaration: true });
-        expect(client.request).toHaveBeenCalledWith('textDocument/references', {
-            textDocument: { uri: 'file:///workspace/src/index.ts' },
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), {
+            initializeManager: jest.fn(),
+        });
+        await getHandler(registrar, "lsp_references")({
+            file: "/workspace/src/index.ts",
+            line: 0,
+            character: 0,
+            includeDeclaration: true,
+        });
+        expect(client.request).toHaveBeenCalledWith("textDocument/references", {
+            textDocument: { uri: "file:///workspace/src/index.ts" },
             position: { line: 0, character: 0 },
-            context: { includeDeclaration: true }
+            context: { includeDeclaration: true },
         }, 15000);
     });
-    it('merges workspace symbols across ready clients', async () => {
+    it("merges workspace symbols across ready clients", async () => {
         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 } } } }]);
-        const lifecycle = createLifecycle({ workspaceClients: [firstClient, secondClient] });
+        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 },
+                    },
+                },
+            },
+        ]);
+        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' });
+        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(firstClient.request).toHaveBeenCalledWith("workspace/symbol", { query: "log" }, 30000);
+        expect(secondClient.request).toHaveBeenCalledWith("workspace/symbol", { query: "log" }, 30000);
         expect(result).toEqual({
-            content: [{ type: 'text', text: expect.stringContaining('UserService') }],
+            content: [{ type: "text", text: expect.stringContaining("UserService") }],
             raw: [
-                { name: 'UserService', kind: 5, path: '/workspace/src/user.ts', range: { start: { line: 0, character: 0 }, end: { line: 0, character: 4 } } },
-                { name: 'login', kind: 12, path: '/workspace/src/auth.ts', range: { start: { line: 1, character: 0 }, end: { line: 1, character: 3 } } }
-            ]
+                {
+                    name: "UserService",
+                    kind: 5,
+                    path: "/workspace/src/user.ts",
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 4 },
+                    },
+                },
+                {
+                    name: "login",
+                    kind: 12,
+                    path: "/workspace/src/auth.ts",
+                    range: {
+                        start: { line: 1, character: 0 },
+                        end: { line: 1, character: 3 },
+                    },
+                },
+            ],
         });
     });
-    it('returns cached file diagnostics and aggregates workspace diagnostics', async () => {
+    it("returns cached file diagnostics and aggregates workspace diagnostics", async () => {
         const registrar = new FakeRegistrar();
-        const diagnostics = [{ uri: 'file:///workspace/src/index.ts', message: 'Boom', severity: vscode_languageserver_protocol_1.DiagnosticSeverity.Error, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }];
+        const diagnostics = [
+            {
+                uri: "file:///workspace/src/index.ts",
+                message: "Boom",
+                severity: vscode_languageserver_protocol_1.DiagnosticSeverity.Error,
+                range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 1 },
+                },
+            },
+        ];
         (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ diagnostics, workspaceClients: [createClient([])] }), { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_diagnostics')({ file: '/workspace/src/index.ts' })).resolves.toEqual({
-            content: [{ type: 'text', text: expect.stringContaining('File diagnostics: 1 issue(s)') }],
-            raw: diagnostics
+        await expect(getHandler(registrar, "lsp_diagnostics")({ file: "/workspace/src/index.ts" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: expect.stringContaining("File diagnostics: 1 issue(s)"),
+                },
+            ],
+            raw: diagnostics,
         });
-        await expect(getHandler(registrar, 'lsp_diagnostics')({ scope: 'workspace' })).resolves.toEqual({
-            content: [{ type: 'text', text: expect.stringContaining('Workspace diagnostics: 1 issue(s)') }],
-            raw: diagnostics
+        await expect(getHandler(registrar, "lsp_diagnostics")({ scope: "workspace" })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: expect.stringContaining("Workspace diagnostics: 1 issue(s)"),
+                },
+            ],
+            raw: diagnostics,
         });
     });
-    it('returns health instantly without LSP requests', async () => {
+    it("returns health instantly without LSP requests", async () => {
         const registrar = new FakeRegistrar();
-        const lifecycle = createLifecycle({ health: [{ language: 'typescript', status: 'ready' }] });
+        const lifecycle = createLifecycle({
+            health: [{ language: "typescript", status: "ready" }],
+        });
         (0, read_tools_1.registerReadTools)(registrar, lifecycle, { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_health')({})).resolves.toEqual({
-            content: [{ type: 'text', text: '| Language | Status | Error |\n| --- | --- | --- |\n| typescript | ready |  |' }],
-            raw: [{ language: 'typescript', status: 'ready' }]
+        await expect(getHandler(registrar, "lsp_health")({})).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "| Language | Status | Error |\n| --- | --- | --- |\n| typescript | ready |  |",
+                },
+            ],
+            raw: [{ language: "typescript", status: "ready" }],
         });
     });
-    it('supports document symbols, completion lists, and signature help fallbacks', async () => {
+    it("supports document symbols", async () => {
         const registrar = new FakeRegistrar();
-        const client = createClient({ items: [{ label: 'x', kind: 3 }] });
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_completion')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Showing 1 of 1 completion item(s)\n\n### Functions\n- `x`' }],
-            raw: [{ label: 'x', kind: 3 }]
-        });
-        client.request.mockResolvedValueOnce([{ name: 'DocSymbol', kind: 5, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } }, selectionRange: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }]);
-        await expect(getHandler(registrar, 'lsp_document_symbols')({ file: '/workspace/src/index.ts' })).resolves.toEqual({
-            content: [{ type: 'text', text: '- 📦 `DocSymbol`' }],
-            raw: [{ name: 'DocSymbol', kind: 5, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } }, selectionRange: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }]
+        const client = createClient([
+            {
+                name: "DocSymbol",
+                kind: 5,
+                range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 1 },
+                },
+                selectionRange: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 0, character: 1 },
+                },
+            },
+        ]);
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), {
+            initializeManager: jest.fn(),
         });
-        client.request.mockResolvedValueOnce(null);
-        await expect(getHandler(registrar, 'lsp_signature_help')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'No result' }],
-            raw: null
+        await expect(getHandler(registrar, "lsp_document_symbols")({ file: "/workspace/src/index.ts" })).resolves.toEqual({
+            content: [{ type: "text", text: "- 📦 `DocSymbol`" }],
+            raw: [
+                {
+                    name: "DocSymbol",
+                    kind: 5,
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 1 },
+                    },
+                    selectionRange: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 1 },
+                    },
+                },
+            ],
         });
     });
-    it('supports type and implementation lookups plus empty completion results', async () => {
+    it("supports type and implementation lookups", async () => {
         const registrar = new FakeRegistrar();
         const client = createClient({
-            uri: 'file:///workspace/src/types.ts',
-            range: { start: { line: 1, character: 2 }, end: { line: 1, character: 6 } }
+            uri: "file:///workspace/src/types.ts",
+            range: {
+                start: { line: 1, character: 2 },
+                end: { line: 1, character: 6 },
+            },
         });
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_type_definition')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Found 1 definition: `/workspace/src/types.ts:2:3`' }],
-            raw: [{ path: '/workspace/src/types.ts', range: { start: { line: 1, character: 2 }, end: { line: 1, character: 6 } } }]
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), {
+            initializeManager: jest.fn(),
         });
-        client.request.mockResolvedValueOnce(null);
-        await expect(getHandler(registrar, 'lsp_implementation')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'No result' }],
-            raw: null
+        await expect(getHandler(registrar, "lsp_type_definition")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Found 1 definition: `/workspace/src/types.ts:2:3`",
+                },
+            ],
+            raw: [
+                {
+                    path: "/workspace/src/types.ts",
+                    range: {
+                        start: { line: 1, character: 2 },
+                        end: { line: 1, character: 6 },
+                    },
+                },
+            ],
         });
         client.request.mockResolvedValueOnce(null);
-        await expect(getHandler(registrar, 'lsp_completion')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'No result' }],
-            raw: null
-        });
-        client.request.mockResolvedValueOnce({ signatures: [{ label: 'fn(x: string)' }] });
-        await expect(getHandler(registrar, 'lsp_signature_help')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: JSON.stringify({ signatures: [{ label: 'fn(x: string)' }] }, null, 2) }],
-            raw: { signatures: [{ label: 'fn(x: string)' }] }
+        await expect(getHandler(registrar, "lsp_implementation")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
+            content: [{ type: "text", text: "No result" }],
+            raw: null,
         });
     });
-    it('turns LSP timeouts into retry guidance', async () => {
+    it("turns LSP timeouts into retry guidance", async () => {
         const registrar = new FakeRegistrar();
-        const client = createClient(new Error('LSP request timed out: textDocument/hover'));
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_hover')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Operation timed out after 5s — try a more specific query or check the LSP server health' }],
+        const client = createClient(new Error("LSP request timed out: textDocument/definition"));
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), {
+            initializeManager: jest.fn(),
+        });
+        await expect(getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Operation timed out after 5s — try a more specific query or check the LSP server health",
+                },
+            ],
             error: true,
-            raw: null
+            raw: null,
         });
     });
-    it('returns a no-server error when no language server matches the file', async () => {
+    it("returns a no-server error when no language server matches the file", async () => {
         const registrar = new FakeRegistrar();
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_hover')({ 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.' }],
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: null }), {
+            initializeManager: jest.fn(),
+        });
+        await expect(getHandler(registrar, "lsp_definition")({ 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
+            raw: null,
         });
     });
-    it('returns restart guidance when the LSP crashed', async () => {
+    it("returns restart guidance when the LSP crashed", async () => {
         const registrar = new FakeRegistrar();
-        const client = createClient(new Error('LSP server exited unexpectedly (code: 1, signal: null)'));
-        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), { initializeManager: jest.fn() });
-        await expect(getHandler(registrar, 'lsp_hover')({ file: '/workspace/src/index.ts', line: 0, character: 0 })).resolves.toEqual({
-            content: [{ type: 'text', text: 'Der Language Server ist neu gestartet, bitte versuche es erneut.' }],
+        const client = createClient(new Error("LSP server exited unexpectedly (code: 1, signal: null)"));
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), {
+            initializeManager: jest.fn(),
+        });
+        await expect(getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: "Der Language Server ist neu gestartet, bitte versuche es erneut.",
+                },
+            ],
             error: true,
-            raw: null
+            raw: null,
         });
     });
 });
@@ -262,11 +456,12 @@ function createLifecycle(options) {
     return {
         getClientForFile: jest.fn((_) => options.fileClient ?? null),
         getReadyClients: jest.fn((_) => options.workspaceClients ?? []),
-        getFileDiagnostics: jest.fn((_) => (options.diagnostics ?? []).filter((diagnostic) => diagnostic.uri === 'file:///workspace/src/index.ts')),
+        getFileDiagnostics: jest.fn((_) => (options.diagnostics ?? []).filter((diagnostic) => diagnostic.uri === "file:///workspace/src/index.ts")),
         getWorkspaceDiagnostics: jest.fn((_) => options.diagnostics ?? []),
         getHealth: jest.fn(() => options.health ?? []),
         ensureLanguageForFile: jest.fn().mockResolvedValue(undefined),
-        ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined)
+        ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined),
+        analyzeWorkspace: jest.fn().mockResolvedValue(undefined),
     };
 }
 function createClient(result) {
@@ -278,6 +473,6 @@ function createClient(result) {
         getCapabilities: jest.fn(() => ({ renameProvider: true })),
         ensureDidOpen: jest.fn().mockResolvedValue(undefined),
         waitForDiagnosticsPublish: jest.fn().mockResolvedValue(undefined),
-        ensureSeedFileOpen: jest.fn().mockResolvedValue(undefined)
+        ensureSeedFileOpen: jest.fn().mockResolvedValue(undefined),
     };
 }