@theupsider/lsp-mcp 1.0.8 → 1.0.9

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_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("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_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({});
+        // 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_definition');
+        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_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,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/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.0.9",
   "description": "Universal LSP MCP server",
   "license": "Apache-2.0",
   "type": "commonjs",