@treedy/vue-lsp-mcp 0.2.1 → 0.2.2

package/dist/index.js

@@ -19666,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)}`;
 }
@@ -19875,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,
@@ -19885,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,
@@ -19914,6 +19941,7 @@ async function getConnection(projectRoot) {
       }
     ]
   });
+  conn.serverCapabilities = initResult?.capabilities || {};
   sendNotification(conn, "initialized", {});
   conn.initialized = true;
   return conn;
@@ -20011,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);
@@ -20034,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);
@@ -20114,6 +20207,29 @@ 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);
@@ -20138,6 +20254,228 @@ async function getInlayHints(filePath) {
     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);
@@ -20687,6 +21025,18 @@ async function getDefinition3(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 { absPath, error: error2 } = resolveFilePath(file);
   if (error2 || !absPath)
@@ -20697,6 +21047,12 @@ async function getReferences3(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 { absPath, error: error2 } = resolveFilePath(file);
   if (error2 || !absPath)
@@ -20717,6 +21073,39 @@ async function getSignatureHelp3(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");
 var server = new McpServer({
@@ -20800,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)"),
@@ -20819,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)"),
@@ -20888,6 +21438,77 @@ server.tool("inlay_hints", "Get inlay hints (type annotations, parameter names)
     };
   }
 });
+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 (absolute or relative to active workspace)")
 }, async ({ path: inputPath }) => {
@@ -21025,6 +21646,150 @@ 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("Path to the .vue file (absolute or relative to active workspace)"),
   line: exports_external.number().int().positive().describe("Line number (1-based)"),
@@ -21071,6 +21836,153 @@ 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 (absolute or relative to active workspace)"),

package/dist/vue-service.d.ts

@@ -75,6 +75,26 @@ export declare function getDefinition(filePath: string, line: number, column: nu
     line: number;
     column: number;
 }>>;
+/**
+ * Get implementation locations
+ */
+export declare function getImplementation(filePath: string, line: number, column: number): Promise<Array<{
+    file: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}>>;
+/**
+ * Get type definition locations
+ */
+export declare function getTypeDefinition(filePath: string, line: number, column: number): Promise<Array<{
+    file: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}>>;
 /**
  * Get all references to a symbol
  */
@@ -83,6 +103,17 @@ export declare function getReferences(filePath: string, line: number, column: nu
     line: number;
     column: number;
 }>>;
+/**
+ * Get document highlights for a symbol
+ */
+export declare function getDocumentHighlights(filePath: string, line: number, column: number): Promise<Array<{
+    file: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+    kind: number;
+}>>;
 /**
  * Get completions at a position
  */
@@ -104,10 +135,82 @@ export declare function getSignatureHelp(filePath: string, line: number, column:
     activeSignature: number;
     activeParameter: number;
 } | null>;
+/**
+ * Check whether rename is valid at this position
+ */
+export declare function getPrepareRename(filePath: string, line: number, column: number): Promise<{
+    canRename: boolean;
+    placeholder?: string;
+    range?: {
+        line: number;
+        column: number;
+        endLine: number;
+        endColumn: number;
+    };
+}>;
 /**
  * Get inlay hints for a file
  */
 export declare function getInlayHints(filePath: string): Promise<any[]>;
+/**
+ * Get semantic tokens for a file and decode to absolute positions.
+ */
+export declare function getSemanticTokens(filePath: string): Promise<{
+    tokens: any[];
+    count: number;
+}>;
+/**
+ * Get nested smart selection ranges for a position.
+ */
+export declare function getSelectionRanges(filePath: string, line: number, column: number): Promise<Array<{
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}>>;
+/**
+ * Get foldable ranges in a file.
+ */
+export declare function getFoldingRanges(filePath: string): Promise<Array<{
+    kind?: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}>>;
+/**
+ * Get document links (imports/URLs).
+ */
+export declare function getDocumentLinks(filePath: string): Promise<Array<{
+    target?: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}>>;
+/**
+ * Get call hierarchy around a symbol.
+ */
+export declare function getCallHierarchy(filePath: string, line: number, column: number, direction?: "incoming" | "outgoing" | "both"): Promise<{
+    items: any[];
+    count: number;
+    direction: "incoming" | "outgoing" | "both";
+}>;
+/**
+ * Get code actions at a position.
+ */
+export declare function getCodeActions(filePath: string, line: number, column: number): Promise<any[]>;
+/**
+ * Execute command from code action.
+ */
+export declare function executeCommand(filePath: string, command: string, args?: any[]): Promise<any>;
+/**
+ * Apply WorkspaceEdit to disk and sync open docs.
+ */
+export declare function applyWorkspaceEdit(edit: any): Promise<{
+    filesChanged: number;
+    editsApplied: number;
+}>;
 /**
  * Diagnostic type for internal use
  */

package/package.json

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