@treedy/vue-lsp-mcp 0.2.0 → 0.2.2

package/dist/index.js

@@ -19589,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)) {
@@ -19611,6 +19666,17 @@ function getFileContent(filePath) {
   }
   return "";
 }
+function positionToOffset(content, line, character) {
+  const lines = content.split(`
+`);
+  const safeLine = Math.max(0, Math.min(line, lines.length - 1));
+  let offset = 0;
+  for (let i = 0;i < safeLine; i++) {
+    offset += lines[i].length + 1;
+  }
+  const safeChar = Math.max(0, Math.min(character, lines[safeLine].length));
+  return offset + safeChar;
+}
 function toUri(filePath) {
   return `file://${path.resolve(filePath)}`;
 }
@@ -19820,7 +19886,7 @@ async function getConnection(projectRoot) {
       }
     }
   }
-  await sendMessage(conn, "initialize", {
+  const initResult = await sendMessage(conn, "initialize", {
     processId: process.pid,
     rootUri: toUri(projectRoot),
     rootPath: projectRoot,
@@ -19830,7 +19896,23 @@ async function getConnection(projectRoot) {
         completion: { completionItem: { snippetSupport: true } },
         signatureHelp: {},
         definition: {},
+        implementation: {},
+        typeDefinition: {},
         references: {},
+        documentHighlight: {},
+        selectionRange: {},
+        foldingRange: {},
+        documentLink: {},
+        callHierarchy: {},
+        codeAction: {
+          dynamicRegistration: false,
+          codeActionLiteralSupport: {
+            codeActionKind: {
+              valueSet: ["quickfix", "refactor", "source", "source.organizeImports"]
+            }
+          }
+        },
+        rename: { prepareSupport: true },
         publishDiagnostics: {},
         synchronization: {
           didOpen: true,
@@ -19849,7 +19931,7 @@ async function getConnection(projectRoot) {
         tsdk: tsSdkPath || ""
       },
       vue: {
-        hybridMode: false
+        hybridMode: true
       }
     },
     workspaceFolders: [
@@ -19859,6 +19941,7 @@ async function getConnection(projectRoot) {
       }
     ]
   });
+  conn.serverCapabilities = initResult?.capabilities || {};
   sendNotification(conn, "initialized", {});
   conn.initialized = true;
   return conn;
@@ -19956,6 +20039,52 @@ async function getDefinition(filePath, line, column) {
     return [];
   }
 }
+async function getImplementation(filePath, line, column) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/implementation", {
+    textDocument: { uri: toUri(filePath) },
+    position: { line: line - 1, character: column - 1 }
+  });
+  if (!result)
+    return [];
+  const locations = Array.isArray(result) ? result : [result];
+  return locations.map((loc) => {
+    const uri = loc.targetUri || loc.uri;
+    const range = loc.targetRange || loc.range;
+    return {
+      file: fromUri(uri),
+      line: range.start.line + 1,
+      column: range.start.character + 1,
+      endLine: range.end.line + 1,
+      endColumn: range.end.character + 1
+    };
+  });
+}
+async function getTypeDefinition(filePath, line, column) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/typeDefinition", {
+    textDocument: { uri: toUri(filePath) },
+    position: { line: line - 1, character: column - 1 }
+  });
+  if (!result)
+    return [];
+  const locations = Array.isArray(result) ? result : [result];
+  return locations.map((loc) => {
+    const uri = loc.targetUri || loc.uri;
+    const range = loc.targetRange || loc.range;
+    return {
+      file: fromUri(uri),
+      line: range.start.line + 1,
+      column: range.start.character + 1,
+      endLine: range.end.line + 1,
+      endColumn: range.end.character + 1
+    };
+  });
+}
 async function getReferences(filePath, line, column) {
   const projectRoot = findProjectRoot(filePath);
   const conn = await getConnection(projectRoot);
@@ -19979,6 +20108,25 @@ async function getReferences(filePath, line, column) {
     return [];
   }
 }
+async function getDocumentHighlights(filePath, line, column) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/documentHighlight", {
+    textDocument: { uri: toUri(filePath) },
+    position: { line: line - 1, character: column - 1 }
+  });
+  if (!result || !Array.isArray(result))
+    return [];
+  return result.map((item) => ({
+    file: path.resolve(filePath),
+    line: item.range.start.line + 1,
+    column: item.range.start.character + 1,
+    endLine: item.range.end.line + 1,
+    endColumn: item.range.end.character + 1,
+    kind: item.kind ?? 1
+  }));
+}
 async function getCompletions(filePath, line, column, limit = 20) {
   const projectRoot = findProjectRoot(filePath);
   const conn = await getConnection(projectRoot);
@@ -20059,6 +20207,275 @@ async function getSignatureHelp(filePath, line, column) {
     return null;
   }
 }
