@theupsider/lsp-mcp 1.0.7 → 1.0.9

package/README.md

@@ -32,7 +32,7 @@ A Model Context Protocol (MCP) server that gives language models access to **Lan
 
 - **🔍 Automatic Language Detection** — Scans project root for language markers (`package.json`, `Cargo.toml`, `go.mod`, etc.)
 - **🔄 Auto Language Server Selection** — Hardcoded mapping with fallback servers; installs missing LSPs automatically
-- **🛠 19 LSP Tools** — Hover, definition, references, completions, diagnostics, rename, code actions, formatting, and more
+- **🛠 12 LSP Tools** — Definition, references, symbols, diagnostics, rename, code actions, formatting, and more
 - **📝 Read & Write Operations** — Both inspection and modification of code via LSP
 - **🌐 Polyglot Support** — Multiple language servers run simultaneously in the same project
 - **📋 Hybrid Responses** — Human-readable `text` field + raw LSP data in `raw` field
@@ -103,14 +103,11 @@ lsp_init({ root: "/path/to/project", languages: ["python", "typescript"] })
 | Tool                    | Description                             | Key Parameters                                         |
 | ----------------------- | --------------------------------------- | ------------------------------------------------------ |
 | `lsp_init`              | Initialize server for a project root    | `root` (required), `languages` (optional string array) |
-| `lsp_hover`             | Show type info / documentation          | `file`, `line`, `character`                            |
 | `lsp_definition`        | Go to definition                | `file`, `line`, `character`           |
 | `lsp_references`        | Find all references             | `file`, `line`, `character`           |
 | `lsp_document_symbols`  | List symbols in a file          | `file`                                |
 | `lsp_workspace_symbols` | Search symbols across workspace | `query` (limit: 100–500 results)      |
-| `lsp_completion`        | Code completion suggestions     | `file`, `line`, `character`           |
 | `lsp_diagnostics`       | Get errors & warnings           | `file` (scope: `file` or `workspace`) |
-| `lsp_signature_help`    | Function signature help         | `file`, `line`, `character`           |
 | `lsp_type_definition`   | Go to type definition           | `file`, `line`, `character`           |
 | `lsp_implementation`    | Find implementations            | `file`, `line`, `character`           |
 | `lsp_health`            | Check status of all LSP servers | _(none)_                              |
@@ -123,7 +120,6 @@ lsp_init({ root: "/path/to/project", languages: ["python", "typescript"] })
 | `lsp_code_action`          | Apply / list code actions | `file`, `line`, `character`, `apply`   |
 | `lsp_formatting`           | Format document           | `file`                                 |
 | `lsp_range_formatting`     | Format code range         | `file`, `range`                        |
-| `lsp_apply_workspace_edit` | Apply raw workspace edit  | `edit` (WorkspaceEdit object)          |
 
 ## Configuration
 
@@ -190,7 +186,7 @@ Each language server runs as a separate process. For large projects with many la
 ┌─────────────────────────────────────────────┐
 │         LSP MCP Server (Node.js)            │
 │  ┌───────────┐ ┌──────────┐ ┌───────────┐  │
-│  │ lsp_hover │ │ lsp_...  │ │ lsp_...   │  │
+│  │ lsp_init  │ │ lsp_...  │ │ lsp_...   │  │
 │  └─────┬─────┘ └────┬─────┘ └─────┬─────┘  │
 │        └─────────────┼─────────────┘        │
 │                      ▼                       │

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

