@treedy/vue-lsp-mcp 0.1.5 → 0.2.1

package/README.md

@@ -0,0 +1,33 @@
+# Vue LSP MCP Server
+
+A Model Context Protocol (MCP) server that provides Vue.js code intelligence using **Volar** (`@vue/language-server`).
+
+## Features
+
+*   **Vue SFC Support**: Intelligent analysis of `.vue` files (Template, Script, Style).
+*   **Hybrid Mode**: Supports TypeScript files in Vue projects.
+*   **LSP Features**: Hover, Definition, Completion, etc.
+
+## Installation
+
+```bash
+npm install -g @treedy/vue-lsp-mcp
+```
+
+## Usage
+
+Run via command line (stdio):
+
+```bash
+vue-lsp-mcp
+```
+
+Or via npx:
+
+```bash
+npx @treedy/vue-lsp-mcp
+```
+
+## Requirements
+
+Requires a Vue project with `typescript` and `vue` installed in `node_modules`.

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;
@@ -19567,6 +19589,61 @@ ${responseNotification}`;
     }
   }, 30000);
 }
+var activeWorkspace = null;
+function setActiveWorkspace(workspace) {
+  activeWorkspace = path.resolve(workspace);
+  return activeWorkspace;
+}
+function resolveFilePath(filePath) {
+  const pathObj = path.parse(filePath);
+  let absPath;
+  if (!path.isAbsolute(filePath)) {
+    if (activeWorkspace) {
+      absPath = path.resolve(activeWorkspace, filePath);
+    } else {
+      absPath = path.resolve(filePath);
+    }
+  } else {
+    absPath = filePath;
+  }
+  absPath = path.resolve(absPath);
+  if (activeWorkspace && !absPath.startsWith(activeWorkspace)) {
+    return {
+      absPath: null,
+      error: JSON.stringify({
+        error: "Context Mismatch",
+        message: `The file '${filePath}' resolves to '${absPath}', which is outside the active workspace '${activeWorkspace}'.
+
+Current Logic:
+1. I only analyze files from the active project to ensure accuracy and save resources.
+2. You must explicitly switch the workspace if you want to work on a different project.
+
+Action Required:
+Please call 'switch_workspace(path="...")' with the new project root before retrying.`,
+        currentWorkspace: activeWorkspace,
+        resolvedPath: absPath
+      })
+    };
+  }
+  return { absPath, error: null };
+}
+function validateFileWorkspace(filePath) {
+  const { error: error2 } = resolveFilePath(filePath);
+  return error2;
+}
+function clearAllConnections() {
+  for (const conn of activeConnections) {
+    try {
+      conn.process.kill();
+      if (conn.tsserver)
+        conn.tsserver.kill();
+    } catch (e) {}
+  }
+  activeConnections.clear();
+  connectionCache.clear();
+  documentContents.clear();
+  documentVersions.clear();
+}
 function findProjectRoot(filePath) {
   let dir = path.dirname(path.resolve(filePath));
   while (dir !== path.dirname(dir)) {
@@ -19730,18 +19807,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 +19845,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 +19886,13 @@ async function getConnection(projectRoot) {
         signatureHelp: {},
         definition: {},
         references: {},
-        publishDiagnostics: {}
+        publishDiagnostics: {},
+        synchronization: {
+          didOpen: true,
+          didChange: true,
+          didSave: true,
+          dynamicRegistration: true
+        }
       },
       workspace: {
         configuration: true,
@@ -19804,7 +19904,7 @@ async function getConnection(projectRoot) {
         tsdk: tsSdkPath || ""
       },
       vue: {
-        hybridMode: false
+        hybridMode: true
       }
     },
     workspaceFolders: [
@@ -19836,10 +19936,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);
@@ -19998,9 +20114,48 @@ async function getSignatureHelp(filePath, line, column) {
     return null;
   }
 }
+async function getInlayHints(filePath) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  try {
+    const content = getFileContent(filePath);
+    const lines = content.split(`
+`);
+    const result = await sendMessage(conn, "textDocument/inlayHint", {
+      textDocument: { uri: toUri(filePath) },
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: lines.length, character: lines[lines.length - 1].length }
+      }
+    });
+    if (!result) {
+      return [];
+    }
+    return Array.isArray(result) ? result : [];
+  } catch (error2) {
+    console.error("Inlay hints error:", error2);
+    return [];
+  }
+}
 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")
@@ -20236,7 +20391,7 @@ async function ensureFileOpen(conn, filePath) {
     await sendCommand(conn, "open", {
       file: absPath,
       fileContent: content,
-      scriptKindName: "TS",
+      scriptKindName: "Unknown",
       projectRootPath: conn.projectRoot
     });
     conn.openedFiles.add(absPath);
@@ -20513,46 +20668,90 @@ async function getRenameLocations(filePath, line, column) {
 
 // src/index.ts
 async function getQuickInfo3(file, line, column) {
-  const lspResult = await getQuickInfo(file, line, column);
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  const lspResult = await getQuickInfo(absPath, line, column);
   if (lspResult && lspResult.contents) {
     return lspResult;
   }
-  return getQuickInfo2(file, line, column);
+  return getQuickInfo2(absPath, line, column);
 }
 async function getDefinition3(file, line, column) {
-  const lspResult = await getDefinition(file, line, column);
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  const lspResult = await getDefinition(absPath, line, column);
   if (lspResult && lspResult.length > 0) {
     return lspResult;
   }
-  return getDefinition2(file, line, column);
+  return getDefinition2(absPath, line, column);
 }
 async function getReferences3(file, line, column) {
-  const lspResult = await getReferences(file, line, column);
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  const lspResult = await getReferences(absPath, line, column);
   if (lspResult && lspResult.length > 0) {
     return lspResult;
   }
-  return getReferences2(file, line, column);
+  return getReferences2(absPath, line, column);
 }
 async function getCompletions3(file, line, column, limit = 20) {
-  const lspResult = await getCompletions(file, line, column, limit);
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  const lspResult = await getCompletions(absPath, line, column, limit);
   if (lspResult && lspResult.items && lspResult.items.length > 0) {
     return lspResult;
   }
-  return getCompletions2(file, line, column, limit);
+  return getCompletions2(absPath, line, column, limit);
 }
 async function getSignatureHelp3(file, line, column) {
-  const lspResult = await getSignatureHelp(file, line, column);
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  const lspResult = await getSignatureHelp(absPath, line, column);
   if (lspResult && lspResult.signatures && lspResult.signatures.length > 0) {
     return lspResult;
   }
-  return getSignatureHelp2(file, line, column);
+  return getSignatureHelp2(absPath, 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",
   version: packageJson.version
 });
+server.tool("switch_workspace", "Switch the active workspace to a new project directory", {
+  path: exports_external.string().describe("Absolute path to the new project root directory")
+}, async ({ path: inputPath }) => {
+  try {
+    const absPath = path3.resolve(inputPath);
+    if (!fs3.existsSync(absPath) || !fs3.statSync(absPath).isDirectory()) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Invalid Path", message: `'${inputPath}' is not a directory.` }) }]
+      };
+    }
+    clearAllConnections();
+    const newWorkspace = setActiveWorkspace(absPath);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: `Switched active workspace to: ${newWorkspace}`,
+          workspace: newWorkspace,
+          info: "All previous Vue language server connections have been closed."
+        })
+      }]
+    };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: String(error2) }) }]
+    };
+  }
+});
 server.tool("hover", "Get type information and documentation at a specific position in a Vue SFC file", {
   file: exports_external.string().describe("Absolute path to the .vue file"),
   line: exports_external.number().int().positive().describe("Line number (1-based)"),
@@ -20668,11 +20867,35 @@ server.tool("signature_help", "Get function signature help at a specific positio
     };
   }
 });
+server.tool("inlay_hints", "Get inlay hints (type annotations, parameter names) for a Vue SFC file", {
+  file: exports_external.string().describe("Path to the .vue file (absolute or relative to active workspace)")
+}, async ({ file }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const hints = await getInlayHints(absPath);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ hints, count: hints.length })
+      }]
+    };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: String(error2) }) }]
+    };
+  }
+});
 server.tool("diagnostics", "Get type errors and warnings for Vue SFC files", {
-  path: exports_external.string().describe("Path to a .vue file or directory to check")
+  path: exports_external.string().describe("Path to a .vue file or directory to check (absolute or relative to active workspace)")
 }, async ({ path: inputPath }) => {
   try {
-    const absPath = path3.resolve(inputPath);
+    const { absPath, error: error2 } = resolveFilePath(inputPath);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
     const stats = fs3.statSync(absPath);
     let files = [];
     if (stats.isDirectory()) {
@@ -20717,15 +20940,19 @@ server.tool("diagnostics", "Get type errors and warnings for Vue SFC files", {
   }
 });
 server.tool("update_document", "Update Vue file content for incremental analysis without writing to disk", {
-  file: exports_external.string().describe("Absolute path to the .vue file"),
+  file: exports_external.string().describe("Path to the .vue file (absolute or relative to active workspace)"),
   content: exports_external.string().describe("New content for the file")
 }, async ({ file, content }) => {
   try {
-    updateDocument(file, content);
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    await updateDocument(absPath, content);
     return {
       content: [{
         type: "text",
-        text: JSON.stringify({ success: true, file })
+        text: JSON.stringify({ success: true, file: absPath })
       }]
     };
   } catch (error2) {
@@ -20735,7 +20962,7 @@ server.tool("update_document", "Update Vue file content for incremental analysis
   }
 });
 server.tool("symbols", "Extract symbols (variables, functions, components) from a Vue SFC file", {
-  file: exports_external.string().describe("Absolute path to the .vue file"),
+  file: exports_external.string().describe("Path to the .vue file (absolute or relative to active workspace)"),
   query: exports_external.string().optional().describe("Optional filter query for symbol names")
 }, async ({ file, query }) => {
   try {
@@ -20770,7 +20997,11 @@ server.tool("symbols", "Extract symbols (variables, functions, components) from
         }
       }
     };
-    const tree = await getDocumentSymbols(file);
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const tree = await getDocumentSymbols(absPath);
     if (!tree) {
       return {
         content: [{ type: "text", text: JSON.stringify({ error: "Failed to get symbols" }) }]
@@ -20795,13 +21026,17 @@ server.tool("symbols", "Extract symbols (variables, functions, components) from
   }
 });
 server.tool("rename", "Preview renaming a symbol at a specific position (shows all locations that would be renamed)", {
-  file: exports_external.string().describe("Absolute path to the .vue file"),
+  file: exports_external.string().describe("Path to the .vue file (absolute or relative to active workspace)"),
   line: exports_external.number().int().positive().describe("Line number (1-based)"),
   column: exports_external.number().int().positive().describe("Column number (1-based)"),
   newName: exports_external.string().describe("New name for the symbol")
 }, async ({ file, line, column, newName }) => {
   try {
-    const locations = await getRenameLocations(file, line, column);
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const locations = await getRenameLocations(absPath, line, column);
     if (!locations || locations.length === 0) {
       return {
         content: [{ type: "text", text: JSON.stringify({ error: "Cannot rename symbol at this position" }) }]
@@ -20838,12 +21073,25 @@ server.tool("rename", "Preview renaming a symbol at a specific position (shows a
 });
 server.tool("search", "Search for a pattern in Vue files using ripgrep", {
   pattern: exports_external.string().describe("The regex pattern to search for"),
-  path: exports_external.string().optional().describe("Directory or file to search in"),
+  path: exports_external.string().optional().describe("Directory or file to search in (absolute or relative to active workspace)"),
   glob: exports_external.string().optional().describe("Glob pattern to filter files (e.g., '*.vue')"),
   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")
 }, async ({ pattern, path: searchPath, glob, caseSensitive, maxResults }) => {
   try {
+    let absSearchPath;
+    if (searchPath) {
+      const { absPath, error: error2 } = validateFileWorkspace(searchPath) ? { absPath: null, error: validateFileWorkspace(searchPath) } : { absPath: path3.resolve(searchPath), error: null };
+      const result2 = resolveFilePath(searchPath);
+      if (result2.error || !result2.absPath) {
+        return { content: [{ type: "text", text: result2.error || "Invalid path" }] };
+      }
+      absSearchPath = result2.absPath;
+    } else {
+      const { absPath } = resolveFilePath(".");
+      if (absPath)
+        absSearchPath = absPath;
+    }
     const { execSync } = await import("child_process");
     const args = ["rg", "--json", "-n"];
     if (!caseSensitive)
@@ -20855,8 +21103,8 @@ server.tool("search", "Search for a pattern in Vue files using ripgrep", {
     }
     args.push("--max-count", maxResults.toString());
     args.push(pattern);
-    if (searchPath)
-      args.push(searchPath);
+    if (absSearchPath)
+      args.push(absSearchPath);
     const result = execSync(args.join(" "), {
       encoding: "utf-8",
       maxBuffer: 10485760,
@@ -20897,10 +21145,14 @@ server.tool("search", "Search for a pattern in Vue files using ripgrep", {
   }
 });
 server.tool("status", "Check Vue Language Server status for a project", {
-  file: exports_external.string().describe("A .vue file path to check the project status for")
+  file: exports_external.string().describe("A .vue file path to check the project status for (absolute or relative to active workspace)")
 }, async ({ file }) => {
   try {
-    const status = await getProjectStatus(file);
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const status = await getProjectStatus(absPath);
     return {
       content: [{
         type: "text",

package/dist/vue-service.d.ts

@@ -4,6 +4,38 @@
  * Provides programmatic access to Vue Language Server features
  * by spawning vue-language-server and communicating via LSP.
  */
+/**
+ * Set the active workspace.
+ */
+export declare function setActiveWorkspace(workspace: string): string;
+/**
+ * Get the active workspace.
+ */
+export declare function getActiveWorkspace(): string | null;
+/**
+ * Check if a file is in the active workspace.
+ */
+export declare function isFileInWorkspace(filePath: string): boolean;
+/**
+ * Resolve a file path and validate it against the active workspace.
+ *
+ * Supports:
+ * 1. Absolute paths (must be within active workspace)
+ * 2. Relative paths (resolved against active workspace)
+ */
+export declare function resolveFilePath(filePath: string): {
+    absPath: string | null;
+    error: string | null;
+};
+/**
+ * Validate that a file is within the active workspace.
+ * @deprecated Use resolveFilePath instead.
+ */
+export declare function validateFileWorkspace(filePath: string): string | null;
+/**
+ * Clear all connections and caches.
+ */
+export declare function clearAllConnections(): void;
 /**
  * Find project root by looking for package.json or tsconfig.json
  */
@@ -21,8 +53,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
  */
@@ -71,6 +104,10 @@ export declare function getSignatureHelp(filePath: string, line: number, column:
     activeSignature: number;
     activeParameter: number;
 } | null>;
+/**
+ * Get inlay hints for a file
+ */
+export declare function getInlayHints(filePath: string): Promise<any[]>;
 /**
  * Diagnostic type for internal use
  */
@@ -91,7 +128,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.1",
   "publishConfig": {
     "access": "public"
   },