+async function getPrepareRename(filePath, line, column) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/prepareRename", {
+    textDocument: { uri: toUri(filePath) },
+    position: { line: line - 1, character: column - 1 }
+  });
+  if (!result)
+    return { canRename: false };
+  const range = "range" in result ? result.range : result;
+  const placeholder = "placeholder" in result ? result.placeholder : undefined;
+  return {
+    canRename: true,
+    placeholder,
+    range: {
+      line: range.start.line + 1,
+      column: range.start.character + 1,
+      endLine: range.end.line + 1,
+      endColumn: range.end.character + 1
+    }
+  };
+}
+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 getSemanticTokens(filePath) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/semanticTokens/full", {
+    textDocument: { uri: toUri(filePath) }
+  });
+  if (!result || !Array.isArray(result.data)) {
+    return { tokens: [], count: 0 };
+  }
+  const legend = conn.serverCapabilities?.semanticTokensProvider?.legend || {};
+  const tokenTypes = Array.isArray(legend.tokenTypes) ? legend.tokenTypes : [
+    "namespace",
+    "type",
+    "class",
+    "enum",
+    "interface",
+    "struct",
+    "typeParameter",
+    "parameter",
+    "variable",
+    "property",
+    "enumMember",
+    "event",
+    "function",
+    "method",
+    "macro",
+    "keyword",
+    "modifier",
+    "comment",
+    "string",
+    "number",
+    "regexp",
+    "operator",
+    "decorator"
+  ];
+  const tokenModifiers = Array.isArray(legend.tokenModifiers) ? legend.tokenModifiers : [];
+  let line = 0;
+  let character = 0;
+  const decoded = [];
+  for (let i = 0;i < result.data.length; i += 5) {
+    const deltaLine = result.data[i];
+    const deltaStart = result.data[i + 1];
+    const length = result.data[i + 2];
+    const tokenType = result.data[i + 3];
+    const modifierBits = result.data[i + 4];
+    line = line + deltaLine;
+    character = deltaLine > 0 ? deltaStart : character + deltaStart;
+    const modifiers = tokenModifiers.filter((_, idx) => (modifierBits & 1 << idx) !== 0);
+    decoded.push({
+      line: line + 1,
+      column: character + 1,
+      endLine: line + 1,
+      endColumn: character + length + 1,
+      token_type: tokenTypes[tokenType] || String(tokenType),
+      token_modifiers: modifiers
+    });
+  }
+  return { tokens: decoded, count: decoded.length };
+}
+async function getSelectionRanges(filePath, line, column) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/selectionRange", {
+    textDocument: { uri: toUri(filePath) },
+    positions: [{ line: line - 1, character: column - 1 }]
+  });
+  if (!Array.isArray(result) || result.length === 0)
+    return [];
+  const ranges = [];
+  let current = result[0];
+  while (current) {
+    const itemRange = current.range;
+    ranges.push({
+      line: itemRange.start.line + 1,
+      column: itemRange.start.character + 1,
+      endLine: itemRange.end.line + 1,
+      endColumn: itemRange.end.character + 1
+    });
+    current = current.parent;
+  }
+  return ranges;
+}
+async function getFoldingRanges(filePath) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/foldingRange", {
+    textDocument: { uri: toUri(filePath) }
+  });
+  if (!Array.isArray(result))
+    return [];
+  return result.map((item) => ({
+    kind: item.kind,
+    line: (item.startLine ?? 0) + 1,
+    column: (item.startCharacter ?? 0) + 1,
+    endLine: (item.endLine ?? 0) + 1,
+    endColumn: (item.endCharacter ?? 0) + 1
+  }));
+}
+async function getDocumentLinks(filePath) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/documentLink", {
+    textDocument: { uri: toUri(filePath) }
+  });
+  if (!Array.isArray(result))
+    return [];
+  return result.map((item) => ({
+    target: item.target,
+    line: item.range.start.line + 1,
+    column: item.range.start.character + 1,
+    endLine: item.range.end.line + 1,
+    endColumn: item.range.end.character + 1
+  }));
+}
+async function getCallHierarchy(filePath, line, column, direction = "both") {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const prepared = await sendMessage(conn, "textDocument/prepareCallHierarchy", {
+    textDocument: { uri: toUri(filePath) },
+    position: { line: line - 1, character: column - 1 }
+  });
+  if (!prepared || Array.isArray(prepared) && prepared.length === 0) {
+    return { items: [], count: 0, direction };
+  }
+  const baseItems = Array.isArray(prepared) ? prepared : [prepared];
+  const includeIncoming = direction === "both" || direction === "incoming";
+  const includeOutgoing = direction === "both" || direction === "outgoing";
+  const items = await Promise.all(baseItems.map(async (item) => {
+    const normalizeItem = (node) => ({
+      name: node.name,
+      kind: node.kind,
+      containerName: node.containerName,
+      file: fromUri(node.uri),
+      line: (node.selectionRange?.start?.line ?? node.range.start.line) + 1,
+      column: (node.selectionRange?.start?.character ?? node.range.start.character) + 1
+    });
+    const incoming = includeIncoming ? await sendMessage(conn, "callHierarchy/incomingCalls", { item }) || [] : [];
+    const outgoing = includeOutgoing ? await sendMessage(conn, "callHierarchy/outgoingCalls", { item }) || [] : [];
+    return {
+      symbol: normalizeItem(item),
+      incoming: incoming.map((call) => ({
+        from: normalizeItem(call.from),
+        call_count: Array.isArray(call.fromRanges) ? call.fromRanges.length : 0
+      })),
+      outgoing: outgoing.map((call) => ({
+        to: normalizeItem(call.to),
+        call_count: Array.isArray(call.fromRanges) ? call.fromRanges.length : 0
+      }))
+    };
+  }));
+  return { items, count: items.length, direction };
+}
+async function getCodeActions(filePath, line, column) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  await ensureDocumentOpen(conn, filePath);
+  const result = await sendMessage(conn, "textDocument/codeAction", {
+    textDocument: { uri: toUri(filePath) },
+    range: {
+      start: { line: line - 1, character: column - 1 },
+      end: { line: line - 1, character: column - 1 }
+    },
+    context: { diagnostics: [] }
+  });
+  return Array.isArray(result) ? result : [];
+}
+async function executeCommand(filePath, command, args = []) {
+  const projectRoot = findProjectRoot(filePath);
+  const conn = await getConnection(projectRoot);
+  return sendMessage(conn, "workspace/executeCommand", { command, arguments: args });
+}
+async function applyWorkspaceEdit(edit) {
+  const allEdits = new Map;
+  if (edit?.changes && typeof edit.changes === "object") {
+    for (const [uri, edits] of Object.entries(edit.changes)) {
+      allEdits.set(uri, Array.isArray(edits) ? edits : []);
+    }
+  }
+  if (Array.isArray(edit?.documentChanges)) {
+    for (const change of edit.documentChanges) {
+      if (change?.textDocument?.uri && Array.isArray(change.edits)) {
+        const uri = change.textDocument.uri;
+        const existing = allEdits.get(uri) || [];
+        existing.push(...change.edits);
+        allEdits.set(uri, existing);
+      }
+    }
+  }
+  let filesChanged = 0;
+  let editsApplied = 0;
+  for (const [uri, edits] of allEdits) {
+    const filePath = fromUri(uri);
+    if (!fs.existsSync(filePath))
+      continue;
+    const original = getFileContent(filePath);
+    let content = original;
+    const sorted = [...edits].sort((a, b) => {
+      if (a.range.start.line !== b.range.start.line)
+        return b.range.start.line - a.range.start.line;
+      return b.range.start.character - a.range.start.character;
+    });
+    for (const textEdit of sorted) {
+      const start = textEdit.range.start;
+      const end = textEdit.range.end;
+      const startOffset = positionToOffset(content, start.line, start.character);
+      const endOffset = positionToOffset(content, end.line, end.character);
+      content = content.slice(0, startOffset) + (textEdit.newText || "") + content.slice(endOffset);
+      editsApplied += 1;
+    }
+    if (content !== original) {
+      fs.writeFileSync(filePath, content, "utf-8");
+      await updateDocument(filePath, content);
+      filesChanged += 1;
+    }
+  }
+  return { filesChanged, editsApplied };
+}
 async function getDiagnostics(filePath) {
   const projectRoot = findProjectRoot(filePath);
   const absPath = path.resolve(filePath);
@@ -20312,7 +20729,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);
@@ -20589,39 +21006,105 @@ 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 getImplementation2(file, line, column) {
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  return getImplementation(absPath, line, column);
+}
+async function getTypeDefinition2(file, line, column) {
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  return getTypeDefinition(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 getDocumentHighlights2(file, line, column) {
+  const { absPath, error: error2 } = resolveFilePath(file);
+  if (error2 || !absPath)
+    throw new Error(error2 || "Invalid path");
+  return getDocumentHighlights(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);
+}
+function symbolAtPosition(content, line, column) {
+  const lines = content.split(`
+`);
+  if (line < 1 || line > lines.length)
+    return "";
+  const text = lines[line - 1] || "";
+  if (!text.length)
+    return "";
+  const idx = Math.max(0, Math.min(text.length - 1, column - 1));
+  const re = /[A-Za-z_][A-Za-z0-9_]*/g;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    if (match.index <= idx && idx < match.index + match[0].length) {
+      return match[0];
+    }
+  }
+  return "";
+}
+function packageNameFromPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const marker = "/node_modules/";
+  const idx = normalized.lastIndexOf(marker);
+  if (idx < 0)
+    return null;
+  const rest = normalized.slice(idx + marker.length);
+  const parts = rest.split("/");
+  if (!parts.length)
+    return null;
+  if (parts[0].startsWith("@") && parts.length > 1) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0] || null;
 }
 var require2 = createRequire3(import.meta.url);
 var packageJson = require2("../package.json");
@@ -20629,6 +21112,35 @@ 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)"),
@@ -20677,6 +21189,88 @@ server.tool("definition", "Go to definition of a symbol at a specific position i
     };
   }
 });
+server.tool("implementation", "Go to implementation of a symbol at a specific position in a Vue SFC 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)")
+}, async ({ file, line, column }) => {
+  try {
+    const implementations = await getImplementation2(file, line, column);
+    if (!implementations || implementations.length === 0) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "No implementation found" }) }]
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(implementations.length === 1 ? implementations[0] : implementations)
+      }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("implementation")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose implementation in this environment.",
+            next_step: "Use definition/references or switch to TypeScript backend for this feature.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("type_definition", "Go to type definition of a symbol at a specific position in a Vue SFC 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)")
+}, async ({ file, line, column }) => {
+  try {
+    const typeDefinitions = await getTypeDefinition2(file, line, column);
+    if (!typeDefinitions || typeDefinitions.length === 0) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "No type definition found" }) }]
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(typeDefinitions.length === 1 ? typeDefinitions[0] : typeDefinitions)
+      }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("typeDefinition")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose type_definition in this environment.",
+            next_step: "Use hover/definition or switch to TypeScript backend for this feature.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
 server.tool("references", "Find all references to a symbol 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)"),
