@treedy/vue-lsp-mcp 0.1.5 → 0.2.0

package/dist/index.js

@@ -19382,46 +19382,71 @@ class StdioServerTransport {
 // src/index.ts
 import * as path3 from "path";
 import * as fs3 from "fs";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 
 // src/vue-service.ts
 import * as path from "path";
 import * as fs from "fs";
 import { spawn } from "child_process";
+import { createRequire as createRequire2 } from "module";
 var documentContents = new Map;
 var documentVersions = new Map;
 var messageId = 0;
+var activeConnections = new Set;
+process.on("exit", () => {
+  for (const conn of activeConnections) {
+    try {
+      conn.process.kill();
+      if (conn.tsserver)
+        conn.tsserver.kill();
+    } catch (e) {}
+  }
+});
 var connectionCache = new Map;
 function spawnTsServer(conn) {
   if (conn.tsserver)
     return;
   const projectRoot = conn.projectRoot;
-  const tsserverPaths = [
-    path.join(projectRoot, "node_modules", "typescript", "lib", "tsserver.js"),
-    path.join(projectRoot, "node_modules", ".bin", "tsserver")
-  ];
+  const projectRequire = createRequire2(path.join(projectRoot, "package.json"));
   let tsserverPath = null;
-  for (const p of tsserverPaths) {
-    if (fs.existsSync(p)) {
-      tsserverPath = p;
-      break;
+  try {
+    const typescriptPath = projectRequire.resolve("typescript");
+    tsserverPath = path.join(path.dirname(typescriptPath), "tsserver.js");
+  } catch (e) {
+    const commonPaths = [
+      path.join(projectRoot, "node_modules", "typescript", "lib", "tsserver.js"),
+      path.join(projectRoot, "node_modules", ".bin", "tsserver")
+    ];
+    for (const p of commonPaths) {
+      if (fs.existsSync(p)) {
+        tsserverPath = p;
+        break;
+      }
     }
   }
-  if (!tsserverPath) {
+  if (!tsserverPath || !fs.existsSync(tsserverPath)) {
     console.error("[DEBUG] tsserver not found, Volar 3.x features may not work");
     return;
   }
-  const vuePluginPaths = [
-    path.join(projectRoot, "node_modules", "@vue", "typescript-plugin"),
-    path.join(projectRoot, "node_modules", "@vue", "language-core", "dist", "languagePlugin.js")
-  ];
   let vuePluginPath = null;
-  for (const p of vuePluginPaths) {
-    if (fs.existsSync(p)) {
-      vuePluginPath = p;
-      break;
+  try {
+    try {
+      const pkgPath = projectRequire.resolve("@vue/typescript-plugin/package.json");
+      vuePluginPath = path.dirname(pkgPath);
+    } catch {
+      const langCorePath = projectRequire.resolve("@vue/language-core");
+      const commonPluginPaths = [
+        path.join(projectRoot, "node_modules", "@vue", "typescript-plugin"),
+        path.join(projectRoot, "node_modules", "@vue", "language-core", "dist", "languagePlugin.js")
+      ];
+      for (const p of commonPluginPaths) {
+        if (fs.existsSync(p)) {
+          vuePluginPath = p;
+          break;
+        }
+      }
     }
-  }
+  } catch (e) {}
   const plugins = vuePluginPath ? [{ name: vuePluginPath }] : [];
   conn.tsserver = spawn("node", [tsserverPath], {
     cwd: projectRoot,
@@ -19438,14 +19463,11 @@ function spawnTsServer(conn) {
     conn.tsserverBuffer += data.toString();
     parseTsServerMessages(conn);
   });
-  conn.tsserver.stderr?.on("data", (data) => {
-    console.error("[tsserver]", data.toString().trim());
-  });
+  conn.tsserver.stderr?.on("data", (data) => {});
   conn.tsserver.on("error", (error2) => {
     console.error("[tsserver] Error:", error2);
   });
   conn.tsserver.on("exit", (code) => {
-    console.error(`[tsserver] Exited with code: ${code}`);
     conn.tsserver = undefined;
   });
   const seq = ++conn.tsserverSeq;
@@ -19730,18 +19752,30 @@ async function getConnection(projectRoot) {
   if (connectionCache.has(projectRoot)) {
     return connectionCache.get(projectRoot);
   }
-  const vueServerPaths = [
-    path.join(projectRoot, "node_modules", "@vue", "language-server", "bin", "vue-language-server.js"),
-    path.join(projectRoot, "node_modules", ".bin", "vue-language-server")
-  ];
+  const projectRequire = createRequire2(path.join(projectRoot, "package.json"));
   let serverPath = null;
-  for (const p of vueServerPaths) {
-    if (fs.existsSync(p)) {
-      serverPath = p;
-      break;
+  let args = [];
+  try {
+    const pkgPath = projectRequire.resolve("@vue/language-server/package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    const binPath = pkg.bin ? typeof pkg.bin === "string" ? pkg.bin : pkg.bin["vue-language-server"] : "bin/vue-language-server.js";
+    serverPath = path.join(path.dirname(pkgPath), binPath);
+    args = ["node", serverPath, "--stdio"];
+  } catch (e) {
+    const possiblePaths = [
+      path.join(projectRoot, "node_modules", "@vue", "language-server", "bin", "vue-language-server.js")
+    ];
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        serverPath = p;
+        args = ["node", serverPath, "--stdio"];
+        break;
+      }
+    }
+    if (!serverPath) {
+      args = ["npx", "@vue/language-server", "--stdio"];
     }
   }
-  const args = serverPath ? ["node", serverPath, "--stdio"] : ["npx", "@vue/language-server", "--stdio"];
   const proc = spawn(args[0], args.slice(1), {
     cwd: projectRoot,
     stdio: ["pipe", "pipe", "pipe"],
@@ -19756,29 +19790,34 @@ async function getConnection(projectRoot) {
     openedDocuments: new Set,
     projectRoot
   };
+  activeConnections.add(conn);
   proc.stdout?.on("data", (data) => {
     conn.buffer += data.toString();
     parseMessages(conn);
   });
-  proc.stderr?.on("data", (data) => {
-    console.error("[vue-language-server]", data.toString());
-  });
+  proc.stderr?.on("data", (data) => {});
   proc.on("error", (error2) => {
     console.error("Failed to start vue-language-server:", error2);
   });
   proc.on("exit", (code) => {
     connectionCache.delete(projectRoot);
+    activeConnections.delete(conn);
   });
   connectionCache.set(projectRoot, conn);
-  const tsSdkPaths = [
-    path.join(projectRoot, "node_modules", "typescript", "lib"),
-    path.join(projectRoot, "node_modules", "typescript")
-  ];
   let tsSdkPath;
-  for (const p of tsSdkPaths) {
-    if (fs.existsSync(p)) {
-      tsSdkPath = p;
-      break;
+  try {
+    const tsPath = projectRequire.resolve("typescript");
+    tsSdkPath = path.dirname(tsPath);
+  } catch {
+    const tsPaths = [
+      path.join(projectRoot, "node_modules", "typescript", "lib"),
+      path.join(projectRoot, "node_modules", "typescript")
+    ];
+    for (const p of tsPaths) {
+      if (fs.existsSync(p)) {
+        tsSdkPath = p;
+        break;
+      }
     }
   }
   await sendMessage(conn, "initialize", {
@@ -19792,7 +19831,13 @@ async function getConnection(projectRoot) {
         signatureHelp: {},
         definition: {},
         references: {},
-        publishDiagnostics: {}
+        publishDiagnostics: {},
+        synchronization: {
+          didOpen: true,
+          didChange: true,
+          didSave: true,
+          dynamicRegistration: true
+        }
       },
       workspace: {
         configuration: true,
@@ -19836,10 +19881,26 @@ async function ensureDocumentOpen(conn, filePath) {
   });
   conn.openedDocuments.add(absPath);
 }
-function updateDocument(filePath, content) {
+async function updateDocument(filePath, content) {
   const absPath = path.resolve(filePath);
+  const projectRoot = findProjectRoot(filePath);
   documentContents.set(absPath, content);
-  documentVersions.set(absPath, (documentVersions.get(absPath) || 0) + 1);
+  const newVersion = (documentVersions.get(absPath) || 0) + 1;
+  documentVersions.set(absPath, newVersion);
+  if (connectionCache.has(projectRoot)) {
+    const conn = connectionCache.get(projectRoot);
+    if (conn.openedDocuments.has(absPath)) {
+      sendNotification(conn, "textDocument/didChange", {
+        textDocument: {
+          uri: toUri(absPath),
+          version: newVersion
+        },
+        contentChanges: [
+          { text: content }
+        ]
+      });
+    }
+  }
 }
 async function getQuickInfo(filePath, line, column) {
   const projectRoot = findProjectRoot(filePath);
@@ -20001,6 +20062,21 @@ async function getSignatureHelp(filePath, line, column) {
 async function getDiagnostics(filePath) {
   const projectRoot = findProjectRoot(filePath);
   const absPath = path.resolve(filePath);
+  try {
+    const conn = await getConnection(projectRoot);
+    await ensureDocumentOpen(conn, absPath);
+    let attempts = 0;
+    while (attempts < 10) {
+      if (conn.diagnosticsCache.has(absPath)) {
+        return conn.diagnosticsCache.get(absPath);
+      }
+      await new Promise((r) => setTimeout(r, 200));
+      attempts++;
+    }
+    return conn.diagnosticsCache.get(absPath) || [];
+  } catch (e) {
+    console.error("LSP diagnostics failed, falling back to vue-tsc spawn:", e);
+  }
   const vueTscPaths = [
     path.join(projectRoot, "node_modules", ".bin", "vue-tsc"),
     path.join(projectRoot, "node_modules", "vue-tsc", "bin", "vue-tsc.js")
@@ -20547,7 +20623,7 @@ async function getSignatureHelp3(file, line, column) {
   }
   return getSignatureHelp2(file, line, column);
 }
-var require2 = createRequire2(import.meta.url);
+var require2 = createRequire3(import.meta.url);
 var packageJson = require2("../package.json");
 var server = new McpServer({
   name: "vue-lsp-mcp",
@@ -20721,7 +20797,7 @@ server.tool("update_document", "Update Vue file content for incremental analysis
   content: exports_external.string().describe("New content for the file")
 }, async ({ file, content }) => {
   try {
-    updateDocument(file, content);
+    await updateDocument(file, content);
     return {
       content: [{
         type: "text",

package/dist/vue-service.d.ts

@@ -21,8 +21,9 @@ export declare function offsetToPosition(content: string, offset: number): {
 };
 /**
  * Update document content for incremental analysis
+ * Now properly synchronizes with LSP server
  */
-export declare function updateDocument(filePath: string, content: string): void;
+export declare function updateDocument(filePath: string, content: string): Promise<void>;
 /**
  * Create Vue language service for a project
  */
@@ -91,7 +92,11 @@ interface Diagnostic {
     source?: string;
 }
 /**
- * Get diagnostics for a file using vue-tsc
+ * Get diagnostics for a file
+ *
+ * Strategy:
+ * 1. For single files, prefer LSP diagnostics (faster, incremental)
+ * 2. Fallback to vue-tsc only if LSP unavailable or for project-wide checks (if needed)
  */
 export declare function getDiagnostics(filePath: string): Promise<Diagnostic[]>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treedy/vue-lsp-mcp",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },