@treedy/lsp-mcp 0.1.8 → 0.1.10

package/dist/bundled/python/src/rope_mcp/config.py

@@ -22,10 +22,10 @@ class Backend(Enum):
 
 
 # Tools that support both backends
-SHARED_TOOLS = {"hover", "definition", "references", "completions", "symbols"}
+SHARED_TOOLS = {"hover", "definition", "references", "completions", "symbols", "rename"}
 
 # Tools exclusive to each backend
-ROPE_ONLY_TOOLS = {"rename"}  # Rope has better refactoring
+ROPE_ONLY_TOOLS = set()  # Rope has better refactoring (move, change_signature)
 PYRIGHT_ONLY_TOOLS = {"diagnostics", "signature_help"}  # Pyright exclusive
 
 # Environment variable prefix (supports both old and new names)
@@ -37,7 +37,9 @@ class ServerConfig:
     """Configuration for the MCP server."""
 
     # Default backend for shared features
-    default_backend: Backend = Backend.ROPE
+    # Pyright is generally more robust for read operations as it doesn't require
+    # perfect environment setup (like running imports).
+    default_backend: Backend = Backend.PYRIGHT
 
     # Per-tool backend overrides (None = use default)
     tool_backends: dict[str, Backend] = field(default_factory=dict)
@@ -47,7 +49,7 @@ class ServerConfig:
         """Create config from environment variables.
 
         Environment variables (PYTHON_LSP_MCP_ or ROPE_MCP_ prefix):
-            *_BACKEND: Default backend (rope/pyright), default: rope
+            *_BACKEND: Default backend (rope/pyright), default: pyright
             *_HOVER_BACKEND: Backend for hover (rope/pyright)
             *_DEFINITION_BACKEND: Backend for definition
             *_REFERENCES_BACKEND: Backend for references
@@ -63,9 +65,9 @@ class ServerConfig:
                     return val
             return None
 
-        default = get_env("BACKEND") or "rope"
+        default = get_env("BACKEND") or "pyright"
         default_backend = (
-            Backend(default) if default in ["rope", "pyright"] else Backend.ROPE
+            Backend(default) if default in ["rope", "pyright"] else Backend.PYRIGHT
         )
 
         tool_backends = {}
@@ -328,20 +330,43 @@ def is_file_in_workspace(file_path: str) -> bool:
     return abs_file.startswith(_active_workspace)
 
 
-def validate_file_workspace(file_path: str) -> Optional[dict]:
-    """Validate that a file is within the active workspace.
+def resolve_file_path(file_path: str) -> tuple[Optional[str], Optional[dict]]:
+    """Resolve a file path and validate it against the active workspace.
+
+    Supports:
+    1. Absolute paths (must be within active workspace)
+    2. Relative paths (resolved against active workspace)
 
     Args:
-        file_path: Path to the file
+        file_path: Path to the file (absolute or relative)
 
     Returns:
-        Error dict if file is outside workspace, None otherwise.
+        Tuple of (absolute_path, error_dict).
+        If success, absolute_path is set and error_dict is None.
+        If failure, absolute_path is None and error_dict contains the error.
     """