@@ -20696,6 +21290,85 @@ server.tool("references", "Find all references to a symbol at a specific positio
     };
   }
 });
+server.tool("call_hierarchy", "Get incoming/outgoing call hierarchy for symbol at a specific position in a Vue SFC 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)"),
+  direction: exports_external.enum(["incoming", "outgoing", "both"]).default("both").optional().describe("Call hierarchy direction to include")
+}, async ({ file, line, column, direction }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const result = await getCallHierarchy(absPath, line, column, direction || "both");
+    if (!result.count) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "No call hierarchy found", ...result }) }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("callHierarchy")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose call_hierarchy in this environment.",
+            next_step: "Use references/definition or switch to TypeScript backend for call_hierarchy.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("document_highlight", "Find symbol highlights in current Vue document at a specific position", {
+  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)")
+}, async ({ file, line, column }) => {
+  try {
+    const highlights = await getDocumentHighlights2(file, line, column);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ highlights, count: highlights.length })
+      }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("documentHighlight")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose document_highlight in this environment.",
+            next_step: "Use references as fallback for symbol occurrences.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
 server.tool("completions", "Get code completion suggestions 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)"),
@@ -20744,11 +21417,106 @@ 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("semantic_tokens", "Get semantic tokens 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 result = await getSemanticTokens(absPath);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(result)
+      }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("semanticTokens")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose semantic tokens in this environment.",
+            next_step: "Use hover/definition/references or switch to TypeScript/Python where semantic_tokens is available.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("moniker", "Get moniker-like symbol identity for cross-package tracking in Vue files", {
+  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)")
+}, async ({ file, line, column }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const definitions = await getDefinition3(absPath, line, column);
+    const sourceFile = definitions.length > 0 ? definitions[0].file : absPath;
+    const content = getFileContent(absPath);
+    const symbol = symbolAtPosition(content, line, column);
+    const packageName = packageNameFromPath(sourceFile);
+    const identifier = packageName ? `npm:${packageName}:${symbol || `${line}:${column}`}` : `workspace:${sourceFile}:${symbol || `${line}:${column}`}`;
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          symbol,
+          identifier,
+          package_name: packageName,
+          source_file: sourceFile
+        })
+      }]
+    };
+  } 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()) {
@@ -20793,15 +21561,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 {
-    await 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) {
@@ -20811,7 +21583,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 {
@@ -20846,7 +21618,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" }) }]
@@ -20870,14 +21646,162 @@ server.tool("symbols", "Extract symbols (variables, functions, components) from
     };
   }
 });
