@treedy/lsp-mcp 0.1.8 → 0.1.9

package/dist/index.js

@@ -19837,32 +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
 import * as path from "path";
 import * as fs from "fs";
+import * as os from "os";
 import { fileURLToPath } from "url";
-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 {
+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];
@@ -19873,6 +19957,15 @@ 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));
@@ -19885,11 +19978,21 @@ function resolveBundledBackend(name) {
   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}`);
@@ -19921,8 +20024,6 @@ 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}`);
@@ -19938,8 +20039,6 @@ function getBackendCommand(language, config2) {
       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}`);
@@ -20646,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);
@@ -20667,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) {
@@ -20691,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();
@@ -20721,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
@@ -20736,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
@@ -20752,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);
@@ -20770,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) {
@@ -20782,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);
@@ -20837,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}...`);
@@ -20854,13 +21048,13 @@ class BackendManager {
 }
 
 // src/tools/meta.ts
-import { readFileSync } from "fs";
+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(join2(__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) {
@@ -21575,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 () => ({
@@ -21587,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
@@ -21598,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:
-
-\`\`\`
-Edit code
-diagnostics(path) → check for errors
-Fix issues
-Repeat until clean
-\`\`\`
-
-## Quick Reference
-
+### 3. Debug & Fix
 \`\`\`
-# 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).
 `
         }
       }
@@ -21659,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];
@@ -21793,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;
@@ -21806,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
@@ -21829,53 +21912,97 @@ 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: "switch_workspace", description: "Switch the active workspace to a new project directory", schema: { path: exports_external.string() } },
-    { 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: "switch_workspace", description: "Switch the active workspace to a new project directory", schema: { path: exports_external.string() } },
-    { 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: "switch_workspace", description: "Switch the active workspace to a new project directory", schema: { path: exports_external.string() } },
-    { 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: []
 };
 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.",
@@ -21883,14 +22010,9 @@ server.registerTool("switch_workspace", {
     path: exports_external.string().describe("Absolute path to the new project root directory")
   }
 }, async ({ path: workspacePath }) => {
+  activeWorkspacePath = workspacePath;
   const results = {};
-  const languages = [];
-  if (config2.python.enabled)
-    languages.push("python");
-  if (config2.typescript.enabled)
-    languages.push("typescript");
-  if (config2.vue.enabled)
-    languages.push("vue");
+  const languages = Object.keys(config2.languages).filter((lang) => config2.languages[lang].enabled);
   await Promise.all(languages.map(async (lang) => {
     try {
       if (startedBackends.has(lang)) {
@@ -21904,27 +22026,166 @@ server.registerTool("switch_workspace", {
     }
   }));
   return {
-    content: [{
-      type: "text",
-      text: JSON.stringify({
-        success: true,
-        workspace: workspacePath,
-        results
-      }, null, 2)
-    }]
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          workspace: workspacePath,
+          results
+        }, null, 2)
+      }
+    ]
   };
 });
-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];
+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) {
@@ -21934,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...`);
@@ -21973,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);
@@ -22008,4 +22261,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=B173E4D0EEF312F264756E2164756E21
+//# debugId=52D8C4766CA64C6B64756E2164756E21