@treedy/lsp-mcp 0.1.7 → 0.1.8

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

@@ -0,0 +1,147 @@
+"""Pyright client wrapper for running Pyright CLI commands."""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+
+class PyrightClient:
+    """Runs Pyright CLI for diagnostics and analysis."""
+
+    def __init__(self):
+        self._pyright_path: Optional[str] = None
+        self._check_pyright()
+
+    def _check_pyright(self) -> None:
+        """Check if Pyright is available."""
+        try:
+            result = subprocess.run(
+                ["pyright", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                self._pyright_path = "pyright"
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            # Try npx
+            try:
+                result = subprocess.run(
+                    ["npx", "pyright", "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                )
+                if result.returncode == 0:
+                    self._pyright_path = "npx pyright"
+            except (FileNotFoundError, subprocess.TimeoutExpired):
+                pass
+
+    @property
+    def is_available(self) -> bool:
+        """Check if Pyright is available."""
+        return self._pyright_path is not None
+
+    def get_version(self) -> Optional[str]:
+        """Get Pyright version."""
+        if not self.is_available or self._pyright_path is None:
+            return None
+
+        try:
+            cmd = self._pyright_path.split() + ["--version"]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            return result.stdout.strip()
+        except Exception:
+            return None
+
+    def get_diagnostics(self, path: str) -> dict:
+        """Get diagnostics for a file or directory.
+
+        Args:
+            path: Path to file or directory
+
+        Returns:
+            Dict containing diagnostics or error
+        """
+        if not self.is_available or self._pyright_path is None:
+            return {
+                "error": "Pyright is not installed. Install with: npm install -g pyright",
+            }
+
+        try:
+            cmd = self._pyright_path.split() + ["--outputjson", path]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=120,
+                cwd=str(Path(path).parent) if Path(path).is_file() else path,
+            )
+
+            # Parse JSON output
+            try:
+                data = json.loads(result.stdout)
+            except json.JSONDecodeError:
+                # Pyright might output non-JSON errors
+                return {
+                    "error": f"Failed to parse Pyright output: {result.stderr or result.stdout}",
+                }
+
+            # Format diagnostics
+            diagnostics = []
+            for diag in data.get("generalDiagnostics", []):
+                diagnostics.append(
+                    {
+                        "file": diag.get("file", ""),
+                        "line": diag.get("range", {}).get("start", {}).get("line", 0)
+                        + 1,
+                        "column": diag.get("range", {})
+                        .get("start", {})
+                        .get("character", 0)
+                        + 1,
+                        "end_line": diag.get("range", {}).get("end", {}).get("line", 0)
+                        + 1,
+                        "end_column": diag.get("range", {})
+                        .get("end", {})
+                        .get("character", 0)
+                        + 1,
+                        "severity": diag.get("severity", "error"),
+                        "message": diag.get("message", ""),
+                        "rule": diag.get("rule", ""),
+                    }
+                )
+
+            summary = data.get("summary", {})
+            return {
+                "diagnostics": diagnostics,
+                "summary": {
+                    "files_analyzed": summary.get("filesAnalyzed", 0),
+                    "errors": summary.get("errorCount", 0),
+                    "warnings": summary.get("warningCount", 0),
+                    "informations": summary.get("informationCount", 0),
+                },
+                "version": data.get("version", ""),
+            }
+
+        except subprocess.TimeoutExpired:
+            return {"error": "Pyright analysis timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+# Global client instance
+_client: Optional[PyrightClient] = None
+
+
+def get_pyright_client() -> PyrightClient:
+    """Get the global PyrightClient instance."""
+    global _client
+    if _client is None:
+        _client = PyrightClient()
+    return _client

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

@@ -0,0 +1,198 @@
+"""Rope client wrapper for managing projects and providing code analysis."""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional, cast
+
+import rope.base.project
+from rope.base.resources import File
+
+from .config import get_python_path_for_workspace
+
+# Environment variable to disable Rope caching (creates .ropeproject in each project)
+# Set to "1" or "true" to disable caching
+DISABLE_CACHE = os.environ.get("PYTHON_LSP_MCP_NO_CACHE", "").lower() in ("1", "true")
+
+
+def _get_site_packages(python_executable: str) -> list[str]:
+    """Get site-packages paths from a Python interpreter.
+
+    Args:
+        python_executable: Path to Python interpreter
+
+    Returns:
+        List of site-packages paths
+    """
+    try:
+        result = subprocess.run(
+            [
+                python_executable,
+                "-c",
+                "import site; print('\\n'.join(site.getsitepackages()))",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            paths = [p.strip() for p in result.stdout.strip().split("\n") if p.strip()]
+            return paths
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+    return []
+
+
+class RopeClient:
+    """Manages Rope projects and provides code analysis operations."""
+
+    def __init__(self):
+        self._projects: dict[str, rope.base.project.Project] = {}
+        self._project_python_paths: dict[str, str] = {}
+
+    def get_project(self, workspace: str) -> rope.base.project.Project:
+        """Get or create a Rope project for the given workspace."""
+        workspace = os.path.abspath(workspace)
+
+        # Get the Python interpreter path for this workspace
+        python_executable = get_python_path_for_workspace(workspace)
+
+        # Check if we need to recreate the project (Python path changed)
+        if workspace in self._projects:
+            if self._project_python_paths.get(workspace) != python_executable:
+                # Python path changed, close old project
+                self._projects[workspace].close()
+                del self._projects[workspace]
+
+        if workspace not in self._projects:
+            # ropefolder=None disables caching, default ".ropeproject" enables it
+            ropefolder = None if DISABLE_CACHE else ".ropeproject"
+            project = rope.base.project.Project(
+                workspace,
+                ropefolder=ropefolder,  # type: ignore[arg-type]
+            )
+
+            # Get site-packages from the Python interpreter and add to python_path
+            site_packages = _get_site_packages(python_executable)
+            if site_packages:
+                project.prefs.set("python_path", site_packages)
+
+            self._projects[workspace] = project
+            self._project_python_paths[workspace] = python_executable
+
+        return self._projects[workspace]
+
+    def get_python_path(self, workspace: str) -> str:
+        """Get the Python path being used for a workspace."""
+        workspace = os.path.abspath(workspace)
+        return self._project_python_paths.get(
+            workspace, get_python_path_for_workspace(workspace)
+        )
+
+    def get_resource(self, project: rope.base.project.Project, file_path: str) -> File:
+        """Get a Rope resource for a file path."""
+        abs_path = os.path.abspath(file_path)
+        project_root = project.root.real_path
+
+        if abs_path.startswith(project_root):
+            rel_path = os.path.relpath(abs_path, project_root)
+        else:
+            rel_path = abs_path
+
+        return cast(File, project.get_resource(rel_path))
+
+    def position_to_offset(self, source: str, line: int, column: int) -> int:
+        """Convert (line, column) to byte offset.
+
+        Args:
+            source: The source code string
+            line: 1-based line number
+            column: 1-based column number
+
+        Returns:
+            0-based byte offset
+        """
+        lines = source.splitlines(keepends=True)
+        offset = 0
+        for i in range(min(line - 1, len(lines))):
+            offset += len(lines[i])
+        offset += column - 1
+        return offset
+
+    def offset_to_position(self, source: str, offset: int) -> tuple[int, int]:
+        """Convert byte offset to (line, column).
+
+        Args:
+            source: The source code string
+            offset: 0-based byte offset
+
+        Returns:
+            Tuple of (1-based line, 1-based column)
+        """
+        lines = source.splitlines(keepends=True)
+        current_offset = 0
+        for i, line_text in enumerate(lines):
+            if current_offset + len(line_text) > offset:
+                return (i + 1, offset - current_offset + 1)
+            current_offset += len(line_text)
+        # Offset is at the end
+        return (len(lines), len(lines[-1]) + 1 if lines else 1)
+
+    def find_workspace_for_file(self, file_path: str) -> str:
+        """Find the workspace root for a given file.
+
+        Looks for common project markers like pyproject.toml, setup.py, .git, etc.
+        Falls back to the file's parent directory.
+        """
+        path = Path(file_path).resolve()
+        markers = [
+            "pyproject.toml",
+            "setup.py",
+            "setup.cfg",
+            ".git",
+            "requirements.txt",
+        ]
+
+        current = path.parent
+        while current != current.parent:
+            for marker in markers:
+                if (current / marker).exists():
+                    return str(current)
+            current = current.parent
+
+        return str(path.parent)
+
+    def close_project(self, workspace: str) -> None:
+        """Close and remove a project from the cache."""
+        workspace = os.path.abspath(workspace)
+        if workspace in self._projects:
+            self._projects[workspace].close()
+            del self._projects[workspace]
+
+    def close_all(self) -> None:
+        """Close all cached projects."""
+        for project in self._projects.values():
+            project.close()
+        self._projects.clear()
+
+    def get_status(self) -> dict:
+        """Get status information about the Rope client."""
+        return {
+            "active_projects": list(self._projects.keys()),
+            "project_count": len(self._projects),
+            "project_python_paths": dict(self._project_python_paths),
+            "caching_enabled": not DISABLE_CACHE,
+            "cache_folder": ".ropeproject" if not DISABLE_CACHE else None,
+        }
+
+
+# Global client instance
+_client: Optional[RopeClient] = None
+
+
+def get_client() -> RopeClient:
+    """Get the global RopeClient instance."""
+    global _client
+    if _client is None:
+        _client = RopeClient()
+    return _client