@treedy/lsp-mcp 0.1.10 → 0.2.1

package/dist/index.js

@@ -19839,6 +19839,7 @@ class StdioServerTransport {
 import { createRequire as createRequire2 } from "module";
 import * as fs2 from "fs";
 import * as path2 from "path";
+import { execSync } from "child_process";
 
 // src/config.ts
 import * as path from "path";
@@ -19958,6 +19959,33 @@ function getEnvString(name, defaultValue) {
   return process.env[name] ?? defaultValue;
 }
 function inferLanguageFromPath(filePath, config2) {
+  if (fs.existsSync(filePath)) {
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.isDirectory()) {
+        if (config2.languages.typescript?.enabled && (fs.existsSync(path.join(filePath, "tsconfig.json")) || fs.existsSync(path.join(filePath, "package.json")))) {
+          return "typescript";
+        }
+        if (config2.languages.python?.enabled && (fs.existsSync(path.join(filePath, "pyproject.toml")) || fs.existsSync(path.join(filePath, "requirements.txt")) || fs.existsSync(path.join(filePath, "setup.py")) || fs.existsSync(path.join(filePath, "venv")) || fs.existsSync(path.join(filePath, ".venv")))) {
+          return "python";
+        }
+        if (config2.languages.vue?.enabled && (fs.existsSync(path.join(filePath, "vite.config.ts")) || fs.existsSync(path.join(filePath, "vue.config.js")))) {
+          return "vue";
+        }
+        try {
+          const entries = fs.readdirSync(filePath);
+          for (const entry of entries) {
+            if (entry.endsWith(".ts") && config2.languages.typescript?.enabled)
+              return "typescript";
+            if (entry.endsWith(".py") && config2.languages.python?.enabled)
+              return "python";
+            if (entry.endsWith(".vue") && config2.languages.vue?.enabled)
+              return "vue";
+          }
+        } catch {}
+      }
+    } catch (e) {}
+  }
   const ext = filePath.substring(filePath.lastIndexOf("."));
   for (const [lang, langConfig] of Object.entries(config2.languages)) {
     if (langConfig?.enabled && langConfig.extensions.includes(ext)) {
@@ -21539,6 +21567,18 @@ Analyze Python and TypeScript code for structure, types, and errors.
 
 ## Tools
 
+### project_structure
+
+Get a visual tree structure of the project, highlighting key files.
+
+\`\`\`
+project_structure(path=None)
+\`\`\`
+
+**Use when:**
+- Starting a new task to understand project layout
+- Finding entry points (main.py, package.json)
+
 ### symbols
 
 Extract all symbols (classes, functions, variables) from a file.
@@ -21565,6 +21605,18 @@ diagnostics(path)
 - Validating refactoring didn't break anything
 - Finding issues before running tests
 
+### git_diagnostics
+
+Check for errors ONLY in files changed in Git (working tree + staged).
+
+\`\`\`
+git_diagnostics()
+\`\`\`
+
+**Use when:**
+- Fast feedback loop after editing code
+- "Did I break anything I just touched?"
+
 ### search
 
 Search for patterns across the codebase using regex. Returns positions in LSP format (file, line, column).
@@ -21782,7 +21834,7 @@ function registerPrompts(server) {
         text: `Please explore the project at '${path2 || "current workspace"}'.
 
 Recommended Workflow:
-1. List files to understand the directory structure (use 'ls' or 'glob').
+1. Use 'project_structure' to visualize the directory hierarchy and identify key files.
 2. Identify key entry points (e.g., main.py, index.ts, App.vue, pyproject.toml, package.json).
 3. Use 'summarize_file' on these entry points to extract high-level symbols (classes/functions) without reading full content.
 4. Report back with a structural summary of the project.`
@@ -21802,7 +21854,7 @@ Recommended Workflow:
         text: `Please debug and analyze the file '${file}'.
 
 Recommended Workflow:
-1. Run 'diagnostics' on the file to identify syntax errors, type mismatches, or unused imports.
+1. Run 'diagnostics' on the file (or 'git_diagnostics' to check recent changes) to identify syntax errors, type mismatches, or unused imports.
 2. Use 'read_file_with_hints' to read the content. This will reveal inferred types and parameter names, making it easier to spot logic errors.
 3. If errors are found, check specific locations with 'code_action' to see if auto-fixes (like 'Organize Imports') are available.
 4. Explain the findings and propose fixes.`
@@ -21824,6 +21876,8 @@ Recommended Workflow:
 ### 1. Smart Exploration
 Instead of reading raw code, use:
 \`\`\`
+project_structure() → See file hierarchy
+workspace_symbol("User") → Find where "User" class is
 summarize_file(file) → Get outline of classes/functions
 read_file_with_hints(file) → Read code with type/param annotations
 \`\`\`
@@ -21831,14 +21885,15 @@ read_file_with_hints(file) → Read code with type/param annotations
 ### 2. Search → LSP Tools
 \`\`\`
 search("ClassName") → get positions
+peek_definition(file, line, col) → See definition code immediately
 hover(file, line, column) → get type info
-definition(...) → jump to definition
 references(...) → find usages
 \`\`\`
 
 ### 3. Debug & Fix
 \`\`\`
-diagnostics(path) → Check for errors
+git_diagnostics() → Check errors in changed files
+diagnostics(path) → Check full path
 code_action(file, line, col) → Get quick fixes (e.g. Organize Imports)
 run_code_action(...) → Apply fix
 \`\`\`
@@ -21865,6 +21920,106 @@ var server = new McpServer({
   version: packageJson.version
 });
 registerPrompts(server);
+function getProjectStructure(dirPath, depth = 0, maxDepth = 3) {
+  const IGNORED_DIRS = new Set([".git", "node_modules", "dist", "build", "coverage", "__pycache__", ".venv", ".idea", ".vscode", ".next", ".nuxt"]);
+  const KEY_FILES = new Set(["package.json", "tsconfig.json", "pyproject.toml", "requirements.txt", "README.md", "Dockerfile", "docker-compose.yml", "cargo.toml", "go.mod", "gemfile"]);
+  if (depth > maxDepth)
+    return "";
+  let output = "";
+  let entries;
+  try {
+    entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+  } catch (e) {
+    return "";
+  }
+  entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory())
+      return -1;
+    if (!a.isDirectory() && b.isDirectory())
+      return 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    if (IGNORED_DIRS.has(entry.name))
+      continue;
+    const isDir = entry.isDirectory();
+    const indent = "  ".repeat(depth);
+    const marker = isDir ? "\uD83D\uDCC1 " : "\uD83D\uDCC4 ";
+    const isKeyFile = KEY_FILES.has(entry.name.toLowerCase());
+    const extra = isKeyFile ? " (config)" : "";
+    output += `${indent}${marker}${entry.name}${extra}
+`;
+    if (isDir) {
+      output += getProjectStructure(path2.join(dirPath, entry.name), depth + 1, maxDepth);
+    }
+  }
+  return output;
+}
+function getGitChangedFiles(cwd) {
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const files = new Set;
+    try {
+      const stdout = execSync("git diff --name-only", { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      stdout.split(`
+`).forEach((f) => {
+        if (f.trim())
+          files.add(path2.resolve(gitRoot, f.trim()));
+      });
+    } catch (e) {}
+    try {
+      const stdout = execSync("git diff --staged --name-only", { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      stdout.split(`
+`).forEach((f) => {
+        if (f.trim())
+          files.add(path2.resolve(gitRoot, f.trim()));
+      });
+    } catch (e) {}
+    return Array.from(files);
+  } catch (error2) {
+    return [];
+  }
+}
+function validateAndFixPosition(filePath, line, column) {
+  try {
+    if (!fs2.existsSync(filePath))
+      return { line, column };
+    const stats = fs2.statSync(filePath);
+    if (stats.size > 1024 * 1024)
+      return { line, column };
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    let newLine = line;
+    let warning = "";
+    if (newLine > lines.length) {
+      newLine = lines.length;
+      warning = `Line ${line} out of bounds (max ${lines.length}). Clamped to ${newLine}.`;
+    }
+    if (newLine < 1) {
+      newLine = 1;
+      warning = `Line ${line} must be positive. Clamped to 1.`;
+    }
+    const lineContent = lines[newLine - 1] || "";
+    let newColumn = column;
+    const maxCol = lineContent.length + 1;
+    if (newColumn > maxCol) {
+      newColumn = maxCol;
+      const w = `Column ${column} out of bounds (max ${maxCol}). Clamped to ${newColumn}.`;
+      warning = warning ? `${warning} ${w}` : w;
+    }
+    if (newColumn < 1) {
+      newColumn = 1;
+      const w = `Column ${column} must be positive. Clamped to 1.`;
+      warning = warning ? `${warning} ${w}` : w;
+    }
+    return { line: newLine, column: newColumn, warning: warning || undefined };
+  } catch (e) {
+    return { line, column };
+  }
+}
 async function startAndRegisterBackend(language) {
   if (startedBackends.has(language)) {
     const status2 = backendManager.getStatus()[language];
@@ -21926,7 +22081,11 @@ var UNIFIED_TOOLS = [
   { name: "summarize_file", description: "Get a high-level outline of a file (classes, functions, methods) to understand its structure without reading the full content.", schema: { file: exports_external.string() } },
   { name: "read_file_with_hints", description: "Read file content with inlay hints (type annotations, parameter names) inserted as comments. Useful for understanding complex code.", schema: { file: exports_external.string() } },
   { name: "code_action", description: "Get available code actions (refactors and quick fixes) at a specific position", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
-  { name: "run_code_action", description: "Apply a code action (refactor or quick fix)", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), kind: exports_external.enum(["refactor", "quickfix"]), name: exports_external.string(), actionName: exports_external.string().optional(), preview: exports_external.boolean().default(false).optional() } }
+  { name: "run_code_action", description: "Apply a code action (refactor or quick fix)", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive(), kind: exports_external.enum(["refactor", "quickfix"]), name: exports_external.string(), actionName: exports_external.string().optional(), preview: exports_external.boolean().default(false).optional() } },
+  { name: "workspace_symbol", description: "Search for a symbol (class, function, etc.) across the entire workspace. Returns locations that can be used with peek_definition.", schema: { query: exports_external.string() } },
+  { name: "peek_definition", description: "Go to definition and return the surrounding code context immediately. Reduces round-trips compared to definition() + read_file().", schema: { file: exports_external.string(), line: exports_external.number().int().positive(), column: exports_external.number().int().positive() } },
+  { name: "project_structure", description: "Get a visual tree structure of the project to understand hierarchy and identify key files. Ignores build artifacts.", schema: { path: exports_external.string().optional() } },
+  { name: "git_diagnostics", description: "Check for errors/warnings ONLY in files changed in Git (working tree + staged). Useful for checking your changes.", schema: {} }
 ];
 function applyInlayHints(content, hints, language) {
   const lines = content.split(`
@@ -22044,30 +22203,131 @@ function preRegisterTools() {
       description: `${tool.description} (unified tool, routes automatically by file extension)`,
       inputSchema: tool.schema
     }, async (args) => {
+      let paramWarning;
+      if (typeof args.line === "number" && typeof args.column === "number") {
+        const targetFile = args.file || args.path;
+        if (targetFile) {
+          let checkPath = targetFile;
+          if (!path2.isAbsolute(checkPath) && activeWorkspacePath) {
+            checkPath = path2.join(activeWorkspacePath, checkPath);
+          } else if (!path2.isAbsolute(checkPath)) {
+            checkPath = path2.resolve(checkPath);
+          }
+          const fixed = validateAndFixPosition(checkPath, args.line, args.column);
+          if (fixed.warning) {
+            console.error(`[lsp-mcp] Auto-corrected params for ${tool.name}: ${fixed.warning}`);
+            args.line = fixed.line;
+            args.column = fixed.column;
+            paramWarning = `(Auto-corrected: ${fixed.warning})`;
+          }
+        }
+      }
+      if (tool.name === "project_structure") {
+        const targetPath = args.path || activeWorkspacePath || process.cwd();
+        const tree = getProjectStructure(targetPath);
+        return {
+          content: [{ type: "text", text: `Project Structure for ${targetPath}:
+
+${tree}` }]
+        };
+      }
+      if (tool.name === "git_diagnostics") {
+        const cwd = activeWorkspacePath || process.cwd();
+        const changedFiles = getGitChangedFiles(cwd);
+        if (changedFiles.length === 0) {
+          return { content: [{ type: "text", text: "No changed files found in git." }] };
+        }
+        const results = [];
+        for (const file of changedFiles) {
+          const language2 = inferLanguageFromPath(file, config2);
+          if (!language2)
+            continue;
+          if (!startedBackends.has(language2)) {
+            try {
+              await backendManager.getBackend(language2);
+              startedBackends.add(language2);
+            } catch (e) {
+              results.push(`Could not check ${path2.basename(file)}: Backend failed to start`);
+              continue;
+            }
+          }
+          try {
+            const relativePath = path2.relative(cwd, file);
+            const res = await backendManager.callTool(language2, "diagnostics", { path: relativePath });
+            const parsed = JSON.parse(res.content[0].text);
+            if (parsed.error) {
+              results.push(`⚠️ ${path2.basename(file)}: Backend error: ${parsed.error}`);
+              continue;
+            }
+            let diagnostics = [];
+            if (Array.isArray(parsed))
+              diagnostics = parsed;
+            else if (parsed.diagnostics && Array.isArray(parsed.diagnostics))
+              diagnostics = parsed.diagnostics;
+            else {
+              console.error(`[lsp-mcp] Unexpected diagnostics format for ${file}:`, parsed);
+              results.push(`⚠️ ${path2.basename(file)}: Unexpected response format`);
+              continue;
+            }
+            if (diagnostics.length === 0) {
+              results.push(`✅ ${path2.basename(file)}: No errors`);
+            } else {
+              const errors4 = diagnostics.map((d) => `  - [Line ${d.range?.start?.line ?? d.line ?? "?"}] ${d.message}`).join(`
+`);
+              results.push(`❌ ${path2.basename(file)}:
+${errors4}`);
+            }
+          } catch (e) {
+            results.push(`⚠️ ${path2.basename(file)}: Check failed (${e})`);
+          }
+        }
+        return { content: [{ type: "text", text: `Git Diagnostics Report:
+
+${results.join(`
+
+`)}` }] };
+      }
       const filePath = args.file || args.path;
-      if (tool.name === "search" && !filePath) {
+      if ((tool.name === "search" || tool.name === "workspace_symbol") && !filePath) {
         const languages = Object.keys(config2.languages).filter((lang) => config2.languages[lang].enabled);
         const results = [];
         for (const lang of languages) {
           if (startedBackends.has(lang)) {
             try {
-              const res = await backendManager.callTool(lang, "search", args);
-              results.push(JSON.parse(res.content[0].text));
+              const res = await backendManager.callTool(lang, tool.name, args);
+              const parsed = JSON.parse(res.content[0].text);
+              let items = [];
+              if (Array.isArray(parsed))
+                items = parsed;
+              else if (parsed.matches)
+                items = parsed.matches;
+              else if (parsed.symbols)
+                items = parsed.symbols;
+              if (items.length > 0) {
+                results.push(...items.map((i) => ({ ...i, language: lang })));
+              }
             } catch (e) {}
           }
         }
         if (results.length === 0) {
-          return { content: [{ type: "text", text: JSON.stringify({ matches: [], count: 0, message: "No active backends to search in. Please specify a file path to auto-start a backend." }) }] };
+          return { content: [{ type: "text", text: JSON.stringify({ matches: [], count: 0, message: "No matches found or no active backends." }) }] };
         }
-        const allMatches = results.flatMap((r) => r.matches || []);
-        return { content: [{ type: "text", text: JSON.stringify({ matches: allMatches, count: allMatches.length }) }] };
+        return { content: [{ type: "text", text: JSON.stringify({ matches: results, count: results.length }) }] };
       }
       if (!filePath) {
         return {
           content: [{ type: "text", text: JSON.stringify({ error: "Missing 'file' or 'path' argument required for unified routing" }) }]
         };
       }
-      const language = inferLanguageFromPath(filePath, config2);
+      let absPath = filePath;
+      if (!path2.isAbsolute(filePath)) {
+        if (activeWorkspacePath) {
+          absPath = path2.join(activeWorkspacePath, filePath);
+        } else {
+          absPath = path2.resolve(filePath);
+        }
+      }
+      const language = inferLanguageFromPath(absPath, config2);
       if (!language) {
         return {
           content: [
@@ -22114,7 +22374,7 @@ function preRegisterTools() {
           };
         }
       }
-      if (tool.name !== "summarize_file" && tool.name !== "read_file_with_hints") {
+      if (tool.name !== "summarize_file" && tool.name !== "read_file_with_hints" && tool.name !== "peek_definition") {
         const availableTools = await backendManager.getTools(language);
         const supportsTool = availableTools.some((t) => t.name === tool.name);
         if (!supportsTool) {
@@ -22155,16 +22415,69 @@ ${summary || "(No symbols found)"}`
           };
         }
       }
+      if (tool.name === "peek_definition") {
+        try {
+          const result = await backendManager.callTool(language, "definition", args);
+          const parsed = JSON.parse(result.content[0].text);
+          if (parsed.error) {
+            return { content: [{ type: "text", text: JSON.stringify(parsed) }] };
+          }
+          let locs = Array.isArray(parsed) ? parsed : [parsed];
+          if (parsed.matches)
+            locs = parsed.matches;
+          if (!locs || locs.length === 0) {
+            return { content: [{ type: "text", text: JSON.stringify({ message: "No definition found" }) }] };
+          }
+          const def = locs[0];
+          const defPath = def.file || def.uri;
+          if (!defPath) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Invalid definition result", raw: parsed }) }] };
+          }
+          let defAbsPath = defPath;
+          if (!path2.isAbsolute(defPath) && activeWorkspacePath) {
+            defAbsPath = path2.join(activeWorkspacePath, defPath);
+          }
+          if (!fs2.existsSync(defAbsPath)) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `Definition file not found: ${defAbsPath}`, location: def }) }] };
+          }
+          const fileContent = fs2.readFileSync(defAbsPath, "utf-8");
+          const lines = fileContent.split(`
+`);
+          const targetLine = def.line;
+          const lineIdx = targetLine - 1;
+          const CONTEXT_LINES = 10;
+          const startIdx = Math.max(0, lineIdx - CONTEXT_LINES);
+          const endIdx = Math.min(lines.length, lineIdx + CONTEXT_LINES + 1);
+          const contextSnippet = lines.slice(startIdx, endIdx).map((line, i) => {
+            const currentLineNum = startIdx + i + 1;
+            const marker = currentLineNum === targetLine ? " >" : "  ";
+            return `${marker} ${currentLineNum.toString().padEnd(4)} | ${line}`;
+          }).join(`
+`);
+          const responseText = `Definition found in ${defPath} at line ${targetLine}:
+
+` + "```" + (language === "python" ? "python" : "typescript") + `
+` + contextSnippet + `
+` + "```";
+          return {
+            content: [{ type: "text", text: responseText }]
+          };
+        } catch (error2) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Failed to peek definition: ${error2}` }) }]
+          };
+        }
+      }
       if (tool.name === "read_file_with_hints") {
         try {
-          let absPath = filePath;
+          let absPath2 = filePath;
           if (!path2.isAbsolute(filePath) && activeWorkspacePath) {
-            absPath = path2.join(activeWorkspacePath, filePath);
+            absPath2 = path2.join(activeWorkspacePath, filePath);
           }
-          if (!fs2.existsSync(absPath)) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `File not found: ${absPath}` }) }] };
+          if (!fs2.existsSync(absPath2)) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `File not found: ${absPath2}` }) }] };
           }
-          const content = fs2.readFileSync(absPath, "utf-8");
+          const content = fs2.readFileSync(absPath2, "utf-8");
           const result = await backendManager.callTool(language, "inlay_hints", args);
           const parsed = JSON.parse(result.content[0].text);
           if (parsed.error) {
@@ -22275,4 +22588,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=4446D59062B5AFD964756E2164756E21
+//# debugId=CC41A27AB80DC0BB64756E2164756E21