@@ -126,22 +126,41 @@ describe("registerReadTools", () => {
             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", {
+        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 () => {
@@ -303,22 +322,9 @@ describe("registerReadTools", () => {
             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([
+        const client = createClient([
             {
                 name: "DocSymbol",
                 kind: 5,
@@ -332,6 +338,9 @@ describe("registerReadTools", () => {
                 },
             },
         ]);
+        (0, read_tools_1.registerReadTools)(registrar, createLifecycle({ fileClient: client }), {
+            initializeManager: jest.fn(),
+        });
         await expect(getHandler(registrar, "lsp_document_symbols")({ file: "/workspace/src/index.ts" })).resolves.toEqual({
             content: [{ type: "text", text: "- 📦 `DocSymbol`" }],
             raw: [
@@ -349,13 +358,8 @@ describe("registerReadTools", () => {
                 },
             ],
         });
-        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,
-        });
     });
-    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",
@@ -389,31 +393,14 @@ describe("registerReadTools", () => {
             content: [{ type: "text", text: "No result" }],
             raw: null,
         });
-        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)" }] },
-        });
     });
     it("turns LSP timeouts into retry guidance", async () => {
         const registrar = new FakeRegistrar();
-        const client = createClient(new Error("LSP request timed out: textDocument/hover"));
+        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_hover")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
+        await expect(getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
             content: [
                 {
                     type: "text",
@@ -429,7 +416,7 @@ describe("registerReadTools", () => {
         (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({
+        await expect(getHandler(registrar, "lsp_definition")({ file: "/workspace/README.md", line: 0, character: 0 })).resolves.toEqual({
             content: [
                 {
                     type: "text",
@@ -446,7 +433,7 @@ describe("registerReadTools", () => {
         (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({
+        await expect(getHandler(registrar, "lsp_definition")({ file: "/workspace/src/index.ts", line: 0, character: 0 })).resolves.toEqual({
             content: [
                 {
                     type: "text",

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

@@ -2,27 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const mockRegisterCapabilities = jest.fn();
 const mockSetRequestHandler = jest.fn();
+const mockSetNotificationHandler = jest.fn();
 const mockConnect = jest.fn().mockResolvedValue(undefined);
-jest.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
+const mockGetClientCapabilities = jest.fn().mockReturnValue(undefined);
+const mockListRoots = jest.fn().mockResolvedValue({ roots: [] });
+const mockSendToolListChanged = jest.fn().mockResolvedValue(undefined);
+const mockInnerServer = {
+    registerCapabilities: mockRegisterCapabilities,
+    setRequestHandler: mockSetRequestHandler,
+    setNotificationHandler: mockSetNotificationHandler,
+    getClientCapabilities: mockGetClientCapabilities,
+    listRoots: mockListRoots,
+    sendToolListChanged: mockSendToolListChanged,
+    oninitialized: undefined,
+};
+jest.mock("@modelcontextprotocol/sdk/server/mcp.js", () => ({
     McpServer: jest.fn().mockImplementation(() => ({
         connect: mockConnect,
-        server: {
-            registerCapabilities: mockRegisterCapabilities,
-            setRequestHandler: mockSetRequestHandler
-        }
-    }))
+        server: mockInnerServer,
+    })),
 }));
-jest.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
-    StdioServerTransport: jest.fn().mockImplementation(() => ({ kind: 'stdio' }))
+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-compat.js", () => ({
+    normalizeObjectSchema: jest.fn().mockReturnValue(null),
 }));
-jest.mock('@modelcontextprotocol/sdk/server/zod-json-schema-compat.js', () => ({
-    toJsonSchemaCompat: jest.fn().mockReturnValue({})
+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() }));
+jest.mock("../../utils/workspace-config", () => ({
+    loadWorkspaceConfig: jest.fn().mockResolvedValue(null),
+    saveWorkspaceConfig: jest.fn().mockResolvedValue(undefined),
+    loadLastRoot: jest.fn().mockResolvedValue(null),
 }));
-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);
@@ -30,114 +45,240 @@ function getHandler(schema) {
         throw new Error(`No handler registered for schema`);
     return call[1];
 }
-describe('McpServer', () => {
+describe("McpServer", () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        mockInnerServer.oninitialized = undefined;
+        mockGetClientCapabilities.mockReturnValue(undefined);
+        mockListRoots.mockResolvedValue({ roots: [] });
+        mockSendToolListChanged.mockResolvedValue(undefined);
     });
-    it('registers tool capabilities, request handlers, and connects on start', async () => {
-        const server = new server_1.McpServer('info');
+    it("registers tool capabilities, request handlers, notification handler, 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' });
+        expect(mockSetNotificationHandler).toHaveBeenCalledTimes(1);
+        expect(mockConnect).toHaveBeenCalledWith({ kind: "stdio" });
+    });
+    it("sets oninitialized callback on start", async () => {
+        const server = new server_1.McpServer("info");
+        await server.start();
+        expect(mockInnerServer.oninitialized).toBeInstanceOf(Function);
     });
-    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;
+    it("lists lsp_init before auto-init", 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 }));
+            registrar.registerTool("lsp_init", { description: "init" }, async () => ({ content: [{ type: "text", text: "ok" }], raw: null }));
+            registrar.registerTool("lsp_definition", { description: "definition" }, async () => ({
+                content: [{ type: "text", text: "definition" }],
+                raw: null,
+            }));
         });
         writeTools.mockImplementationOnce(() => undefined);
-        const { ListToolsRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
-        const server = new server_1.McpServer('info');
+        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');
+        expect(result.tools.map((t) => t.name)).toContain("lsp_init");
+        expect(result.tools.map((t) => t.name)).toContain("lsp_definition");
     });
-    it('lists all tools after initialization too', async () => {
-        const readTools = jest.requireMock('../tools/read-tools').registerReadTools;
-        const writeTools = jest.requireMock('../tools/write-tools').registerWriteTools;
+    it("hides lsp_init after successful auto-init (all servers ready)", 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 }));
+            registrar.registerTool("lsp_init", { description: "init" }, async () => ({ content: [{ type: "text", text: "ok" }], raw: null }));
+            registrar.registerTool("lsp_definition", { description: "definition" }, async () => ({
+                content: [{ type: "text", text: "definition" }],
+                raw: null,
+            }));
         });
         writeTools.mockImplementationOnce(() => undefined);
-        const { ListToolsRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
-        const server = new server_1.McpServer('info');
+        const health = [{ language: "typescript", status: "ready" }];
+        const manager = {
+            start: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            getHealth: jest.fn().mockReturnValue(health),
+        };
+        const factory = jest.fn().mockReturnValue(manager);
+        mockGetClientCapabilities.mockReturnValue({ roots: { listChanged: true } });
+        mockListRoots.mockResolvedValue({
+            roots: [{ uri: "file:///workspace/project" }],
+        });
+        const { ListToolsRequestSchema } = jest.requireActual("@modelcontextprotocol/sdk/types.js");
+        const server = new server_1.McpServer("info", factory);
         await server.start();
-        server.setManager({});
+        // Trigger the oninitialized callback
+        await mockInnerServer.oninitialized();
+        const listHandler = getHandler(ListToolsRequestSchema);
+        const result = await listHandler({});
+        expect(result.tools.map((t) => t.name)).not.toContain("lsp_init");
+        expect(result.tools.map((t) => t.name)).toContain("lsp_definition");
+    });
+    it("keeps lsp_init visible after auto-init when a server has errors", 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 health = [
+            { language: "typescript", status: "ready" },
+            { language: "python", status: "error", error: "pylsp not found" },
+        ];
+        const manager = {
+            start: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            getHealth: jest.fn().mockReturnValue(health),
+        };
+        const factory = jest.fn().mockReturnValue(manager);
+        mockGetClientCapabilities.mockReturnValue({ roots: { listChanged: true } });
+        mockListRoots.mockResolvedValue({
+            roots: [{ uri: "file:///workspace/project" }],
+        });
+        const { ListToolsRequestSchema } = jest.requireActual("@modelcontextprotocol/sdk/types.js");
+        const server = new server_1.McpServer("info", factory);
+        await server.start();
+        await mockInnerServer.oninitialized();
         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');
+        expect(result.tools.map((t) => t.name)).toContain("lsp_init");
     });
-    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;
+    it("falls back to persisted last root when client has no roots capability", async () => {
+        const { loadLastRoot, loadWorkspaceConfig } = jest.requireMock("../../utils/workspace-config");
+        loadLastRoot.mockResolvedValueOnce("/persisted/root");
+        loadWorkspaceConfig.mockResolvedValueOnce({ languages: ["typescript"] });
+        const health = [{ language: "typescript", status: "ready" }];
+        const manager = {
+            start: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            getHealth: jest.fn().mockReturnValue(health),
+        };
+        const factory = jest.fn().mockReturnValue(manager);
+        mockGetClientCapabilities.mockReturnValue(undefined); // no roots capability
+        const server = new server_1.McpServer("info", factory);
+        await server.start();
+        await mockInnerServer.oninitialized();
+        expect(manager.start).toHaveBeenCalled();
+        expect(server.isInitToolHidden()).toBe(true);
+    });
+    it("returns no-root error for non-init tools before initialization", 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 }));
+            registrar.registerTool("lsp_definition", { description: "definition" }, 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');
+        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: {} } });
+        const result = await callHandler({
+            params: { name: "lsp_definition", 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;
+    it("allows calling lsp_init directly even after initialization (re-init)", 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_init", { description: "init" }, async () => ({
+                content: [{ type: "text", text: "initialized" }],
+                raw: null,
+            }));
         });
         writeTools.mockImplementationOnce(() => undefined);
-        const { CallToolRequestSchema } = jest.requireActual('@modelcontextprotocol/sdk/types.js');
-        const server = new server_1.McpServer('info');
+        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/);
+        const result = await callHandler({
+            params: { name: "lsp_init", arguments: { root: "/x" } },
+        });
+        expect(result.content[0].text).toBe("initialized");
     });
-    it('shuts down the old manager before starting a new one', async () => {
+    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' }])
+            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'); }),
+            start: jest.fn().mockImplementation(async () => {
+                order.push("start-second");
+            }),
             shutdown: jest.fn().mockResolvedValue(undefined),
-            getHealth: jest.fn().mockReturnValue([{ language: 'python', status: 'ready' }])
+            getHealth: jest
+                .fn()
+                .mockReturnValue([{ language: "python", status: "ready" }]),
         };
-        const factory = jest.fn()
+        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' }]
+        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' }]
+        await expect(server.initializeManager("/workspace-two")).resolves.toEqual({
+            root: "/workspace-two",
+            health: [{ language: "python", status: "ready" }],
         });
-        expect(order).toEqual(['shutdown-first', 'start-second']);
+        expect(order).toEqual(["shutdown-first", "start-second"]);
     });