-    if not is_file_in_workspace(file_path):
-        return {
+    path_obj = Path(file_path)
+
+    # Handle relative paths
+    if not path_obj.is_absolute():
+        if _active_workspace:
+            abs_path = os.path.join(_active_workspace, file_path)
+        else:
+            # If no workspace set, we can't resolve relative paths reliably
+            # But for backward compatibility with "no workspace" mode, we might assume cwd
+            abs_path = os.path.abspath(file_path)
+    else:
+        abs_path = str(path_obj)
+
+    # Normalize path
+    abs_path = os.path.abspath(abs_path)
+
+    # Validate against workspace
+    if _active_workspace and not abs_path.startswith(_active_workspace):
+        return None, {
             "error": "Context Mismatch",
             "message": (
-                f"The file '{file_path}' is outside the active workspace '{_active_workspace}'.\n\n"
+                f"The file '{file_path}' resolves to '{abs_path}', which is outside the active workspace '{_active_workspace}'.\n\n"
                 "Current Logic:\n"
                 "1. I only analyze files from the active project to ensure accuracy and save resources.\n"
                 "2. You must explicitly switch the workspace if you want to work on a different project.\n\n"
@@ -349,8 +374,19 @@ def validate_file_workspace(file_path: str) -> Optional[dict]:
                 "Please call 'switch_workspace(path=\"...\")' with the new project root before retrying."
             ),
             "current_workspace": _active_workspace,
+            "resolved_path": abs_path
         }
-    return None
+
+    return abs_path, None
+
+
+def validate_file_workspace(file_path: str) -> Optional[dict]:
+    """Validate that a file is within the active workspace.
+    
+    Deprecated: Use resolve_file_path instead.
+    """
+    _, error = resolve_file_path(file_path)
+    return error
 
 
 def set_python_path(python_path: str, workspace: Optional[str] = None) -> dict:

package/dist/bundled/python/src/rope_mcp/lsp/client.py

@@ -83,16 +83,154 @@ class LspClient:
                 message = json.loads(content.decode())
 
                 # Handle response
-                if "id" in message and message["id"] in self._pending_requests:
-                    req_id = message["id"]
-                    self._responses[req_id] = message
-                    self._pending_requests[req_id].set()
+                if "id" in message:
+                    if "method" in message:
+                        # Server Request
+                        self._handle_server_request(message)
+                    elif message["id"] in self._pending_requests:
+                        # Server Response to our request
+                        req_id = message["id"]
+                        self._responses[req_id] = message
+                        self._pending_requests[req_id].set()
+                elif "method" in message:
+                    # Server Notification
+                    self._handle_server_notification(message)
 
             except Exception:
                 if self._running:
                     continue
                 break
 
+    def _handle_server_notification(self, message: dict) -> None:
+        """Handle a notification from the server."""
+        method = message.get("method")
+        params = message.get("params", {})
+        
+        if method == "textDocument/publishDiagnostics":
+            uri = params.get("uri")
+            diagnostics = params.get("diagnostics", [])
+            
+            # Normalize URI to match our internal map
+            # Pyright might send "file:///path" while we stored "file:///path"
+            # But we need to check if it's in our _documents
+            if uri in self._documents:
+                self._documents[uri].diagnostics = diagnostics
+                # Signal update if someone is waiting
+                if hasattr(self._documents[uri], "update_event"):
+                    self._documents[uri].update_event.set()
+            else:
+                # Try decoding uri if keys don't match exactly
+                path = self._uri_to_path(uri)
+                uri_key = self._path_to_uri(path)
+                if uri_key in self._documents:
+                    self._documents[uri_key].diagnostics = diagnostics
+                    if hasattr(self._documents[uri_key], "update_event"):
+                        self._documents[uri_key].update_event.set()
+
+    def get_diagnostics(self, file_path: str, timeout: float = 3.0) -> dict:
+        """Get diagnostics for a file."""
+        # Force re-open to trigger fresh diagnostics
+        # This ensures we get the latest state including any config changes
+        if self._path_to_uri(file_path) in self._documents:
+            self.close_document(file_path)
+            
+        # Create event before opening
+        uri = self._path_to_uri(file_path)
+        
+        # We need to access _documents but it's created in open_document
+        # So we can't attach event yet.
+        
+        self.open_document(file_path)
+        doc = self._documents.get(uri)
+        if not doc:
+            return {"error": "Failed to open document"}
+            
+        doc.update_event = threading.Event()
+        
+        # Wait for diagnostics
+        doc.update_event.wait(timeout)
+        
+        diags = doc.diagnostics or []
+        
+        formatted = []
+        for d in diags:
+            formatted.append({
+                "file": file_path,
+                "line": d["range"]["start"]["line"] + 1,
+                "column": d["range"]["start"]["character"] + 1,
+                "end_line": d["range"]["end"]["line"] + 1,
+                "end_column": d["range"]["end"]["character"] + 1,
+                "severity": self._severity_to_string(d.get("severity", 1)),
+                "message": d["message"],
+                "code": d.get("code")
+            })
+            
+        return {
+            "diagnostics": formatted,
+            "summary": {
+                "files_analyzed": 1,
+                "errors": len([d for d in formatted if d["severity"] == "error"]),
+                "warnings": len([d for d in formatted if d["severity"] == "warning"]),
+                "informations": len([d for d in formatted if d["severity"] == "information"]),
+            },
+            "backend": "pyright-lsp"
+        }
+
+    def _severity_to_string(self, severity: int) -> str:
+        mapping = {1: "error", 2: "warning", 3: "information", 4: "hint"}
+        return mapping.get(severity, "error")
+
+    def _handle_server_request(self, message: dict) -> None:
+        """Handle a request from the server."""
+        method = message.get("method")
+        req_id = message.get("id")
+        
+        if method == "workspace/configuration":
+            # Pyright asking for config
+            items = message.get("params", {}).get("items", [])
+            result = []
+            analysis_config = {
+                "typeCheckingMode": "basic",
+                "reportUnusedImport": "warning",
+                "reportUnusedVariable": "warning",
+                "autoImportCompletions": True,
+                "autoSearchPaths": True,
+                "useLibraryCodeForTypes": True,
+                "diagnosticMode": "workspace"
+            }
+            
+            for item in items:
+                section = item.get("section")
+                if section == "python.analysis":
+                    result.append(analysis_config)
+                elif section == "python":
+                    result.append({"analysis": analysis_config})
+                else:
+                    # Return analysis config for everything to be safe
+                    result.append(analysis_config)
+            
+            self._send_response(req_id, result)
+            
+        elif method == "client/registerCapability":
+            # Just acknowledge
+            self._send_response(req_id, None)
+
+    def _send_response(self, req_id: Any, result: Any) -> None:
+        """Send a JSON-RPC response."""
+        if not self._process or not self._process.stdin:
+            return
+            
+        message = {"jsonrpc": "2.0", "id": req_id, "result": result}
+        content = json.dumps(message)
+        header = f"Content-Length: {len(content)}\r\n\r\n"
+        
+        try:
+            with self._lock: # Protect stdin write
+                self._process.stdin.write(header.encode() + content.encode())
+                self._process.stdin.flush()
+        except Exception:
+            pass
+
     def _send_message(self, message: dict) -> None:
         """Send a JSON-RPC message to the server."""
         if not self._process or not self._process.stdin:
@@ -170,6 +308,22 @@ class LspClient:
                     "definition": {"linkSupport": True},
                     "references": {},
                     "rename": {"prepareSupport": True},
+                    "codeAction": {
+                        "codeActionLiteralSupport": {
+                            "codeActionKind": {
+                                "valueSet": [
+                                    "quickfix",
+                                    "refactor",
+                                    "refactor.extract",
+                                    "refactor.inline",
+                                    "refactor.rewrite",
+                                    "source",
+                                    "source.organizeImports",
+                                ]
+                            }
+                        }
+                    },
+                    "inlayHint": {"dynamicRegistration": False},
                     "documentSymbol": {"hierarchicalDocumentSymbolSupport": True},
                     "publishDiagnostics": {},
                 },
