@theupsider/lsp-mcp 1.0.8 → 1.1.0

package/README.md

@@ -32,6 +32,9 @@ 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
+- **🤖 Hands-Free Initialization** — Clients that support [MCP Roots](https://modelcontextprotocol.io/docs/concepts/roots) auto-initialize on connect — `lsp_init` disappears from the tool list once all servers start cleanly
+- **💾 Cross-Session Persistence** — Initialized workspaces and their ready languages are remembered across server restarts
+- **🔁 Graceful Degradation** — `lsp_init` reappears if a previously-working server starts failing (e.g. language added, binary missing)
 - **🛠 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
@@ -45,10 +48,10 @@ A Model Context Protocol (MCP) server that gives language models access to **Lan
 
 ```bash
 # npm
-npm install -g @theupsider/lsp-mcp
+npm install -g @theupsider/lsp-mcp@latest
 
 # bun
-bun install -g @theupsider/lsp-mcp
+bun install -g @theupsider/lsp-mcp@latest
 ```
 
 ## Quickstart
@@ -63,7 +66,7 @@ Add to your **workspace** `.vscode/mcp.json` (recommended — ensures the server
     "lsp-mcp": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "@theupsider/lsp-mcp"]
+      "args": ["-y", "@theupsider/lsp-mcp@latest"]
     }
   }
 }
@@ -78,7 +81,9 @@ Add to your **workspace** `.vscode/mcp.json` (recommended — ensures the server
 lsp-mcp
 ```
 
-The server starts with no active project. The first action the model must take is calling `lsp_init`:
+The server starts with no active project. **Most clients auto-initialize** when they support the MCP Roots protocol (VS Code, Copilot, etc.), but `lsp_init` remains available as a manual override.
+
+For clients without Roots support, the first action the model must take is calling `lsp_init`:
 
 ```
 lsp_init({ root: "/path/to/your/project" })
@@ -87,7 +92,7 @@ lsp_init({ root: "/path/to/your/project" })
 `lsp_init` will:
 
 1. Scan the root for language markers and start matching language servers (best-effort)
-2. Disappear from the tool list — subsequent calls to any LSP tool trigger lazy server startup for that file's language if no server was detected at init time
+2. Disappear from the tool list when you called it explicitly — subsequent calls to any LSP tool trigger lazy server startup for that file's language if no server was detected at init time
 3. Return health status for all servers that were started eagerly
 
 **Optional: pre-warm specific languages** (skips detection, faster cold start):
@@ -96,36 +101,40 @@ lsp_init({ root: "/path/to/your/project" })
 lsp_init({ root: "/path/to/project", languages: ["python", "typescript"] })
 ```
 
+**Persistence:** Once initialized, the workspace configuration (detected languages) is saved to your OS-standard config directory (`~/.config/lsp-mcp/` on Linux, `~/Library/Application Support/lsp-mcp/` on macOS, `%APPDATA%\lsp-mcp\` on Windows). On subsequent server startups, the MCP server will automatically reconnect using the last-known root, so you rarely need to call `lsp_init` again.
+
+**Re-emergence:** If a language server that was previously healthy fails to start (e.g. you added a new language or removed a binary), `lsp_init` will reappear in the tool list, signaling the model should re-initialize.
+
 ## Available Tools
 
 ### Read-Only Tools
 
-| Tool                    | Description                             | Key Parameters                                         |
-| ----------------------- | --------------------------------------- | ------------------------------------------------------ |
-| `lsp_init`              | Initialize server for a project root    | `root` (required), `languages` (optional string array) |
-| `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_diagnostics`       | Get errors & warnings           | `file` (scope: `file` or `workspace`) |
-| `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)_                              |
+| Tool                    | Description                          | Key Parameters                                         | Visibility                                                       |
+| ----------------------- | ------------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------- |
+| `lsp_init`              | Initialize server for a project root | `root` (required), `languages` (optional string array) | Conditional — hidden after a successful explicit `lsp_init` call |
+| `lsp_definition`        | Go to definition                     | `file`, `line`, `character`                            | Always                                                           |
+| `lsp_references`        | Find all references                  | `file`, `line`, `character`                            | Always                                                           |
+| `lsp_document_symbols`  | List symbols in a file               | `file`                                                 | Always                                                           |
+| `lsp_workspace_symbols` | Search symbols across workspace      | `query` (limit: 100–500 results)                       | Always                                                           |
+| `lsp_diagnostics`       | Get errors & warnings                | `file` (scope: `file` or `workspace`)                  | Always                                                           |
+| `lsp_type_definition`   | Go to type definition                | `file`, `line`, `character`                            | Always                                                           |
+| `lsp_implementation`    | Find implementations                 | `file`, `line`, `character`                            | Always                                                           |
+| `lsp_health`            | Check status of all LSP servers      | _(none)_                                               | Always                                                           |
 
 ### Write Tools
 