-    it('tolerates shutdown with no active manager', async () => {
-        const server = new server_1.McpServer('info');
+    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');
+    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);
     });
+    it("sends tool list changed notification when roots change", async () => {
+        const { RootsListChangedNotificationSchema } = jest.requireActual("@modelcontextprotocol/sdk/types.js");
+        const health = [{ language: "typescript", status: "ready" }];
+        const manager = {
+            start: jest.fn().mockResolvedValue(undefined),
+            shutdown: jest.fn().mockResolvedValue(undefined),
+            getHealth: jest.fn().mockReturnValue(health),
+        };
+        const factory = jest.fn().mockReturnValue(manager);
+        mockGetClientCapabilities.mockReturnValue({ roots: {} });
+        mockListRoots.mockResolvedValue({
+            roots: [{ uri: "file:///workspace/new-project" }],
+        });
+        const server = new server_1.McpServer("info", factory);
+        await server.start();
+        const notificationHandler = mockSetNotificationHandler.mock.calls.find(([s]) => s === RootsListChangedNotificationSchema)?.[1];
+        expect(notificationHandler).toBeDefined();
+        await notificationHandler({});
+        expect(mockSendToolListChanged).toHaveBeenCalled();
+    });
 });

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

@@ -171,29 +171,7 @@ describe("registerWriteTools", () => {
             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 () => {
+    it("supports indexed code actions and document changes", async () => {
         const registrar = new FakeRegistrar();
         const client = createClient([
             { title: "Skip me" },
@@ -230,34 +208,6 @@ describe("registerWriteTools", () => {
             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),
-            ensureSeedFilesOpen: jest.fn().mockResolvedValue(undefined),
-            analyzeWorkspace: 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();

package/dist/mcp/server.js

@@ -8,12 +8,15 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const lifecycle_manager_1 = require("../lsp/lifecycle-manager");
 const shared_1 = require("./tools/shared");
+const workspace_config_1 = require("../utils/workspace-config");
 const read_tools_1 = require("./tools/read-tools");
 const write_tools_1 = require("./tools/write-tools");
 class McpServer {
     currentManager = null;
     currentRoot = null;
     initialized = false;
+    /** When true, lsp_init is hidden from ListTools (client auto-initialized). */
+    hideInitTool = false;
     logLevel;
     createLifecycleManager;
     server;
@@ -39,10 +42,24 @@ class McpServer {
             },
         };
         (0, read_tools_1.registerReadTools)(registrar, lifecycleProxy, {
-            initializeManager: async (root, languages) => await this.initializeManager(root, languages),
+            initializeManager: async (root, languages) => {
+                const result = await this.initializeManager(root, languages);
+                // When lsp_init is called explicitly, hide it on success, re-expose on error
+                this.updateInitVisibility(result.health);
+                await this.server.server.sendToolListChanged();
+                return result;
+            },
         });
         (0, write_tools_1.registerWriteTools)(registrar, lifecycleProxy);
         this.configureToolHandlers();
+        // Hook into post-handshake to attempt auto-init from roots or persisted config.
+        // Cast to `() => void` to satisfy the SDK type while still returning the promise
+        // so test harnesses can await it when needed.
+        this.server.server.oninitialized = (() => this.tryAutoInit());
+        // Handle roots/list_changed: client switched workspace
+        this.server.server.setNotificationHandler(types_js_1.RootsListChangedNotificationSchema, async () => {
+            await this.tryAutoInitFromRoots();
+        });
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);
     }
@@ -68,10 +85,69 @@ class McpServer {
         this.currentManager = null;
         this.currentRoot = null;
         this.initialized = false;
+        this.hideInitTool = false;
         if (activeManager) {
             await activeManager.shutdown();
         }
     }
+    /** True when lsp_init is currently hidden from the tool list. */
+    isInitToolHidden() {
+        return this.hideInitTool;
+    }
+    updateInitVisibility(health) {
+        const hasErrors = health.some((entry) => entry.status === "error");
+        this.hideInitTool = !hasErrors;
+    }
+    async tryAutoInit() {
+        // Prefer roots from the client if supported
+        const caps = this.server.server.getClientCapabilities();
+        if (caps?.roots) {
+            await this.tryAutoInitFromRoots();
+            return;
+        }
+        // Fallback: load the last-used root from persisted config
+        try {
+            const lastRoot = await (0, workspace_config_1.loadLastRoot)();
+            if (lastRoot) {
+                await this.autoInitRoot(lastRoot);
+            }
+        }
+        catch {
+            // Non-fatal; lsp_init stays visible
+        }
+    }
+    async tryAutoInitFromRoots() {
+        try {
+            const { roots } = await this.server.server.listRoots();
+            const firstUri = roots[0]?.uri;
+            if (!firstUri?.startsWith("file://"))
+                return;
+            // file:///path/to/project → /path/to/project
+            const root = decodeURIComponent(new URL(firstUri).pathname);
+            await this.autoInitRoot(root);
+        }
+        catch {
+            // Client may not support roots (e.g. Cursor bug) — stay visible
+        }
+    }
+    async autoInitRoot(root) {
+        const saved = await (0, workspace_config_1.loadWorkspaceConfig)(root);
+        const languages = saved?.languages;
+        const result = await this.initializeManager(root, languages);
+        this.updateInitVisibility(result.health);
+        // Persist successful init so we can restore on next startup
+        const readyLanguages = result.health
+            .filter((e) => e.status === "ready")
+            .map((e) => e.language);
+        await (0, workspace_config_1.saveWorkspaceConfig)(root, { languages: readyLanguages });
+        // Notify client that tool list may have changed (lsp_init hidden/shown)
+        try {
+            await this.server.server.sendToolListChanged();
+        }
+        catch {
+            // Client may not support list-changed notifications
+        }
+    }
     configureToolHandlers() {
         this.server.server.registerCapabilities({ tools: {} });
         this.server.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
@@ -79,9 +155,6 @@ class McpServer {
         }));
         this.server.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const toolName = request.params.name;
-            if (toolName === "lsp_init" && this.initialized) {
-                return (0, shared_1.failure)(`Already initialized at ${this.currentRoot ?? "unknown"}. Call lsp_init again with a new root to switch projects.`);
-            }
             if (toolName !== "lsp_init" && !this.initialized) {
                 return (0, shared_1.noProjectRootResult)();
             }
@@ -93,7 +166,9 @@ class McpServer {
         });
     }
     listTools() {
-        return [...this.tools.values()].map((tool) => ({
+        return [...this.tools.values()]
+            .filter((tool) => !(tool.name === "lsp_init" && this.hideInitTool))
+            .map((tool) => ({
             name: tool.name,
             description: tool.description,
             inputSchema: this.toInputSchema(tool.inputSchema),

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

@@ -20,16 +20,6 @@ function registerReadTools(registrar, lifecycleManager, options) {
     }, async (args) => {
         return await handleInitTool(args, options);
     });
-    registrar.registerTool("lsp_hover", { description: "Show hover information", inputSchema: positionSchema }, async (args) => {
-        return await runFileRequest({
-            args,
-            lifecycleManager,
-            method: "textDocument/hover",
-            timeoutMs: 5000,
-            format: formatters_1.formatHover,
-            raw: (result) => result,
-        });
-    });
     registrar.registerTool("lsp_definition", { description: "Find definitions", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({
             args,
@@ -86,16 +76,6 @@ function registerReadTools(registrar, lifecycleManager, options) {
         const merged = results.flat().slice(0, query === "" ? 100 : 500);
         return (0, shared_1.success)((0, formatters_1.formatSymbols)(merged), (0, shared_1.normalizeSymbols)(merged));
     });
-    registrar.registerTool("lsp_completion", { description: "Get completions", inputSchema: positionSchema }, async (args) => {
-        return await runFileRequest({
-            args,
-            lifecycleManager,
-            method: "textDocument/completion",
-            timeoutMs: 5000,
-            format: (result) => (0, formatters_1.formatCompletion)(asCompletionItems(result)),
-            raw: (result) => asCompletionItems(result)?.slice(0, 50) ?? null,
-        });
-    });
     registrar.registerTool("lsp_diagnostics", {
         description: "Get errors and warnings. Pass a file path to trigger analysis of that file and its language server, then return diagnostics for that file (scope: file) or all files seen so far (scope: workspace). Omit file for workspace scope to query whatever has been opened previously.",
         inputSchema: zod_1.z.object({
@@ -129,16 +109,6 @@ function registerReadTools(registrar, lifecycleManager, options) {
         const diagnostics = lifecycleManager.getFileDiagnostics(filePath);
         return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, "file"), diagnostics);
     });
-    registrar.registerTool("lsp_signature_help", { description: "Show signature help", inputSchema: positionSchema }, async (args) => {
-        return await runFileRequest({
-            args,
-            lifecycleManager,
-            method: "textDocument/signatureHelp",
-            timeoutMs: 5000,
-            format: stringifyResult,
-            raw: (result) => result,
-        });
-    });
     registrar.registerTool("lsp_type_definition", { description: "Find type definitions", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({
             args,
@@ -242,18 +212,6 @@ function asLocationArray(result) {
     }
     return Array.isArray(result) ? result : [result];
 }
-function asCompletionItems(result) {
-    if (!result) {
-        return null;
-    }
-    return Array.isArray(result) ? result : result.items;
-}
-function stringifyResult(result) {
-    if (!result) {
-        return "No result";
-    }
-    return JSON.stringify(result, null, 2);
-}
 function formatLanguageList(languages) {
     return languages.length === 0 ? "None" : languages.join(", ");
 }

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

@@ -83,19 +83,6 @@ function registerWriteTools(registrar, lifecycleManager) {
             }, 15000);
         });
     });
-    registrar.registerTool('lsp_apply_workspace_edit', { description: 'Apply raw workspace edit', inputSchema: zod_1.z.object({ edit: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()) }) }, async (args) => {
-        const clients = lifecycleManager.getReadyClients();
-        const client = clients[0] ?? null;
-        if (!client) {
-            return (0, shared_1.failure)('No language servers are ready. Run lsp_health for details.');
-        }
-        try {
-            return await applyWorkspaceEdit((args.edit ?? null), lifecycleManager, client, 'Applied workspace edit to');
-        }
-        catch (error) {
-            return (0, shared_1.mapToolError)(error, 15);
-        }
-    });
 }
 const positionSchema = zod_1.z.object({ line: zod_1.z.number().int(), character: zod_1.z.number().int() });
 const rangeSchema = zod_1.z.object({ start: positionSchema, end: positionSchema });

package/dist/utils/workspace-config.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadWorkspaceConfig = loadWorkspaceConfig;
+exports.saveWorkspaceConfig = saveWorkspaceConfig;
+exports.loadLastRoot = loadLastRoot;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+function getConfigDir() {
+    const platform = node_os_1.default.platform();
+    if (platform === "win32") {
+        const appData = process.env["APPDATA"];
+        if (appData)
+            return node_path_1.default.join(appData, "lsp-mcp");
+        return node_path_1.default.join(node_os_1.default.homedir(), "AppData", "Roaming", "lsp-mcp");
+    }
+    if (platform === "darwin") {
+        return node_path_1.default.join(node_os_1.default.homedir(), "Library", "Application Support", "lsp-mcp");
+    }
+    // Linux / other POSIX — respect XDG
+    const xdgConfig = process.env["XDG_CONFIG_HOME"];
+    const base = xdgConfig ?? node_path_1.default.join(node_os_1.default.homedir(), ".config");
+    return node_path_1.default.join(base, "lsp-mcp");
+}
+const CONFIG_FILE = node_path_1.default.join(getConfigDir(), "config.json");
+async function readConfig() {
+    try {
+        const raw = await (0, promises_1.readFile)(CONFIG_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            "workspaces" in parsed &&
+            typeof parsed.workspaces === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // File missing or malformed — start fresh
+    }
+    return { workspaces: {} };
+}
+async function writeConfig(config) {
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(CONFIG_FILE), { recursive: true });
+    await (0, promises_1.writeFile)(CONFIG_FILE, JSON.stringify(config, null, 2), "utf8");
+}
+async function loadWorkspaceConfig(root) {
+    const config = await readConfig();
+    return config.workspaces[root] ?? null;
+}
+async function saveWorkspaceConfig(root, entry) {
+    const config = await readConfig();
+    config.workspaces[root] = entry;
+    config.lastRoot = root;
+    await writeConfig(config);
+}
+async function loadLastRoot() {
+    const config = await readConfig();
+    return config.lastRoot ?? null;
+}

package/package.json

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