@treedy/lsp-mcp 0.1.7 → 0.1.9

package/dist/index.js

@@ -6495,8 +6495,8 @@ var require_dist = __commonJS((exports, module) => {
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs = __require("fs");
-  function checkPathExt(path, options) {
+  var fs2 = __require("fs");
+  function checkPathExt(path2, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -6507,25 +6507,25 @@ var require_windows = __commonJS((exports, module) => {
     }
     for (var i = 0;i < pathext.length; i++) {
       var p = pathext[i].toLowerCase();
-      if (p && path.substr(-p.length).toLowerCase() === p) {
+      if (p && path2.substr(-p.length).toLowerCase() === p) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat, path, options) {
+  function checkStat(stat, path2, options) {
     if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
-    return checkPathExt(path, options);
+    return checkPathExt(path2, options);
   }
-  function isexe(path, options, cb) {
-    fs.stat(path, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path, options));
+  function isexe(path2, options, cb) {
+    fs2.stat(path2, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path2, options));
     });
   }
-  function sync(path, options) {
-    return checkStat(fs.statSync(path), path, options);
+  function sync(path2, options) {
+    return checkStat(fs2.statSync(path2), path2, options);
   }
 });
 
@@ -6533,14 +6533,14 @@ var require_windows = __commonJS((exports, module) => {
 var require_mode = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs = __require("fs");
-  function isexe(path, options, cb) {
-    fs.stat(path, function(er, stat) {
+  var fs2 = __require("fs");
+  function isexe(path2, options, cb) {
+    fs2.stat(path2, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options));
     });
   }
-  function sync(path, options) {
-    return checkStat(fs.statSync(path), options);
+  function sync(path2, options) {
+    return checkStat(fs2.statSync(path2), options);
   }
   function checkStat(stat, options) {
     return stat.isFile() && checkMode(stat, options);
@@ -6562,7 +6562,7 @@ var require_mode = __commonJS((exports, module) => {
 
 // node_modules/isexe/index.js
 var require_isexe = __commonJS((exports, module) => {
-  var fs = __require("fs");
+  var fs2 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -6571,7 +6571,7 @@ var require_isexe = __commonJS((exports, module) => {
   }
   module.exports = isexe;
   isexe.sync = sync;
-  function isexe(path, options, cb) {
+  function isexe(path2, options, cb) {
     if (typeof options === "function") {
       cb = options;
       options = {};
@@ -6580,17 +6580,17 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve, reject) {
-        isexe(path, options || {}, function(er, is) {
+      return new Promise(function(resolve2, reject) {
+        isexe(path2, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve(is);
+            resolve2(is);
           }
         });
       });
     }
-    core2(path, options || {}, function(er, is) {
+    core2(path2, options || {}, function(er, is) {
       if (er) {
         if (er.code === "EACCES" || options && options.ignoreErrors) {
           er = null;
@@ -6600,9 +6600,9 @@ var require_isexe = __commonJS((exports, module) => {
       cb(er, is);
     });
   }
-  function sync(path, options) {
+  function sync(path2, options) {
     try {
-      return core2.sync(path, options || {});
+      return core2.sync(path2, options || {});
     } catch (er) {
       if (options && options.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -6616,7 +6616,7 @@ var require_isexe = __commonJS((exports, module) => {
 // node_modules/which/which.js
 var require_which = __commonJS((exports, module) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path = __require("path");
+  var path2 = __require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -6647,27 +6647,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i) => new Promise((resolve, reject) => {
+    const step = (i) => new Promise((resolve2, reject) => {
       if (i === pathEnv.length)
-        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path.join(pathPart, cmd);
+      const pCmd = path2.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve(subStep(p, i, 0));
+      resolve2(subStep(p, i, 0));
     });
-    const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+    const subStep = (p, i, ii) => new Promise((resolve2, reject) => {
       if (ii === pathExt.length)
-        return resolve(step(i + 1));
+        return resolve2(step(i + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve(p + ext);
+            return resolve2(p + ext);
         }
-        return resolve(subStep(p, i, ii + 1));
+        return resolve2(subStep(p, i, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -6679,7 +6679,7 @@ var require_which = __commonJS((exports, module) => {
     for (let i = 0;i < pathEnv.length; i++) {
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path.join(pathPart, cmd);
+      const pCmd = path2.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j = 0;j < pathExt.length; j++) {
         const cur = p + pathExt[j];
@@ -6720,7 +6720,7 @@ var require_path_key = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports, module) => {
-  var path = __require("path");
+  var path2 = __require("path");
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -6737,7 +6737,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
     try {
       resolved = which.sync(parsed.command, {
         path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path.delimiter : undefined
+        pathExt: withoutPathExt ? path2.delimiter : undefined
       });
     } catch (e) {} finally {
       if (shouldSwitchCwd) {
@@ -6745,7 +6745,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
       }
     }
     if (resolved) {
-      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path2.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -6790,8 +6790,8 @@ var require_shebang_command = __commonJS((exports, module) => {
     if (!match) {
       return null;
     }
-    const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path.split("/").pop();
+    const [path2, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path2.split("/").pop();
     if (binary === "env") {
       return argument;
     }
@@ -6801,16 +6801,16 @@ var require_shebang_command = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS((exports, module) => {
-  var fs = __require("fs");
+  var fs2 = __require("fs");
   var shebangCommand = require_shebang_command();
   function readShebang(command) {
     const size = 150;
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs.openSync(command, "r");
-      fs.readSync(fd, buffer, 0, size, 0);
-      fs.closeSync(fd);
+      fd = fs2.openSync(command, "r");
+      fs2.readSync(fd, buffer, 0, size, 0);
+      fs2.closeSync(fd);
     } catch (e) {}
     return shebangCommand(buffer.toString());
   }
@@ -6819,7 +6819,7 @@ var require_readShebang = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/parse.js
 var require_parse = __commonJS((exports, module) => {
-  var path = __require("path");
+  var path2 = __require("path");
   var resolveCommand = require_resolveCommand();
   var escape2 = require_escape();
   var readShebang = require_readShebang();
@@ -6844,7 +6844,7 @@ var require_parse = __commonJS((exports, module) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path.normalize(parsed.command);
+      parsed.command = path2.normalize(parsed.command);
       parsed.command = escape2.command(parsed.command);
       parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -19837,29 +19837,116 @@ class StdioServerTransport {
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
+import * as fs2 from "fs";
+import * as path2 from "path";
 
 // src/config.ts
-function loadConfig() {
-  const pythonEnabled = getEnvBool("LSP_MCP_PYTHON_ENABLED", true);
-  const pythonProvider = getEnvString("LSP_MCP_PYTHON_PROVIDER", "python-lsp-mcp");
-  const typescriptEnabled = getEnvBool("LSP_MCP_TYPESCRIPT_ENABLED", true);
-  const vueEnabled = getEnvBool("LSP_MCP_VUE_ENABLED", true);
-  const autoUpdate = getEnvBool("LSP_MCP_AUTO_UPDATE", true);
-  const eagerStart = getEnvBool("LSP_MCP_EAGER_START", false);
-  return {
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import { fileURLToPath } from "url";
+var DEFAULT_EXTENSIONS = {
+  python: [".py", ".pyi", ".pyw"],
+  typescript: [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"],
+  vue: [".vue"]
+};
+var DEFAULT_CONFIG = {
+  languages: {
     python: {
-      enabled: pythonEnabled,
-      provider: pythonProvider
+      enabled: true,
+      extensions: DEFAULT_EXTENSIONS.python
     },
     typescript: {
-      enabled: typescriptEnabled
+      enabled: true,
+      extensions: DEFAULT_EXTENSIONS.typescript
     },
     vue: {
-      enabled: vueEnabled
-    },
-    autoUpdate,
-    eagerStart
+      enabled: true,
+      extensions: DEFAULT_EXTENSIONS.vue
+    }
+  },
+  autoUpdate: true,
+  eagerStart: false,
+  idleTimeout: 600
+};
+function loadConfig() {
+  const fileConfig = loadConfigFile();
+  const envConfig = loadEnvConfig();
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...fileConfig,
+    ...envConfig,
+    languages: {
+      ...DEFAULT_CONFIG.languages,
+      ...fileConfig?.languages || {},
+      ...Object.keys(DEFAULT_CONFIG.languages).reduce((acc, lang) => {
+        if (envConfig.languages?.[lang]) {
+          acc[lang] = {
+            ...fileConfig?.languages?.[lang] || DEFAULT_CONFIG.languages[lang],
+            ...envConfig.languages[lang]
+          };
+        }
+        return acc;
+      }, {})
+    }
   };
+  for (const [lang, cfg] of Object.entries(merged.languages)) {
+    if (!cfg.extensions && DEFAULT_EXTENSIONS[lang]) {
+      cfg.extensions = DEFAULT_EXTENSIONS[lang];
+    }
+  }
+  return merged;
+}
+function loadConfigFile() {
+  const locations = [
+    path.resolve(process.cwd(), ".lsp-mcp.json"),
+    path.join(os.homedir(), ".config", "lsp-mcp", "config.json")
+  ];
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      try {
+        console.error(`[Config] Loading configuration from ${loc}`);
+        const content = fs.readFileSync(loc, "utf-8");
+        return JSON.parse(content);
+      } catch (e) {
+        console.error(`[Config] Failed to parse config file ${loc}: ${e}`);
+      }
+    }
+  }
+  return null;
+}
+function loadEnvConfig() {
+  const pythonEnabled = getEnvBool("LSP_MCP_PYTHON_ENABLED");
+  const pythonProvider = getEnvString("LSP_MCP_PYTHON_PROVIDER");
+  const typescriptEnabled = getEnvBool("LSP_MCP_TYPESCRIPT_ENABLED");
+  const vueEnabled = getEnvBool("LSP_MCP_VUE_ENABLED");
+  const autoUpdate = getEnvBool("LSP_MCP_AUTO_UPDATE");
+  const eagerStart = getEnvBool("LSP_MCP_EAGER_START");
+  const idleTimeoutStr = getEnvString("LSP_MCP_IDLE_TIMEOUT");
+  const idleTimeout = idleTimeoutStr ? parseInt(idleTimeoutStr, 10) : undefined;
+  const config2 = {};
+  const languages = {};
+  if (pythonEnabled !== undefined)
+    languages.python = { enabled: pythonEnabled };
+  if (typescriptEnabled !== undefined)
+    languages.typescript = { enabled: typescriptEnabled };
+  if (vueEnabled !== undefined)
+    languages.vue = { enabled: vueEnabled };
+  if (Object.keys(languages).length > 0)
+    config2.languages = languages;
+  if (autoUpdate !== undefined)
+    config2.autoUpdate = autoUpdate;
+  if (eagerStart !== undefined)
+    config2.eagerStart = eagerStart;
+  if (idleTimeout !== undefined)
+    config2.idleTimeout = idleTimeout;
+  if (pythonEnabled !== undefined || pythonProvider) {
+    config2.python = {
+      enabled: pythonEnabled ?? true,
+      provider: pythonProvider ?? "python-lsp-mcp"
+    };
+  }
+  return config2;
 }
 function getEnvBool(name, defaultValue) {
   const value = process.env[name];
@@ -19870,18 +19957,66 @@ function getEnvBool(name, defaultValue) {
 function getEnvString(name, defaultValue) {
   return process.env[name] ?? defaultValue;
 }
+function inferLanguageFromPath(filePath, config2) {
+  const ext = filePath.substring(filePath.lastIndexOf("."));
+  for (const [lang, langConfig] of Object.entries(config2.languages)) {
+    if (langConfig.enabled && langConfig.extensions.includes(ext)) {
+      return lang;
+    }
+  }
+  return null;
+}
+function resolveBundledBackend(name) {
+  try {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const isInDist = currentDir.endsWith("dist") || currentDir.endsWith("dist/");
+    const bundledDir = isInDist ? path.resolve(currentDir, "bundled", name) : path.resolve(currentDir, "..", "dist", "bundled", name);
+    if (fs.existsSync(bundledDir)) {
+      return bundledDir;
+    }
+  } catch (error2) {}
+  return null;
+}
 function getBackendCommand(language, config2) {
+  const langConfig = config2.languages[language];
+  if (!langConfig || !langConfig.enabled)
+    return null;
+  if (langConfig.command) {
+    return {
+      enabled: true,
+      command: langConfig.command,
+      args: langConfig.args || [],
+      env: langConfig.env
+    };
+  }
   const { autoUpdate } = config2;
   if (language === "python") {
-    if (!config2.python.enabled)
-      return null;
-    if (config2.python.provider === "pyright-mcp") {
+    const provider = config2.python?.provider || "python-lsp-mcp";
+    if (provider === "pyright-mcp") {
+      const bundledPath = resolveBundledBackend("pyright");
+      if (bundledPath) {
+        console.error(`[Config] Using bundled pyright backend from ${bundledPath}`);
+        return {
+          enabled: true,
+          command: "node",
+          args: [path.join(bundledPath, "dist", "index.js")]
+        };
+      }
       return {
         enabled: true,
         command: "npx",
         args: autoUpdate ? ["--yes", "@treedy/pyright-mcp@latest"] : ["@treedy/pyright-mcp@latest"]
       };
     } else {
+      const bundledPath = resolveBundledBackend("python");
+      if (bundledPath) {
+        console.error(`[Config] Using bundled python backend from ${bundledPath}`);
+        return {
+          enabled: true,
+          command: "uv",
+          args: ["run", "--directory", bundledPath, "python-lsp-mcp"]
+        };
+      }
       return {
         enabled: true,
         command: "uvx",
@@ -19889,16 +20024,30 @@ function getBackendCommand(language, config2) {
       };
     }
   } else if (language === "typescript") {
-    if (!config2.typescript.enabled)
-      return null;
+    const bundledPath = resolveBundledBackend("typescript");
+    if (bundledPath) {
+      console.error(`[Config] Using bundled typescript backend from ${bundledPath}`);
+      return {
+        enabled: true,
+        command: "node",
+        args: [path.join(bundledPath, "dist", "index.js")]
+      };
+    }
     return {
       enabled: true,
       command: "npx",
       args: autoUpdate ? ["--yes", "@treedy/typescript-lsp-mcp@latest"] : ["@treedy/typescript-lsp-mcp@latest"]
     };
   } else if (language === "vue") {
-    if (!config2.vue.enabled)
-      return null;
+    const bundledPath = resolveBundledBackend("vue");
+    if (bundledPath) {
+      console.error(`[Config] Using bundled vue backend from ${bundledPath}`);
+      return {
+        enabled: true,
+        command: "node",
+        args: [path.join(bundledPath, "dist", "index.js")]
+      };
+    }
     return {
       enabled: true,
       command: "npx",
@@ -20487,7 +20636,7 @@ class StdioClientTransport {
     if (this._process) {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this._process = import_cross_spawn.default(this._serverParams.command, this._serverParams.args ?? [], {
         env: {
           ...getDefaultEnvironment(),
@@ -20503,7 +20652,7 @@ class StdioClientTransport {
         this.onerror?.(error2);
       });
       this._process.on("spawn", () => {
-        resolve();
+        resolve2();
       });
       this._process.on("close", (_code) => {
         this._process = undefined;
@@ -20550,20 +20699,20 @@ class StdioClientTransport {
     if (this._process) {
       const processToClose = this._process;
       this._process = undefined;
-      const closePromise = new Promise((resolve) => {
+      const closePromise = new Promise((resolve2) => {
         processToClose.once("close", () => {
-          resolve();
+          resolve2();
         });
       });
       try {
         processToClose.stdin?.end();
       } catch {}
-      await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2000).unref())]);
+      await Promise.race([closePromise, new Promise((resolve2) => setTimeout(resolve2, 2000).unref())]);
       if (processToClose.exitCode === null) {
         try {
           processToClose.kill("SIGTERM");
         } catch {}
-        await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2000).unref())]);
+        await Promise.race([closePromise, new Promise((resolve2) => setTimeout(resolve2, 2000).unref())]);
       }
       if (processToClose.exitCode === null) {
         try {
@@ -20574,15 +20723,15 @@ class StdioClientTransport {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       if (!this._process?.stdin) {
         throw new Error("Not connected");
       }
       const json = serializeMessage(message);
       if (this._process.stdin.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._process.stdin.once("drain", resolve);
+        this._process.stdin.once("drain", resolve2);
       }
     });
   }
@@ -20596,12 +20745,43 @@ class BackendManager {
   backends = new Map;
   startPromises = new Map;
   config;
+  idleCheckInterval = null;
   constructor(config2) {
     this.config = config2;
+    if (this.config.idleTimeout > 0) {
+      this.idleCheckInterval = setInterval(() => this.checkIdle(), 60 * 1000);
+      if (this.idleCheckInterval.unref) {
+        this.idleCheckInterval.unref();
+      }
+    }
+  }
+  async checkIdle() {
+    const now = Date.now();
+    const timeoutMs = this.config.idleTimeout * 1000;
+    for (const [lang, state] of this.backends.entries()) {
+      if (state.status === "ready" && now - state.lastUsed > timeoutMs) {
+        console.error(`[BackendManager] ${lang} backend idle for ${this.config.idleTimeout}s, shutting down...`);
+        await this.shutdownBackend(lang);
+      }
+    }
+  }
+  updateConfig(newConfig) {
+    this.config = newConfig;
+    if (this.idleCheckInterval) {
+      clearInterval(this.idleCheckInterval);
+      this.idleCheckInterval = null;
+    }
+    if (this.config.idleTimeout > 0) {
+      this.idleCheckInterval = setInterval(() => this.checkIdle(), 60 * 1000);
+      if (this.idleCheckInterval.unref) {
+        this.idleCheckInterval.unref();
+      }
+    }
   }
   async getBackend(language) {
     const existing = this.backends.get(language);
     if (existing && existing.status === "ready") {
+      existing.lastUsed = Date.now();
       return existing;
     }
     const pending = this.startPromises.get(language);
@@ -20617,6 +20797,62 @@ class BackendManager {
       this.startPromises.delete(language);
     }
   }
+  monitorBackend(language, transport) {
+    transport.onclose = async () => {
+      const state = this.backends.get(language);
+      if (!state || state.status === "stopped")
+        return;
+      console.error(`[BackendManager] ${language} backend connection closed unexpectedly.`);
+      state.status = "error";
+      state.lastError = "Connection closed unexpectedly";
+      await this.handleCrash(language);
+    };
+    transport.onerror = async (error2) => {
+      const state = this.backends.get(language);
+      if (!state || state.status === "stopped")
+        return;
+      console.error(`[BackendManager] ${language} backend transport error:`, error2);
+    };
+  }
+  async handleCrash(language) {
+    const state = this.backends.get(language);
+    if (!state)
+      return;
+    const now = Date.now();
+    if (now - state.lastCrashTime > 3600 * 1000) {
+      state.retryCount = 0;
+    }
+    state.retryCount++;
+    state.lastCrashTime = now;
+    const maxRetries = 5;
+    if (state.retryCount > maxRetries) {
+      console.error(`[BackendManager] ${language} crashed too many times (${state.retryCount}). Giving up.`);
+      state.status = "error";
+      state.lastError = `Crashed ${state.retryCount} times. Manual restart required.`;
+      return;
+    }
+    const backoffMs = Math.min(1000 * Math.pow(2, state.retryCount - 1), 30000);
+    console.error(`[BackendManager] Restarting ${language} in ${backoffMs}ms (Attempt ${state.retryCount}/${maxRetries})...`);
+    await new Promise((resolve2) => setTimeout(resolve2, backoffMs));
+    const currentState = this.backends.get(language);
+    if (!currentState || currentState.status === "stopped")
+      return;
+    try {
+      this.backends.delete(language);
+      const startPromise = this.startBackend(language);
+      this.startPromises.set(language, startPromise);
+      await startPromise;
+      this.startPromises.delete(language);
+      const newState = this.backends.get(language);
+      if (newState) {
+        newState.retryCount = state.retryCount;
+        newState.lastCrashTime = state.lastCrashTime;
+      }
+      console.error(`[BackendManager] ${language} recovered successfully.`);
+    } catch (error2) {
+      console.error(`[BackendManager] Failed to recover ${language}:`, error2);
+    }
+  }
   async startBackend(language) {
     const backendConfig = getBackendCommand(language, this.config);
     if (!backendConfig) {
@@ -20641,9 +20877,13 @@ class BackendManager {
       transport,
       tools: [],
       status: "starting",
-      restartCount: 0
+      restartCount: 0,
+      lastUsed: Date.now(),
+      retryCount: 0,
+      lastCrashTime: 0
     };
     this.backends.set(language, state);
+    this.monitorBackend(language, transport);
     try {
       await client.connect(transport);
       const serverInfo = client.getServerVersion();
@@ -20671,6 +20911,7 @@ class BackendManager {
       throw new Error(`${language} backend is not ready: ${state.lastError}`);
     }
     try {
+      state.lastUsed = Date.now();
       const result = await state.client.callTool({
         name: toolName,
         arguments: args
@@ -20686,6 +20927,7 @@ class BackendManager {
         if (!restarted || restarted.status !== "ready") {
           throw new Error(`${language} backend failed to restart`);
         }
+        restarted.lastUsed = Date.now();
         const result = await restarted.client.callTool({
           name: toolName,
           arguments: args
@@ -20702,13 +20944,7 @@ class BackendManager {
   }
   async getAllTools() {
     const result = new Map;
-    const languages = [];
-    if (this.config.python.enabled)
-      languages.push("python");
-    if (this.config.typescript.enabled)
-      languages.push("typescript");
-    if (this.config.vue.enabled)
-      languages.push("vue");
+    const languages = Object.keys(this.config.languages).filter((lang) => this.config.languages[lang].enabled);
     await Promise.all(languages.map(async (lang) => {
       try {
         const tools = await this.getTools(lang);
@@ -20720,6 +20956,20 @@ class BackendManager {
     }));
     return result;
   }
+  async shutdownBackend(language) {
+    const state = this.backends.get(language);
+    if (!state)
+      return;
+    try {
+      console.error(`[BackendManager] Shutting down ${language}...`);
+      await state.transport.close();
+      await state.client.close();
+    } catch (error2) {
+      console.error(`[BackendManager] Error closing ${language}:`, error2);
+    } finally {
+      this.backends.delete(language);
+    }
+  }
   getStatus() {
     const status = {};
     for (const [lang, state] of this.backends) {
@@ -20732,26 +20982,16 @@ class BackendManager {
         serverName: state.serverInfo?.name
       };
     }
-    if (this.config.python.enabled && !this.backends.has("python")) {
-      status["python"] = { status: "not_started", tools: 0, restartCount: 0 };
-    }
-    if (this.config.typescript.enabled && !this.backends.has("typescript")) {
-      status["typescript"] = { status: "not_started", tools: 0, restartCount: 0 };
-    }
-    if (this.config.vue.enabled && !this.backends.has("vue")) {
-      status["vue"] = { status: "not_started", tools: 0, restartCount: 0 };
+    for (const [lang, config2] of Object.entries(this.config.languages)) {
+      if (config2.enabled && !this.backends.has(lang)) {
+        status[lang] = { status: "not_started", tools: 0, restartCount: 0 };
+      }
     }
     return status;
   }
   getVersions() {
     const versions2 = [];
-    const languages = [];
-    if (this.config.python.enabled)
-      languages.push("python");
-    if (this.config.typescript.enabled)
-      languages.push("typescript");
-    if (this.config.vue.enabled)
-      languages.push("vue");
+    const languages = Object.keys(this.config.languages).filter((lang) => this.config.languages[lang].enabled);
     for (const lang of languages) {
       const backendConfig = getBackendCommand(lang, this.config);
       const state = this.backends.get(lang);
@@ -20787,6 +21027,10 @@ class BackendManager {
   }
   async shutdown() {
     console.error("[BackendManager] Shutting down all backends...");
+    if (this.idleCheckInterval) {
+      clearInterval(this.idleCheckInterval);
+      this.idleCheckInterval = null;
+    }
     const shutdownPromises = Array.from(this.backends.entries()).map(async ([lang, state]) => {
       try {
         console.error(`[BackendManager] Closing ${lang}...`);
@@ -20804,13 +21048,13 @@ class BackendManager {
 }
 
 // src/tools/meta.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var serverVersion = "0.1.0";
 try {
-  const packageJson = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
+  const packageJson = JSON.parse(readFileSync2(join2(__dirname2, "../../package.json"), "utf-8"));
   serverVersion = packageJson.version;
 } catch {}
 async function status(backendManager, config2) {
@@ -21525,6 +21769,46 @@ function registerPrompts(server) {
       }
     ]
   }));
+  server.registerPrompt("explore-project", {
+    description: "Analyze the current project structure and key files using semantic summaries",
+    args: {
+      path: exports_external.string().optional().describe("Project root path (optional, defaults to active workspace)")
+    }
+  }, async ({ path: path2 }) => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Please explore the project at '${path2 || "current workspace"}'.
+
+Recommended Workflow:
+1. List files to understand the directory structure (use 'ls' or 'glob').
+2. Identify key entry points (e.g., main.py, index.ts, App.vue, pyproject.toml, package.json).
+3. Use 'summarize_file' on these entry points to extract high-level symbols (classes/functions) without reading full content.
+4. Report back with a structural summary of the project.`
+      }
+    }]
+  }));
+  server.registerPrompt("debug-file", {
+    description: "Deeply analyze a file for errors using diagnostics and inlay hints",
+    args: {
+      file: exports_external.string().describe("Path to the file to debug")
+    }
+  }, async ({ file }) => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Please debug and analyze the file '${file}'.
+
+Recommended Workflow:
+1. Run 'diagnostics' on the file to identify syntax errors, type mismatches, or unused imports.
+2. Use 'read_file_with_hints' to read the content. This will reveal inferred types and parameter names, making it easier to spot logic errors.
+3. If errors are found, check specific locations with 'code_action' to see if auto-fixes (like 'Organize Imports') are available.
+4. Explain the findings and propose fixes.`
+      }
+    }]
+  }));
   server.registerPrompt("lsp-quick-start", {
     description: "Quick start guide - essential LSP workflow patterns"
   }, async () => ({
@@ -21537,10 +21821,14 @@ function registerPrompts(server) {
 
 ## Key Workflows
 
-### 1. Search → LSP Tools
-
-search() returns positions (file, line, column) that work directly with other LSP tools:
+### 1. Smart Exploration
+Instead of reading raw code, use:
+\`\`\`
+summarize_file(file) → Get outline of classes/functions
+read_file_with_hints(file) → Read code with type/param annotations
+\`\`\`
 
+### 2. Search → LSP Tools
 \`\`\`
 search("ClassName") → get positions
 hover(file, line, column) → get type info
@@ -21548,53 +21836,15 @@ definition(...) → jump to definition
 references(...) → find usages
 \`\`\`
 
-### 2. Learn API Before Using
-
-Before using unfamiliar methods/classes:
-
-\`\`\`
-hover(file, line, column) → get documentation
-signature_help(...) → get parameter details
-→ Then write correct code
-\`\`\`
-
-### 3. Always Verify with Diagnostics
-
-After any code changes:
-
+### 3. Debug & Fix
 \`\`\`
-Edit code
-diagnostics(path) → check for errors
-Fix issues
-Repeat until clean
-\`\`\`
-
-## Quick Reference
-
-\`\`\`
-# Navigation (use python/ or typescript/ prefix)
-hover(file, line, column)           → Get type info and docs
-definition(file, line, column)      → Jump to definition
-references(file, line, column)      → Find all usages
-
-# Analysis
-symbols(file)                       → List all symbols in file
-diagnostics(path)                   → Type errors and warnings
-search(pattern, path)               → Search code, returns LSP positions
-
-# Refactoring (Python only, modifies files)
-rename(file, line, column, new_name)              → Rename symbol
-move(file, line, column, destination)             → Move to another module
-change_signature(file, line, column, ...)         → Modify function params
+diagnostics(path) → Check for errors
+code_action(file, line, col) → Get quick fixes (e.g. Organize Imports)
+run_code_action(...) → Apply fix
 \`\`\`
 
 ## Tool Namespacing
-
-Tools are namespaced by language:
-- \`python/hover\`, \`python/definition\`, etc.
-- \`typescript/hover\`, \`typescript/definition\`, etc.
-
-Or use file extension auto-detection by providing a file path.
+Tools are unified! Just provide the file path, and the server auto-detects the language (Python/TS/Vue).
 `
         }
       }
@@ -21609,132 +21859,12 @@ var config2 = loadConfig();
 var backendManager = new BackendManager(config2);
 var startedBackends = new Set;
 var registeredTools = new Set;
+var activeWorkspacePath = null;
 var server = new McpServer({
   name: "lsp-mcp",
   version: packageJson.version
 });
 registerPrompts(server);
-function jsonSchemaToZod(schema) {
-  const result = {};
-  if (!schema || !schema.properties) {
-    return result;
-  }
-  const required2 = new Set(schema.required || []);
-  for (const [key, prop] of Object.entries(schema.properties)) {
-    let zodType = schemaToZod(prop);
-    if (prop.description) {
-      zodType = zodType.describe(prop.description);
-    }
-    if (prop.default !== undefined) {
-      zodType = zodType.default(prop.default);
-    }
-    if (!required2.has(key)) {
-      zodType = zodType.optional();
-    }
-    result[key] = zodType;
-  }
-  return result;
-}
-function schemaToZod(schema) {
-  if (!schema)
-    return exports_external.any();
-  if (schema.oneOf || schema.anyOf) {
-    const variants = schema.oneOf ?? schema.anyOf;
-    const mapped = variants.map((variant) => schemaToZod(variant));
-    if (mapped.length === 1)
-      return mapped[0];
-    if (mapped.length > 1)
-      return exports_external.union(mapped);
-    return exports_external.any();
-  }
-  if (schema.allOf) {
-    const variants = schema.allOf;
-    if (variants.length === 0)
-      return exports_external.any();
-    return variants.map((variant) => schemaToZod(variant)).reduce((acc, next) => exports_external.intersection(acc, next));
-  }
-  if (schema.enum && schema.type === "string") {
-    return exports_external.enum(schema.enum);
-  }
-  switch (schema.type) {
-    case "string": {
-      let zodType = exports_external.string();
-      if (schema.minLength !== undefined)
-        zodType = zodType.min(schema.minLength);
-      if (schema.maxLength !== undefined)
-        zodType = zodType.max(schema.maxLength);
-      if (schema.pattern) {
-        try {
-          zodType = zodType.regex(new RegExp(schema.pattern));
-        } catch {}
-      }
-      return zodType;
-    }
-    case "number":
-    case "integer": {
-      let zodType = exports_external.number();
-      if (schema.type === "integer") {
-        zodType = zodType.int();
-      }
-      if (schema.exclusiveMinimum !== undefined) {
-        zodType = zodType.gt(schema.exclusiveMinimum);
-      }
-      if (schema.minimum !== undefined) {
-        zodType = zodType.gte(schema.minimum);
-      }
-      if (schema.maximum !== undefined) {
-        zodType = zodType.lte(schema.maximum);
-      }
-      return zodType;
-    }
-    case "boolean":
-      return exports_external.boolean();
-    case "array":
-      return exports_external.array(schemaToZod(schema.items ?? {}));
-    case "object": {
-      if (schema.properties) {
-        const shape = {};
-        const required2 = new Set(schema.required || []);
-        for (const [key, prop] of Object.entries(schema.properties)) {
-          let propSchema = schemaToZod(prop);
-          if (prop.description) {
-            propSchema = propSchema.describe(prop.description);
-          }
-          if (prop.default !== undefined) {
-            propSchema = propSchema.default(prop.default);
-          }
-          if (!required2.has(key)) {
-            propSchema = propSchema.optional();
-          }
-          shape[key] = propSchema;
-        }
-        return exports_external.object(shape).passthrough();
-      }
-      return exports_external.record(exports_external.any());
-    }
-    default:
-      return exports_external.any();
-  }
-}
-function registerBackendTools(language, tools) {
-  let count = 0;
-  for (const tool of tools) {
-    const namespacedName = `${language}_${tool.name}`;
-    if (registeredTools.has(namespacedName)) {
-      continue;
-    }
-    const zodSchema = jsonSchemaToZod(tool.inputSchema);
-    server.registerTool(namespacedName, {
-      description: tool.description || `${language} ${tool.name} tool`,
-      inputSchema: zodSchema
-    }, async (args) => backendManager.callTool(language, tool.name, args));
-    console.error(`[lsp-mcp] Registered ${namespacedName}`);
-    registeredTools.add(namespacedName);
-    count++;
-  }
-  server.sendToolListChanged();
-  return count;
-}
 async function startAndRegisterBackend(language) {
   if (startedBackends.has(language)) {
     const status2 = backendManager.getStatus()[language];
@@ -21743,11 +21873,10 @@ async function startAndRegisterBackend(language) {
   }
   console.error(`[lsp-mcp] Starting ${language} backend...`);
   try {
-    const tools = await backendManager.getTools(language);
-    const count = registerBackendTools(language, tools);
+    await backendManager.getBackend(language);
     startedBackends.add(language);
-    console.error(`[lsp-mcp] ${language}: ${count} new tools registered`);
-    return count;
+    console.error(`[lsp-mcp] ${language} backend started`);
+    return 0;
   } catch (error2) {
     console.error(`[lsp-mcp] Failed to start ${language} backend:`, error2);
     throw error2;
@@ -21756,14 +21885,18 @@ async function startAndRegisterBackend(language) {
 async function updateAndRestartBackend(language) {
   console.error(`[lsp-mcp] Updating ${language} backend...`);
   const result = await backendManager.restartBackend(language);
-  const tools = await backendManager.getTools(language);
-  const newlyRegistered = registerBackendTools(language, tools);
   startedBackends.add(language);
-  console.error(`[lsp-mcp] ${language} backend updated (${newlyRegistered} new tools registered)`);
   return result;
 }
 server.registerTool("status", { description: "Get status of all LSP backends and server configuration" }, async () => status(backendManager, config2));
 server.registerTool("check_versions", { description: "Check versions of all backends and server. Shows installed versions and how to check for updates." }, async () => checkVersions(backendManager, config2));
+server.registerTool("reload_config", { description: "Reload configuration from environment variables. Useful for changing settings without restarting the server." }, async () => {
+  const newConfig = loadConfig();
+  backendManager.updateConfig(newConfig);
+  return {
+    content: [{ type: "text", text: JSON.stringify({ success: true, message: "Configuration reloaded", config: newConfig }) }]
+  };
+});
 server.registerTool("switch_python_backend", {
   description: "Switch the Python backend provider (requires restart)",
   inputSchema: switchPythonBackendSchema
@@ -21779,62 +21912,280 @@ server.registerTool("update_backend", {
   description: "Update a backend to the latest version. This will restart the backend with the newest version available.",
   inputSchema: updateBackendSchema
 }, async ({ language }) => updateBackend(language, backendManager, config2, updateAndRestartBackend));
-var KNOWN_TOOLS = {
+var UNIFIED_TOOLS = [
+  { name: "hover", description: "Get type information and documentation at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
+  { name: "definition", description: "Go to definition of a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
+  { name: "references", description: "Find all references to a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
+  { name: "completions", description: "Get code completion suggestions at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), limit: exports_external.number().int().positive().default(20).optional() } },
+  { name: "signature_help", description: "Get function signature help at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
+  { name: "symbols", description: "Extract symbols (classes, functions, methods, variables) from a file", schema: { file: exports_external.string(), query: exports_external.string().optional() } },
+  { name: "diagnostics", description: "Get type errors and warnings for a file or directory", schema: { path: exports_external.string() } },
+  { name: "rename", description: "Preview renaming a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), newName: exports_external.string() } },
+  { name: "update_document", description: "Update file content for incremental analysis without writing to disk", schema: { file: exports_external.string(), content: exports_external.string() } },
+  { name: "search", description: "Search for a pattern in files using ripgrep. Uses active workspace if path is omitted.", schema: { pattern: exports_external.string(), path: exports_external.string().optional(), glob: exports_external.string().optional() } },
+  { name: "summarize_file", description: "Get a high-level outline of a file (classes, functions, methods) to understand its structure without reading the full content.", schema: { file: exports_external.string() } },
+  { name: "read_file_with_hints", description: "Read file content with inlay hints (type annotations, parameter names) inserted as comments. Useful for understanding complex code.", schema: { file: exports_external.string() } },
+  { name: "code_action", description: "Get available code actions (refactors and quick fixes) at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
+  { name: "run_code_action", description: "Apply a code action (refactor or quick fix)", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), kind: exports_external.enum(["refactor", "quickfix"]), name: exports_external.string(), actionName: exports_external.string().optional(), preview: exports_external.boolean().default(false).optional() } }
+];
+function applyInlayHints(content, hints, language) {
+  const lines = content.split(`
+`);
+  const resultLines = [...lines];
+  const normalizedHints = hints.map((h) => {
+    let line, char;
+    let label = "";
+    if (typeof h.label === "string")
+      label = h.label;
+    else if (Array.isArray(h.label))
+      label = h.label.map((p) => p.value).join("");
+    if (language === "typescript") {
+      line = h.position.line - 1;
+      char = h.position.column - 1;
+    } else {
+      line = h.position.line;
+      char = h.position.character;
+    }
+    return { line, char, label, kind: h.kind, paddingLeft: h.paddingLeft, paddingRight: h.paddingRight };
+  }).sort((a, b) => {
+    if (a.line !== b.line)
+      return b.line - a.line;
+    return b.char - a.char;
+  });
+  for (const hint of normalizedHints) {
+    if (hint.line < 0 || hint.line >= resultLines.length)
+      continue;
+    const lineContent = resultLines[hint.line];
+    if (hint.char < 0)
+      continue;
+    const prefix = lineContent.substring(0, hint.char);
+    const suffix = lineContent.substring(hint.char);
+    let hintText = hint.label;
+    let formatted = "";
+    if (hint.kind === 1) {
+      formatted = `/*: ${hintText.trim()}*/`;
+      if (!hint.paddingLeft && prefix.length > 0 && !prefix.endsWith(" "))
+        formatted = " " + formatted;
+    } else if (hint.kind === 2) {
+      formatted = `/*${hintText.trim()}:*/`;
+      if (!hint.paddingRight)
+        formatted = formatted + " ";
+    } else {
+      formatted = `/*${hintText}*/`;
+    }
+    resultLines[hint.line] = prefix + formatted + suffix;
+  }
+  return resultLines.join(`
+`);
+}
+function formatSymbolsToMarkdown(symbols, depth = 0) {
+  let output = "";
+  const indent = "  ".repeat(depth);
+  for (const symbol of symbols) {
+    const kind = symbol.kind ? `[${symbol.kind.toLowerCase()}]` : "";
+    const line = symbol.range?.start?.line ?? symbol.line ?? "?";
+    output += `${indent}- ${kind} ${symbol.name} (line ${line})
+`;
+    if (symbol.children && symbol.children.length > 0) {
+      output += formatSymbolsToMarkdown(symbol.children, depth + 1);
+    }
+  }
+  return output;
+}
+var LANGUAGE_SPECIFIC_TOOLS = {
   python: [
-    { name: "hover", description: "Get documentation for the symbol at the given position", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int() } },
-    { name: "definition", description: "Get the definition location for the symbol at the given position", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int() } },
-    { name: "references", description: "Find all references to the symbol at the given position", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int() } },
-    { name: "completions", description: "Get code completion suggestions at the given position", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int() } },
-    { name: "symbols", description: "Get symbols from a Python file", schema: { file: exports_external.string(), query: exports_external.string().optional() } },
-    { name: "diagnostics", description: "Get type errors and warnings for a Python file or directory", schema: { path: exports_external.string() } },
-    { name: "rename", description: "Rename the symbol at the given position", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int(), new_name: exports_external.string() } },
-    { name: "signature_help", description: "Get function signature information at the given position", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int() } },
-    { name: "update_document", description: "Update file content for incremental analysis without writing to disk", schema: { file: exports_external.string(), content: exports_external.string() } },
-    { name: "search", description: "Search for a regex pattern in files using ripgrep", schema: { pattern: exports_external.string(), path: exports_external.string().optional(), glob: exports_external.string().optional() } },
-    { name: "status", description: "Get the status of the Python MCP server", schema: {} }
+    { name: "move", description: "Move a function or class to another module", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int(), destination: exports_external.string() } },
+    { name: "change_signature", description: "Change the signature of a function", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int(), new_params: exports_external.array(exports_external.string()).optional() } },
+    { name: "function_signature", description: "Get current signature of a function", schema: { file: exports_external.string(), line: exports_external.number().int(), column: exports_external.number().int() } }
   ],
   typescript: [
-    { name: "hover", description: "Get type information and documentation at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "definition", description: "Go to definition of a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "references", description: "Find all references to a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "completions", description: "Get code completion suggestions at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), limit: exports_external.number().int().positive().default(20).optional() } },
-    { name: "signature_help", description: "Get function signature help at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "symbols", description: "Extract symbols (classes, functions, methods, variables) from a file", schema: { file: exports_external.string(), query: exports_external.string().optional() } },
-    { name: "diagnostics", description: "Get type errors and warnings for a TypeScript/JavaScript file", schema: { path: exports_external.string() } },
-    { name: "rename", description: "Preview renaming a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), newName: exports_external.string() } },
-    { name: "update_document", description: "Update file content for incremental analysis without writing to disk", schema: { file: exports_external.string(), content: exports_external.string() } },
-    { name: "status", description: "Check TypeScript environment status for a project", schema: { file: exports_external.string() } },
-    { name: "search", description: "Search for a pattern in files using ripgrep", schema: { pattern: exports_external.string(), path: exports_external.string().optional(), glob: exports_external.string().optional() } },
     { name: "move", description: "Move a function, class, or variable to a new file", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), destination: exports_external.string().optional(), preview: exports_external.boolean().default(false).optional() } },
-    { name: "function_signature", description: "Get the current signature of a function at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "available_refactors", description: "Get available refactoring actions at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "apply_refactor", description: "Apply a specific refactoring action at a position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), refactorName: exports_external.string(), actionName: exports_external.string(), preview: exports_external.boolean().default(false).optional() } }
+    { name: "function_signature", description: "Get current signature of a function", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } }
   ],
-  vue: [
-    { name: "hover", description: "Get type information and documentation at a specific position in a Vue SFC file", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "definition", description: "Go to definition of a symbol at a specific position in a Vue SFC file", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "references", description: "Find all references to a symbol at a specific position in a Vue SFC file", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "completions", description: "Get code completion suggestions at a specific position in a Vue SFC file", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), limit: exports_external.number().int().positive().default(20).optional() } },
-    { name: "signature_help", description: "Get function signature help at a specific position in a Vue SFC file", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-    { name: "diagnostics", description: "Get type errors and warnings for Vue SFC files", schema: { path: exports_external.string() } },
-    { name: "update_document", description: "Update Vue file content for incremental analysis without writing to disk", schema: { file: exports_external.string(), content: exports_external.string() } },
-    { name: "symbols", description: "Extract symbols (variables, functions, components) from a Vue SFC file", schema: { file: exports_external.string(), query: exports_external.string().optional() } },
-    { name: "rename", description: "Preview renaming a symbol at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), newName: exports_external.string() } },
-    { name: "search", description: "Search for a pattern in Vue files using ripgrep", schema: { pattern: exports_external.string(), path: exports_external.string().optional(), glob: exports_external.string().optional() } },
-    { name: "status", description: "Check Vue Language Server status for a project", schema: { file: exports_external.string() } }
-  ]
+  vue: []
 };
-function preRegisterKnownTools() {
-  const languages = [];
-  if (config2.python.enabled)
-    languages.push("python");
-  if (config2.typescript.enabled)
-    languages.push("typescript");
-  if (config2.vue.enabled)
-    languages.push("vue");
-  let totalCount = 0;
-  for (const language of languages) {
-    const tools = KNOWN_TOOLS[language];
+server.registerTool("switch_workspace", {
+  description: "Switch the active workspace for ALL backends simultaneously. This clears caches and refocuses code intelligence on the new project root.",
+  inputSchema: {
+    path: exports_external.string().describe("Absolute path to the new project root directory")
+  }
+}, async ({ path: workspacePath }) => {
+  activeWorkspacePath = workspacePath;
+  const results = {};
+  const languages = Object.keys(config2.languages).filter((lang) => config2.languages[lang].enabled);
+  await Promise.all(languages.map(async (lang) => {
+    try {
+      if (startedBackends.has(lang)) {
+        const result = await backendManager.callTool(lang, "switch_workspace", { path: workspacePath });
+        results[lang] = JSON.parse(result.content[0].text);
+      } else {
+        results[lang] = { status: "not_started", message: "Workspace will be set when backend starts" };
+      }
+    } catch (error2) {
+      results[lang] = { error: String(error2) };
+    }
+  }));
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          workspace: workspacePath,
+          results
+        }, null, 2)
+      }
+    ]
+  };
+});
+function preRegisterTools() {
+  for (const tool of UNIFIED_TOOLS) {
+    server.registerTool(tool.name, {
+      description: `${tool.description} (unified tool, routes automatically by file extension)`,
+      inputSchema: tool.schema
+    }, async (args) => {
+      const filePath = args.file || args.path;
+      if (tool.name === "search" && !filePath) {
+        const languages = Object.keys(config2.languages).filter((lang) => config2.languages[lang].enabled);
+        const results = [];
+        for (const lang of languages) {
+          if (startedBackends.has(lang)) {
+            try {
+              const res = await backendManager.callTool(lang, "search", args);
+              results.push(JSON.parse(res.content[0].text));
+            } catch (e) {}
+          }
+        }
+        if (results.length === 0) {
+          return { content: [{ type: "text", text: JSON.stringify({ matches: [], count: 0, message: "No active backends to search in. Please specify a file path to auto-start a backend." }) }] };
+        }
+        const allMatches = results.flatMap((r) => r.matches || []);
+        return { content: [{ type: "text", text: JSON.stringify({ matches: allMatches, count: allMatches.length }) }] };
+      }
+      if (!filePath) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Missing 'file' or 'path' argument required for unified routing" }) }]
+        };
+      }
+      const language = inferLanguageFromPath(filePath, config2);
+      if (!language) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "Unsupported File Type",
+                message: `Cannot determine language for file '${filePath}'. Check configuration for supported extensions.`
+              })
+            }
+          ]
+        };
+      }
+      if (!startedBackends.has(language)) {
+        console.error(`[lsp-mcp] Auto-starting ${language} backend for unified ${tool.name}...`);
+        try {
+          await backendManager.getBackend(language);
+          startedBackends.add(language);
+          if (activeWorkspacePath) {
+            console.error(`[lsp-mcp] Syncing active workspace to ${language}: ${activeWorkspacePath}`);
+            try {
+              await backendManager.callTool(language, "switch_workspace", { path: activeWorkspacePath });
+            } catch (syncError) {
+              console.error(`[lsp-mcp] Failed to sync workspace to ${language}:`, syncError);
+            }
+          }
+        } catch (error2) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Failed to start ${language} backend: ${error2}` }) }]
+          };
+        }
+      }
+      if (tool.name !== "summarize_file" && tool.name !== "read_file_with_hints") {
+        const availableTools = await backendManager.getTools(language);
+        const supportsTool = availableTools.some((t) => t.name === tool.name);
+        if (!supportsTool) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "Not Implemented",
+                  message: `The '${language}' backend does not support the '${tool.name}' feature yet.`,
+                  available_tools: availableTools.map((t) => t.name)
+                })
+              }
+            ]
+          };
+        }
+      }
+      if (tool.name === "summarize_file") {
+        try {
+          const result = await backendManager.callTool(language, "symbols", args);
+          const parsed = JSON.parse(result.content[0].text);
+          if (parsed.error) {
+            return { content: [{ type: "text", text: JSON.stringify(parsed) }] };
+          }
+          const symbols = parsed.symbols || [];
+          const summary = formatSymbolsToMarkdown(symbols);
+          return {
+            content: [{
+              type: "text",
+              text: `File Summary for ${filePath}:
+
+${summary || "(No symbols found)"}`
+            }]
+          };
+        } catch (error2) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Failed to summarize file: ${error2}` }) }]
+          };
+        }
+      }
+      if (tool.name === "read_file_with_hints") {
+        try {
+          let absPath = filePath;
+          if (!path2.isAbsolute(filePath) && activeWorkspacePath) {
+            absPath = path2.join(activeWorkspacePath, filePath);
+          }
+          if (!fs2.existsSync(absPath)) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `File not found: ${absPath}` }) }] };
+          }
+          const content = fs2.readFileSync(absPath, "utf-8");
+          const result = await backendManager.callTool(language, "inlay_hints", args);
+          const parsed = JSON.parse(result.content[0].text);
+          if (parsed.error) {
+            return { content: [{ type: "text", text: JSON.stringify(parsed) }] };
+          }
+          const hints = parsed.hints || [];
+          const contentWithHints = applyInlayHints(content, hints, language);
+          return {
+            content: [{
+              type: "text",
+              text: contentWithHints
+            }]
+          };
+        } catch (error2) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Failed to read file with hints: ${error2}` }) }]
+          };
+        }
+      }
+      const backendArgs = { ...args };
+      if (tool.name === "rename") {
+        if (language === "python") {
+          backendArgs.new_name = args.newName || args.new_name;
+        } else {
+          backendArgs.newName = args.newName || args.new_name;
+        }
+      }
+      return backendManager.callTool(language, tool.name, backendArgs);
+    });
+    registeredTools.add(tool.name);
+  }
+  for (const [language, langConfig] of Object.entries(config2.languages)) {
+    if (!langConfig.enabled)
+      continue;
+    const tools = LANGUAGE_SPECIFIC_TOOLS[language];
     if (!tools)
       continue;
     for (const tool of tools) {
@@ -21844,27 +22195,25 @@ function preRegisterKnownTools() {
         inputSchema: tool.schema
       }, async (args) => {
         if (!startedBackends.has(language)) {
-          console.error(`[lsp-mcp] Auto-starting ${language} backend for ${tool.name}...`);
-          try {
-            await backendManager.getBackend(language);
-            startedBackends.add(language);
-            console.error(`[lsp-mcp] ${language} backend started`);
-          } catch (error2) {
-            return {
-              content: [{ type: "text", text: JSON.stringify({ error: `Failed to start ${language} backend: ${error2}` }) }]
-            };
+          await backendManager.getBackend(language);
+          startedBackends.add(language);
+          if (activeWorkspacePath) {
+            console.error(`[lsp-mcp] Syncing active workspace to ${language}: ${activeWorkspacePath}`);
+            try {
+              await backendManager.callTool(language, "switch_workspace", { path: activeWorkspacePath });
+            } catch (syncError) {
+              console.error(`[lsp-mcp] Failed to sync workspace to ${language}:`, syncError);
+            }
           }
         }
         return backendManager.callTool(language, tool.name, args);
       });
       registeredTools.add(namespacedName);
-      totalCount++;
     }
-    console.error(`[lsp-mcp] Pre-registered ${tools.length} ${language} tools`);
   }
-  console.error(`[lsp-mcp] Total: ${totalCount} tools pre-registered (backends start on first use)`);
+  console.error(`[lsp-mcp] Unified and language-specific tools registered`);
 }
-preRegisterKnownTools();
+preRegisterTools();
 async function gracefulShutdown(signal) {
   console.error(`
 [lsp-mcp] Received ${signal}, shutting down gracefully...`);
@@ -21883,22 +22232,16 @@ process.on("SIGINT", () => gracefulShutdown("SIGINT"));
 async function main() {
   console.error("LSP MCP Server - Unified Multi-Language Code Intelligence");
   console.error(`  Version: ${packageJson.version}`);
-  console.error("  Python:", config2.python.enabled ? `enabled (${config2.python.provider})` : "disabled");
-  console.error("  TypeScript:", config2.typescript.enabled ? "enabled" : "disabled");
-  console.error("  Vue:", config2.vue.enabled ? "enabled" : "disabled");
+  console.error("  Python:", config2.languages.python?.enabled ? `enabled` : "disabled");
+  console.error("  TypeScript:", config2.languages.typescript?.enabled ? "enabled" : "disabled");
+  console.error("  Vue:", config2.languages.vue?.enabled ? "enabled" : "disabled");
   console.error("");
   const transport = new StdioServerTransport;
   await server.connect(transport);
   if (config2.eagerStart) {
     console.error("Eager start enabled - starting all backends now...");
-    const languages = [];
-    if (config2.python.enabled)
-      languages.push("python");
-    if (config2.typescript.enabled)
-      languages.push("typescript");
-    if (config2.vue.enabled)
-      languages.push("vue");
-    await Promise.allSettled(languages.map(async (lang) => {
+    const enabledLanguages = Object.keys(config2.languages).filter((l) => config2.languages[l].enabled);
+    await Promise.allSettled(enabledLanguages.map(async (lang) => {
       try {
         await backendManager.getBackend(lang);
         startedBackends.add(lang);
@@ -21918,4 +22261,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=55BC37C22EC14E0664756E2164756E21
+//# debugId=52D8C4766CA64C6B64756E2164756E21