@@ -181,6 +335,19 @@ class LspClient:
                     "name": Path(self.workspace_root).name,
                 }
             ],
+            "initializationOptions": {
+                "python": {
+                    "analysis": {
+                        # Default to basic mode but enable useful hints
+                        "typeCheckingMode": "basic",
+                        "reportUnusedImport": "warning",
+                        "reportUnusedVariable": "warning",
+                        "autoImportCompletions": True,
+                        "autoSearchPaths": True,
+                        "useLibraryCodeForTypes": True
+                    }
+                }
+            }
         }
 
         self._send_request("initialize", init_params)
@@ -431,6 +598,78 @@ class LspClient:
             )
         return completions
 
+    def inlay_hint(
+        self,
+        file_path: str,
+        start_line: int,
+        start_col: int,
+        end_line: int,
+        end_col: int,
+    ) -> list[dict]:
+        """Get inlay hints for a range."""
+        self.open_document(file_path)
+        uri = self._path_to_uri(file_path)
+
+        params = {
+            "textDocument": {"uri": uri},
+            "range": {
+                "start": {"line": start_line - 1, "character": start_col - 1},
+                "end": {"line": end_line - 1, "character": end_col - 1},
+            },
+        }
+
+        result = self._send_request("textDocument/inlayHint", params)
+
+        if not result:
+            return []
+
+        return result
+
+    def code_action(
+        self,
+        file_path: str,
+        start_line: int,
+        start_col: int,
+        end_line: int,
+        end_col: int,
+        diagnostics: list = None,
+    ) -> list[dict]:
+        """Get available code actions."""
+        self.open_document(file_path)
+        uri = self._path_to_uri(file_path)
+
+        params = {
+            "textDocument": {"uri": uri},
+            "range": {
+                "start": {"line": start_line - 1, "character": start_col - 1},
+                "end": {"line": end_line - 1, "character": end_col - 1},
+            },
+            "context": {"diagnostics": diagnostics or []},
+        }
+
+        result = self._send_request("textDocument/codeAction", params)
+
+        if not result:
+            return []
+
+        return result
+
+    def rename(self, file_path: str, line: int, column: int, new_name: str) -> Optional[dict]:
+        """Rename symbol at position."""
+        self.open_document(file_path)
+        uri = self._path_to_uri(file_path)
+
+        result = self._send_request(
+            "textDocument/rename",
+            {
+                "textDocument": {"uri": uri},
+                "position": {"line": line - 1, "character": column - 1},
+                "newName": new_name,
+            },
+        )
+        
+        return result
+
     def document_symbols(self, file_path: str) -> list[dict]:
         """Get document symbols."""
         self.open_document(file_path)

package/dist/bundled/python/src/rope_mcp/lsp/types.py

@@ -80,3 +80,4 @@ class DocumentState:
     version: int
     content: str
     language_id: str = "python"
+    diagnostics: list = None