-| Tool                       | Description               | Key Parameters                         |
-| -------------------------- | ------------------------- | -------------------------------------- |
-| `lsp_rename`               | Rename symbol             | `file`, `line`, `character`, `newName` |
-| `lsp_code_action`          | Apply / list code actions | `file`, `line`, `character`, `apply`   |
-| `lsp_formatting`           | Format document           | `file`                                 |
-| `lsp_range_formatting`     | Format code range         | `file`, `range`                        |
+| Tool                   | Description               | Key Parameters                         |
+| ---------------------- | ------------------------- | -------------------------------------- |
+| `lsp_rename`           | Rename symbol             | `file`, `line`, `character`, `newName` |
+| `lsp_code_action`      | Apply / list code actions | `file`, `line`, `character`, `apply`   |
+| `lsp_formatting`       | Format document           | `file`                                 |
+| `lsp_range_formatting` | Format code range         | `file`, `range`                        |
 
 ## Configuration
 
-| Environment Variable | Description                         | Default      |
-| -------------------- | ----------------------------------- | ------------ |
-| `LSP_MCP_LOG_LEVEL`  | Log level: `error`, `info`, `debug` | `info`       |
+| Environment Variable | Description                         | Default |
+| -------------------- | ----------------------------------- | ------- |
+| `LSP_MCP_LOG_LEVEL`  | Log level: `error`, `info`, `debug` | `info`  |
 
 ## Setup Scripts
 

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,278 @@ function getHandler(schema) {
         throw new Error(`No handler registered for schema`);
     return call[1];
 }
-describe('McpServer', () => {
+async function flushAutoInit() {
+    await new Promise((resolve) => setImmediate(resolve));
+}
+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_definition', { description: 'definition' }, async () => ({ content: [{ type: 'text', text: 'definition' }], 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_definition');
+        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("keeps lsp_init visible 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_definition', { description: 'definition' }, async () => ({ content: [{ type: 'text', text: 'definition' }], 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({});
+        mockInnerServer.oninitialized();
+        await flushAutoInit();
+        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_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();
+        mockInnerServer.oninitialized();
+        await flushAutoInit();
+        const listHandler = getHandler(ListToolsRequestSchema);
+        const result = await listHandler({});
+        expect(result.tools.map((t) => t.name)).toContain("lsp_init");
+    });
+    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();
+        mockInnerServer.oninitialized();
+        await flushAutoInit();
+        expect(manager.start).toHaveBeenCalled();
+        expect(server.isInitToolHidden()).toBe(false);
+    });
+    it("hides lsp_init after a successful explicit init", async () => {
+        const readTools = jest.requireMock("../tools/read-tools")
+            .registerReadTools;
+        const writeTools = jest.requireMock("../tools/write-tools")
+            .registerWriteTools;
+        readTools.mockImplementationOnce((registrar, _lifecycle, options) => {
+            registrar.registerTool("lsp_init", { description: "init" }, async (args) => {
+                const result = await options.initializeManager(args.root);
+                return {
+                    content: [{ type: "text", text: result.root }],
+                    raw: result,
+                };
+            });
+        });
+        writeTools.mockImplementationOnce(() => undefined);
+        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);
+        const { CallToolRequestSchema, ListToolsRequestSchema } = jest.requireActual("@modelcontextprotocol/sdk/types.js");
+        const server = new server_1.McpServer("info", factory);
+        await server.start();
+        const callHandler = getHandler(CallToolRequestSchema);
+        await callHandler({
+            params: { name: "lsp_init", arguments: { root: "/workspace/project" } },
+        });
         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_definition');
+        expect(result.tools.map((t) => t.name)).not.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("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_definition', { description: 'definition' }, 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_definition', 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/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,27 @@ 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);
+                // Hide lsp_init only after an explicit init call.
+                this.updateInitVisibility(result.health, "explicit");
+                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.
+        const onInitialized = async () => {
+            await this.tryAutoInit();
+        };
+        this.server.server.oninitialized = () => {
+            void onInitialized();
+        };
+        // 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 +88,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, source) {
+        const hasErrors = health.some((entry) => entry.status === "error");
+        this.hideInitTool = source === "explicit" && !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, "auto");
+        // 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 +158,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 +169,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/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.8",
+  "version": "1.1.0",
   "description": "Universal LSP MCP server",
   "license": "Apache-2.0",
   "type": "commonjs",