@treedy/lsp-mcp 0.1.2 → 0.1.4

package/dist/index.js

@@ -19843,6 +19843,7 @@ 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);
   return {
     python: {
@@ -19852,6 +19853,9 @@ function loadConfig() {
     typescript: {
       enabled: typescriptEnabled
     },
+    vue: {
+      enabled: vueEnabled
+    },
     autoUpdate
   };
 }
@@ -19890,6 +19894,14 @@ function getBackendCommand(language, config2) {
       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;
+    return {
+      enabled: true,
+      command: "npx",
+      args: autoUpdate ? ["--yes", "@treedy/vue-lsp-mcp@latest"] : ["@treedy/vue-lsp-mcp@latest"]
+    };
   }
   return null;
 }
@@ -20673,6 +20685,8 @@ class BackendManager {
       languages.push("python");
     if (this.config.typescript.enabled)
       languages.push("typescript");
+    if (this.config.vue.enabled)
+      languages.push("vue");
     await Promise.all(languages.map(async (lang) => {
       try {
         const tools = await this.getTools(lang);
@@ -20702,6 +20716,9 @@ class BackendManager {
     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 };
+    }
     return status;
   }
   getVersions() {
@@ -20711,6 +20728,8 @@ class BackendManager {
       languages.push("python");
     if (this.config.typescript.enabled)
       languages.push("typescript");
+    if (this.config.vue.enabled)
+      languages.push("vue");
     for (const lang of languages) {
       const backendConfig = getBackendCommand(lang, this.config);
       const state = this.backends.get(lang);
@@ -20724,6 +20743,24 @@ class BackendManager {
     }
     return versions2;
   }
+  async restartBackend(language) {
+    const existing = this.backends.get(language);
+    const oldVersion = existing?.serverInfo?.version ?? null;
+    if (existing) {
+      console.error(`[BackendManager] Stopping ${language} for update...`);
+      try {
+        await existing.transport.close();
+        await existing.client.close();
+      } catch (error2) {
+        console.error(`[BackendManager] Error closing ${language}:`, error2);
+      }
+      this.backends.delete(language);
+    }
+    console.error(`[BackendManager] Starting fresh ${language} backend...`);
+    const state = await this.startBackend(language);
+    const newVersion = state.serverInfo?.version ?? null;
+    return { oldVersion, newVersion };
+  }
   async shutdown() {
     console.error("[BackendManager] Shutting down all backends...");
     const shutdownPromises = Array.from(this.backends.entries()).map(async ([lang, state]) => {
@@ -20742,84 +20779,6 @@ class BackendManager {
   }
 }
 
-// src/backends/python.ts
-var pythonPositionSchema = {
-  file: exports_external.string().describe("Absolute path to the Python file"),
-  line: exports_external.number().int().positive().describe("Line number (1-based)"),
-  column: exports_external.number().int().positive().describe("Column number (1-based)")
-};
-var pythonToolDescriptions = {
-  hover: "Get type information and documentation at a specific position in a Python file",
-  definition: "Go to definition of a symbol at a specific position in a Python file",
-  references: "Find all references to a symbol at a specific position in a Python file",
-  completions: "Get code completion suggestions at a specific position in a Python file",
-  diagnostics: "Get type errors and warnings for a Python file or directory",
-  symbols: "Extract symbols (classes, functions, methods, variables) from a Python file",
-  rename: "Rename a symbol and update all references in Python files",
-  search: "Search for a regex pattern in Python files",
-  signature_help: "Get function signature help at a specific position in a Python file",
-  update_document: "Update file content for incremental analysis in Python",
-  status: "Check Python/Pyright environment status",
-  move: "Move a function or class to another Python module",
-  change_signature: "Change the signature of a Python function",
-  function_signature: "Get the current signature of a Python function",
-  set_backend: "Set the backend (rope/pyright) for Python code analysis",
-  set_python_path: "Set the Python interpreter path for code analysis"
-};
-
-// src/backends/typescript.ts
-var typescriptPositionSchema = {
-  file: exports_external.string().describe("Absolute path to the TypeScript/JavaScript file"),
-  line: exports_external.number().int().positive().describe("Line number (1-based)"),
-  column: exports_external.number().int().positive().describe("Column number (1-based)")
-};
-var typescriptToolDescriptions = {
-  hover: "Get type information and documentation at a specific position in a TypeScript/JavaScript file",
-  definition: "Go to definition of a symbol at a specific position",
-  references: "Find all references to a symbol at a specific position",
-  completions: "Get code completion suggestions at a specific position",
-  diagnostics: "Get type errors and warnings for a TypeScript/JavaScript file",
-  symbols: "Extract symbols (classes, functions, methods, variables) from a file",
-  rename: "Preview renaming a symbol (shows all locations that would be renamed)",
-  search: "Search for a regex pattern in TypeScript/JavaScript files",
-  signature_help: "Get function signature help at a specific position",
-  update_document: "Update file content for incremental analysis",
-  status: "Check TypeScript environment status for a project"
-};
-
-// src/tools/schemas.ts
-var positionArgs = {
-  file: exports_external.string().describe("Absolute path to the file"),
-  line: exports_external.number().int().positive().describe("Line number (1-based)"),
-  column: exports_external.number().int().positive().describe("Column number (1-based)")
-};
-var searchArgs = {
-  pattern: exports_external.string().describe("The regex pattern to search for"),
-  path: exports_external.string().optional().describe("Directory or file to search in"),
-  glob: exports_external.string().optional().describe("Glob pattern to filter files"),
-  caseSensitive: exports_external.boolean().default(true).describe("Whether the search is case sensitive"),
-  maxResults: exports_external.number().int().positive().default(50).describe("Maximum number of results")
-};
-var diagnosticsArgs = {
-  path: exports_external.string().describe("Path to a file or directory to check")
-};
-var renameArgs = {
-  ...positionArgs,
-  newName: exports_external.string().describe("New name for the symbol")
-};
-var symbolsArgs = {
-  file: exports_external.string().describe("Absolute path to the file"),
-  query: exports_external.string().optional().describe("Optional filter query for symbol names")
-};
-var updateDocumentArgs = {
-  file: exports_external.string().describe("Absolute path to the file"),
-  content: exports_external.string().describe("New content for the file")
-};
-var completionsArgs = {
-  ...positionArgs,
-  limit: exports_external.number().int().positive().default(20).describe("Maximum number of completions to return")
-};
-
 // src/tools/meta.ts
 import { readFileSync } from "fs";
 import { dirname, join } from "path";
@@ -20845,6 +20804,9 @@ async function status(backendManager, config2) {
       typescript: {
         enabled: config2.typescript.enabled
       },
+      vue: {
+        enabled: config2.vue.enabled
+      },
       autoUpdate: config2.autoUpdate
     },
     backends: backendStatus,
@@ -20855,8 +20817,9 @@ async function status(backendManager, config2) {
       status: v.status
     })),
     usage: {
-      namespaced: "Use python/hover or typescript/hover to specify language",
-      auto_infer: "Or provide a file path and language will be inferred from extension"
+      list: "Use list_backends to see available backends",
+      start: "Use start_backend to install and start a backend",
+      tools: "Once started, tools are available as python_hover, typescript_definition, etc."
     }
   };
   return {
@@ -20901,6 +20864,13 @@ async function checkVersions(backendManager, config2) {
             registry: "npm",
             command: "npx --yes @treedy/typescript-lsp-mcp@latest"
           }
+        },
+        vue: {
+          "vue-lsp-mcp": {
+            registry: "npm",
+            command: "npx --yes @treedy/vue-lsp-mcp@latest",
+            description: "Vue SFC support via Volar"
+          }
         }
       },
       howToUpdate: config2.autoUpdate ? "Restart the server to fetch latest backend versions automatically." : "Set LSP_MCP_AUTO_UPDATE=true and restart, or manually update with commands above."
@@ -20924,6 +20894,193 @@ function switchPythonBackend(provider) {
     content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
   };
 }
+async function listBackends(backendManager, config2) {
+  const backendStatus = backendManager.getStatus();
+  const backends = [
+    {
+      name: "python",
+      enabled: config2.python.enabled,
+      provider: config2.python.provider,
+      status: backendStatus.python?.status || "not_started",
+      tools: backendStatus.python?.tools || 0,
+      description: "Python code intelligence (hover, definition, references, refactoring)",
+      startCommand: "Use start_backend tool with language='python'"
+    },
+    {
+      name: "typescript",
+      enabled: config2.typescript.enabled,
+      status: backendStatus.typescript?.status || "not_started",
+      tools: backendStatus.typescript?.tools || 0,
+      description: "TypeScript/JavaScript code intelligence",
+      startCommand: "Use start_backend tool with language='typescript'"
+    },
+    {
+      name: "vue",
+      enabled: config2.vue.enabled,
+      status: backendStatus.vue?.status || "not_started",
+      tools: backendStatus.vue?.tools || 0,
+      description: "Vue Single File Component (.vue) code intelligence via Volar",
+      startCommand: "Use start_backend tool with language='vue'"
+    }
+  ];
+  const result = {
+    backends,
+    usage: {
+      start: "Call start_backend with language='python', 'typescript', or 'vue' to install and start a backend",
+      tools: "Once started, backend tools will be available as {language}_{tool} (e.g., python_hover, vue_hover)"
+    }
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+var startBackendSchema = {
+  language: exports_external.enum(["python", "typescript", "vue"]).describe("The backend to start")
+};
+async function startBackend(language, backendManager, config2, registerToolsCallback) {
+  if (language === "python" && !config2.python.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "Python backend is disabled",
+          hint: "Set LSP_MCP_PYTHON_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  if (language === "typescript" && !config2.typescript.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "TypeScript backend is disabled",
+          hint: "Set LSP_MCP_TYPESCRIPT_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  if (language === "vue" && !config2.vue.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "Vue backend is disabled",
+          hint: "Set LSP_MCP_VUE_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  try {
+    const toolCount = await registerToolsCallback(language);
+    const backendStatus = backendManager.getStatus();
+    const status2 = backendStatus[language];
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          language,
+          status: status2?.status,
+          serverName: status2?.serverName,
+          version: status2?.version,
+          toolsRegistered: toolCount,
+          message: `${language} backend started successfully. ${toolCount} tools are now available.`,
+          usage: `Tools are available as ${language}_hover, ${language}_definition, etc.`
+        }, null, 2)
+      }]
+    };
+  } catch (error2) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          language,
+          error: String(error2),
+          hint: "Check if the backend package is available and network connection is working"
+        }, null, 2)
+      }]
+    };
+  }
+}
+var updateBackendSchema = {
+  language: exports_external.enum(["python", "typescript", "vue"]).describe("The backend to update")
+};
+async function updateBackend(language, backendManager, config2, updateCallback) {
+  if (language === "python" && !config2.python.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "Python backend is disabled",
+          hint: "Set LSP_MCP_PYTHON_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  if (language === "typescript" && !config2.typescript.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "TypeScript backend is disabled",
+          hint: "Set LSP_MCP_TYPESCRIPT_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  if (language === "vue" && !config2.vue.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "Vue backend is disabled",
+          hint: "Set LSP_MCP_VUE_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  try {
+    const { oldVersion, newVersion } = await updateCallback(language);
+    const backendStatus = backendManager.getStatus();
+    const status2 = backendStatus[language];
+    const updated = oldVersion !== newVersion;
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          language,
+          updated,
+          oldVersion,
+          newVersion,
+          serverName: status2?.serverName,
+          tools: status2?.tools,
+          message: updated ? `${language} backend updated from ${oldVersion} to ${newVersion}.` : `${language} backend is already at the latest version (${newVersion}).`
+        }, null, 2)
+      }]
+    };
+  } catch (error2) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          language,
+          error: String(error2),
+          hint: "Check network connection and try again"
+        }, null, 2)
+      }]
+    };
+  }
+}
 
 // src/prompts.ts
 var skillsContent = {
@@ -21426,186 +21583,134 @@ var require2 = createRequire2(import.meta.url);
 var packageJson = require2("../package.json");
 var config2 = loadConfig();
 var backendManager = new BackendManager(config2);
+var startedBackends = new Set;
 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;
+    switch (prop.type) {
+      case "string":
+        zodType = exports_external.string();
+        if (prop.enum) {
+          zodType = exports_external.enum(prop.enum);
+        }
+        break;
+      case "number":
+      case "integer":
+        zodType = exports_external.number();
+        if (prop.type === "integer") {
+          zodType = zodType.int();
+        }
+        if (prop.exclusiveMinimum !== undefined) {
+          zodType = zodType.gt(prop.exclusiveMinimum);
+        }
+        if (prop.minimum !== undefined) {
+          zodType = zodType.gte(prop.minimum);
+        }
+        if (prop.maximum !== undefined) {
+          zodType = zodType.lte(prop.maximum);
+        }
+        break;
+      case "boolean":
+        zodType = exports_external.boolean();
+        break;
+      case "array":
+        if (prop.items?.type === "string") {
+          zodType = exports_external.array(exports_external.string());
+        } else {
+          zodType = exports_external.array(exports_external.any());
+        }
+        break;
+      case "object":
+        zodType = exports_external.record(exports_external.any());
+        break;
+      default:
+        zodType = exports_external.any();
+    }
+    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 registerBackendTools(language, tools) {
+  let count = 0;
+  for (const tool of tools) {
+    const namespacedName = `${language}_${tool.name}`;
+    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}`);
+    count++;
+  }
+  return count;
+}
+async function startAndRegisterBackend(language) {
+  if (startedBackends.has(language)) {
+    const status2 = backendManager.getStatus()[language];
+    console.error(`[lsp-mcp] ${language} backend already started (${status2?.tools} tools)`);
+    return status2?.tools || 0;
+  }
+  console.error(`[lsp-mcp] Starting ${language} backend...`);
+  try {
+    const tools = await backendManager.getTools(language);
+    const count = registerBackendTools(language, tools);
+    startedBackends.add(language);
+    console.error(`[lsp-mcp] ${language}: ${count} tools registered`);
+    return count;
+  } catch (error2) {
+    console.error(`[lsp-mcp] Failed to start ${language} backend:`, error2);
+    throw error2;
+  }
+}
+async function updateAndRestartBackend(language) {
+  console.error(`[lsp-mcp] Updating ${language} backend...`);
+  const result = await backendManager.restartBackend(language);
+  if (startedBackends.has(language)) {
+    console.error(`[lsp-mcp] ${language} backend updated, tools still available`);
+  } else {
+    const tools = await backendManager.getTools(language);
+    registerBackendTools(language, tools);
+    startedBackends.add(language);
+    console.error(`[lsp-mcp] ${language} backend updated and ${tools.length} 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("switch_python_backend", {
   description: "Switch the Python backend provider (requires restart)",
   inputSchema: switchPythonBackendSchema
 }, async ({ provider }) => switchPythonBackend(provider));
-if (config2.python.enabled) {
-  const backendOption = exports_external.enum(["rope", "pyright"]).optional().describe("Backend to use (rope/pyright)");
-  server.registerTool("python/hover", {
-    description: pythonToolDescriptions.hover,
-    inputSchema: { ...positionArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "hover", args));
-  server.registerTool("python/definition", {
-    description: pythonToolDescriptions.definition,
-    inputSchema: { ...positionArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "definition", args));
-  server.registerTool("python/references", {
-    description: pythonToolDescriptions.references,
-    inputSchema: { ...positionArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "references", args));
-  server.registerTool("python/completions", {
-    description: pythonToolDescriptions.completions,
-    inputSchema: { ...completionsArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "completions", args));
-  server.registerTool("python/diagnostics", {
-    description: pythonToolDescriptions.diagnostics,
-    inputSchema: diagnosticsArgs
-  }, async (args) => backendManager.callTool("python", "diagnostics", args));
-  server.registerTool("python/symbols", {
-    description: pythonToolDescriptions.symbols,
-    inputSchema: { ...symbolsArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "symbols", args));
-  server.registerTool("python/rename", {
-    description: pythonToolDescriptions.rename,
-    inputSchema: { ...positionArgs, new_name: exports_external.string().describe("New name for the symbol") }
-  }, async (args) => backendManager.callTool("python", "rename", args));
-  server.registerTool("python/search", {
-    description: pythonToolDescriptions.search,
-    inputSchema: searchArgs
-  }, async (args) => backendManager.callTool("python", "search", args));
-  server.registerTool("python/signature_help", {
-    description: pythonToolDescriptions.signature_help,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("python", "signature_help", args));
-  server.registerTool("python/update_document", {
-    description: pythonToolDescriptions.update_document,
-    inputSchema: updateDocumentArgs
-  }, async (args) => backendManager.callTool("python", "update_document", args));
-  server.registerTool("python/status", {
-    description: pythonToolDescriptions.status
-  }, async () => backendManager.callTool("python", "status", {}));
-  server.registerTool("python/move", {
-    description: pythonToolDescriptions.move,
-    inputSchema: {
-      ...positionArgs,
-      destination: exports_external.string().describe('Destination module path (e.g., "mypackage.utils")'),
-      preview: exports_external.boolean().default(false).describe("If true, only show what would change")
-    }
-  }, async (args) => backendManager.callTool("python", "move", args));
-  server.registerTool("python/change_signature", {
-    description: pythonToolDescriptions.change_signature,
-    inputSchema: {
-      ...positionArgs,
-      new_params: exports_external.array(exports_external.string()).optional().describe("New parameter order"),
-      add_param: exports_external.string().optional().describe("Name of parameter to add"),
-      add_param_default: exports_external.string().optional().describe("Default value for added parameter"),
-      add_param_index: exports_external.number().int().optional().describe("Index where to insert new param"),
-      remove_param: exports_external.string().optional().describe("Name of parameter to remove"),
-      preview: exports_external.boolean().default(false).describe("If true, only show what would change")
-    }
-  }, async (args) => backendManager.callTool("python", "change_signature", args));
-  server.registerTool("python/function_signature", {
-    description: pythonToolDescriptions.function_signature,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("python", "function_signature", args));
-  server.registerTool("python/set_backend", {
-    description: pythonToolDescriptions.set_backend,
-    inputSchema: {
-      backend: exports_external.enum(["rope", "pyright"]).describe("The backend to use"),
-      tool: exports_external.string().optional().describe("Optional tool name to set backend for")
-    }
-  }, async (args) => backendManager.callTool("python", "set_backend", args));
-  server.registerTool("python/set_python_path", {
-    description: pythonToolDescriptions.set_python_path,
-    inputSchema: {
-      python_path: exports_external.string().describe("Absolute path to the Python interpreter"),
-      workspace: exports_external.string().optional().describe("Optional workspace to set the path for")
-    }
-  }, async (args) => backendManager.callTool("python", "set_python_path", args));
-}
-if (config2.typescript.enabled) {
-  server.registerTool("typescript/hover", {
-    description: typescriptToolDescriptions.hover,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "hover", args));
-  server.registerTool("typescript/definition", {
-    description: typescriptToolDescriptions.definition,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "definition", args));
-  server.registerTool("typescript/references", {
-    description: typescriptToolDescriptions.references,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "references", args));
-  server.registerTool("typescript/completions", {
-    description: typescriptToolDescriptions.completions,
-    inputSchema: completionsArgs
-  }, async (args) => backendManager.callTool("typescript", "completions", args));
-  server.registerTool("typescript/diagnostics", {
-    description: typescriptToolDescriptions.diagnostics,
-    inputSchema: diagnosticsArgs
-  }, async (args) => backendManager.callTool("typescript", "diagnostics", args));
-  server.registerTool("typescript/symbols", {
-    description: typescriptToolDescriptions.symbols,
-    inputSchema: symbolsArgs
-  }, async (args) => backendManager.callTool("typescript", "symbols", args));
-  server.registerTool("typescript/rename", {
-    description: typescriptToolDescriptions.rename,
-    inputSchema: renameArgs
-  }, async (args) => backendManager.callTool("typescript", "rename", args));
-  server.registerTool("typescript/search", {
-    description: typescriptToolDescriptions.search,
-    inputSchema: searchArgs
-  }, async (args) => backendManager.callTool("typescript", "search", args));
-  server.registerTool("typescript/signature_help", {
-    description: typescriptToolDescriptions.signature_help,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "signature_help", args));
-  server.registerTool("typescript/update_document", {
-    description: typescriptToolDescriptions.update_document,
-    inputSchema: updateDocumentArgs
-  }, async (args) => backendManager.callTool("typescript", "update_document", args));
-  server.registerTool("typescript/status", {
-    description: typescriptToolDescriptions.status,
-    inputSchema: {
-      file: exports_external.string().describe("A TypeScript/JavaScript file to check project status for")
-    }
-  }, async (args) => backendManager.callTool("typescript", "status", args));
-  server.registerTool("typescript/move", {
-    description: "Move a function, class, or variable to a new file",
-    inputSchema: {
-      file: exports_external.string().describe("Absolute path to the file"),
-      line: exports_external.number().int().positive().describe("Line number (1-based)"),
-      column: exports_external.number().int().positive().describe("Column number (1-based)"),
-      destination: exports_external.string().optional().describe("Destination file path (optional)"),
-      preview: exports_external.boolean().default(false).describe("If true, only show what would change")
-    }
-  }, async (args) => backendManager.callTool("typescript", "move", args));
-  server.registerTool("typescript/function_signature", {
-    description: "Get the current signature of a function at a specific position",
-    inputSchema: {
-      file: exports_external.string().describe("Absolute path to the file"),
-      line: exports_external.number().int().positive().describe("Line number (1-based)"),
-      column: exports_external.number().int().positive().describe("Column number (1-based)")
-    }
-  }, async (args) => backendManager.callTool("typescript", "function_signature", args));
-  server.registerTool("typescript/available_refactors", {
-    description: "Get available refactoring actions at a specific position",
-    inputSchema: {
-      file: exports_external.string().describe("Absolute path to the file"),
-      line: exports_external.number().int().positive().describe("Line number (1-based)"),
-      column: exports_external.number().int().positive().describe("Column number (1-based)")
-    }
-  }, async (args) => backendManager.callTool("typescript", "available_refactors", args));
-  server.registerTool("typescript/apply_refactor", {
-    description: "Apply a specific refactoring action at a position",
-    inputSchema: {
-      file: exports_external.string().describe("Absolute path to the file"),
-      line: exports_external.number().int().positive().describe("Line number (1-based)"),
-      column: exports_external.number().int().positive().describe("Column number (1-based)"),
-      refactorName: exports_external.string().describe("Name of the refactoring"),
-      actionName: exports_external.string().describe("Name of the action"),
-      preview: exports_external.boolean().default(false).describe("If true, only show what would change")
-    }
-  }, async (args) => backendManager.callTool("typescript", "apply_refactor", args));
-}
+server.registerTool("list_backends", {
+  description: "List available backends and their status. Shows which backends are installed, running, and how many tools they provide."
+}, async () => listBackends(backendManager, config2));
+server.registerTool("start_backend", {
+  description: "Start a backend and register its tools. This will download and install the backend if needed, then make its tools available.",
+  inputSchema: startBackendSchema
+}, async ({ language }) => startBackend(language, backendManager, config2, startAndRegisterBackend));
+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));
 async function gracefulShutdown(signal) {
   console.error(`
 [lsp-mcp] Received ${signal}, shutting down gracefully...`);
@@ -21623,12 +21728,15 @@ process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
 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("");
-  console.error("Tools are namespaced: python/hover, typescript/definition, etc.");
+  console.error("Backends are loaded on-demand. Use these tools to get started:");
+  console.error("  - list_backends: See available backends and their status");
+  console.error("  - start_backend: Install and start a backend (e.g., start_backend language=python)");
+  console.error("");
   console.error("Prompts available: code-navigation, refactoring, code-analysis, lsp-rules, lsp-quick-start");
-  console.error("Backends start lazily on first tool call.");
   console.error("");
   const transport = new StdioServerTransport;
   await server.connect(transport);
@@ -21639,4 +21747,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=42A9C81F8A74BE4464756E2164756E21
+//# debugId=0931320CB6D5336A64756E2164756E21