+server.tool("code_action", "Get available code actions (quick fixes/refactors) at a specific position in a Vue SFC 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)")
+}, async ({ file, line, column }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const actions = await getCodeActions(absPath, line, column);
+    const formatted = actions.map((action) => ({
+      title: action.title,
+      kind: action.kind || "quickfix",
+      hasEdit: Boolean(action.edit),
+      hasCommand: Boolean(action.command),
+      data: action.data
+    }));
+    return {
+      content: [{ type: "text", text: JSON.stringify({ actions: formatted, count: formatted.length }) }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("codeAction")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose code_action in this environment.",
+            next_step: "Use diagnostics + manual edits as fallback.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("run_code_action", "Run a specific code action at a position in a Vue SFC 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)"),
+  title: exports_external.string().describe("Code action title (exact match from code_action output)")
+}, async ({ file, line, column, title }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const actions = await getCodeActions(absPath, line, column);
+    const action = actions.find((a) => a.title === title);
+    if (!action) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Action '${title}' not found` }) }]
+      };
+    }
+    let editResult = null;
+    if (action.edit) {
+      editResult = await applyWorkspaceEdit(action.edit);
+    }
+    if (action.command) {
+      const commandName = typeof action.command === "string" ? action.command : action.command.command;
+      const args = typeof action.command === "string" ? [] : action.command.arguments || [];
+      await executeCommand(absPath, commandName, args);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          title: action.title,
+          kind: action.kind || "quickfix",
+          appliedEdit: Boolean(action.edit),
+          executedCommand: Boolean(action.command),
+          editResult
+        })
+      }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("codeAction") || message.includes("executeCommand")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend cannot run code actions in this environment.",
+            next_step: "Use code_action for hints and apply edits manually.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("prepare_rename", "Check whether a symbol can be safely renamed at a specific position in a Vue SFC 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)")
+}, async ({ file, line, column }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const result = await getPrepareRename(absPath, line, column);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("prepareRename")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose prepare_rename in this environment.",
+            next_step: "Use rename preview and verify affected ranges manually.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
 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" }) }]
@@ -20912,14 +21836,174 @@ server.tool("rename", "Preview renaming a symbol at a specific position (shows a
     };
   }
 });
+server.tool("linked_editing_range", "Get linked editing ranges at a specific position in a Vue SFC 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)")
+}, async ({ file, line, column }) => {
+  try {
+    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({ ranges: [], count: 0 }) }]
+      };
+    }
+    const current = path3.resolve(absPath);
+    const ranges = locations.filter((loc) => path3.resolve(loc.file) === current).map((loc) => ({
+      line: loc.line,
+      column: loc.column,
+      endLine: loc.line,
+      endColumn: loc.column + loc.length
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ ranges, count: ranges.length })
+      }]
+    };
+  } catch (error2) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: String(error2) }) }]
+    };
+  }
+});
+server.tool("selection_range", "Get nested smart selection ranges at a specific position in a Vue SFC 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)")
+}, async ({ file, line, column }) => {
+  try {
+    const { absPath, error: error2 } = resolveFilePath(file);
+    if (error2 || !absPath) {
+      return { content: [{ type: "text", text: error2 || "Invalid path" }] };
+    }
+    const ranges = await getSelectionRanges(absPath, line, column);
+    if (!ranges.length) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "No selection range found" }) }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ ranges, count: ranges.length }) }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("selectionRange")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose selection_range in this environment.",
+            next_step: "Use read_file_with_hints/symbols and explicit ranges as fallback.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("folding_range", "Get foldable ranges in 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 ranges = await getFoldingRanges(absPath);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ ranges, count: ranges.length }) }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("foldingRange")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose folding_range in this environment.",
+            next_step: "Use symbols-based sections for manual folding.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
+server.tool("document_link", "Extract links (imports/URLs) from 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 links = await getDocumentLinks(absPath);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ links, count: links.length }) }]
+    };
+  } catch (error2) {
+    const message = String(error2);
+    if (message.includes("Method not found") || message.includes("documentLink")) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: "NOT_IMPLEMENTED",
+            error_code: "NOT_IMPLEMENTED",
+            message: "Vue backend does not expose document_link in this environment.",
+            next_step: "Use search over import/url patterns as fallback.",
+            install_commands: [],
+            missing_packages: [],
+            strict_mode: true
+          })
+        }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: message }) }]
+    };
+  }
+});
 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)
@@ -20931,8 +22015,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,
@@ -20973,10 +22057,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",