@treedy/lsp-mcp 0.1.3 → 0.1.4

package/README.md

@@ -97,6 +97,7 @@ Replace `{lang}` with `python` or `typescript`.
 |------|-------------|
 | `list_backends` | List available backends and their status |
 | `start_backend` | Install and start a backend (downloads if needed) |
+| `update_backend` | Update a backend to the latest version |
 | `status` | Overall server and backend status with versions |
 | `check_versions` | Detailed version info for server and all backends |
 | `switch_python_backend` | Switch Python provider |
@@ -120,6 +121,11 @@ Replace `{lang}` with `python` or `typescript`.
    typescript_definition file=/path/to/file.ts line=15 column=10
    ```
 
+4. **Update a backend** (when new version is available):
+   ```
+   update_backend language=python
+   ```
+
 ## Available Prompts (Skills)
 
 The server exposes skill documentation as MCP prompts that agents can request:

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]) => {
@@ -20767,6 +20804,9 @@ async function status(backendManager, config2) {
       typescript: {
         enabled: config2.typescript.enabled
       },
+      vue: {
+        enabled: config2.vue.enabled
+      },
       autoUpdate: config2.autoUpdate
     },
     backends: backendStatus,
@@ -20824,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."
@@ -20866,13 +20913,21 @@ async function listBackends(backendManager, config2) {
       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' or 'typescript' to install and start a backend",
-      tools: "Once started, backend tools will be available as {language}_{tool} (e.g., python_hover)"
+      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 {
@@ -20880,7 +20935,7 @@ async function listBackends(backendManager, config2) {
   };
 }
 var startBackendSchema = {
-  language: exports_external.enum(["python", "typescript"]).describe("The backend to start")
+  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) {
@@ -20907,6 +20962,18 @@ async function startBackend(language, backendManager, config2, registerToolsCall
       }]
     };
   }
+  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();
@@ -20940,6 +21007,80 @@ async function startBackend(language, backendManager, config2, registerToolsCall
     };
   }
 }
+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 = {
@@ -21540,6 +21681,19 @@ async function startAndRegisterBackend(language) {
     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", {
@@ -21553,6 +21707,10 @@ 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...`);
@@ -21589,4 +21747,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=A15518B7EDCDD67064756E2164756E21
+//# debugId=0931320CB6D5336A64756E2164756E21