moai-adk 0.8.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/lsp/client.py

@@ -0,0 +1,320 @@
+# MoAI LSP Client
+"""LSP client interface for MoAI-ADK.
+
+This module provides the main LSP client interface for getting diagnostics,
+finding references, renaming symbols, and other LSP operations.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from moai_adk.lsp.models import (
+    Diagnostic,
+    DiagnosticSeverity,
+    HoverInfo,
+    Location,
+    Position,
+    Range,
+    TextEdit,
+    WorkspaceEdit,
+)
+from moai_adk.lsp.server_manager import LSPServerManager
+
+
+class LSPClientError(Exception):
+    """Error raised by the LSP client."""
+
+    pass
+
+
+class MoAILSPClient:
+    """LSP client for MoAI-ADK.
+
+    Provides a high-level interface for LSP operations including:
+    - Getting diagnostics for files
+    - Finding references to symbols
+    - Renaming symbols across the project
+    - Getting hover information
+
+    Attributes:
+        project_root: The root directory of the project.
+        server_manager: Manager for LSP server processes.
+    """
+
+    def __init__(self, project_root: str | Path) -> None:
+        """Initialize the LSP client.
+
+        Args:
+            project_root: Path to the project root directory.
+        """
+        self.project_root = Path(project_root)
+        self.server_manager = LSPServerManager()
+        self._load_config()
+
+    def _load_config(self) -> None:
+        """Load LSP configuration from .lsp.json file."""
+        config_path = self.project_root / ".lsp.json"
+        if config_path.exists():
+            self.server_manager.load_config(config_path)
+
+    # ==========================================================================
+    # Public API
+    # ==========================================================================
+
+    async def get_diagnostics(self, file_path: str) -> list[Diagnostic]:
+        """Get diagnostics for a file.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            List of Diagnostic objects.
+        """
+        raw_diagnostics = await self._request_diagnostics(file_path)
+        return [self._parse_diagnostic(d) for d in raw_diagnostics]
+
+    async def find_references(self, file_path: str, position: Position) -> list[Location]:
+        """Find all references to the symbol at position.
+
+        Args:
+            file_path: Path to the file.
+            position: Position of the symbol.
+
+        Returns:
+            List of Location objects.
+        """
+        raw_refs = await self._request_references(file_path, position)
+        return [self._parse_location(r) for r in raw_refs]
+
+    async def rename_symbol(self, file_path: str, position: Position, new_name: str) -> WorkspaceEdit:
+        """Rename the symbol at position.
+
+        Args:
+            file_path: Path to the file.
+            position: Position of the symbol.
+            new_name: New name for the symbol.
+
+        Returns:
+            WorkspaceEdit with all changes.
+        """
+        raw_edit = await self._request_rename(file_path, position, new_name)
+        return self._parse_workspace_edit(raw_edit)
+
+    async def get_hover_info(self, file_path: str, position: Position) -> HoverInfo | None:
+        """Get hover information for position.
+
+        Args:
+            file_path: Path to the file.
+            position: Position to get hover info for.
+
+        Returns:
+            HoverInfo or None if not available.
+        """
+        raw_hover = await self._request_hover(file_path, position)
+        if raw_hover is None:
+            return None
+        return self._parse_hover_info(raw_hover)
+
+    def get_language_for_file(self, file_path: str) -> str | None:
+        """Get the language for a file.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            Language identifier or None.
+        """
+        return self.server_manager.get_language_for_file(file_path)
+
+    async def ensure_server_running(self, language: str) -> None:
+        """Ensure an LSP server is running for a language.
+
+        Args:
+            language: Language identifier.
+        """
+        await self.server_manager.start_server(language)
+
+    async def cleanup(self) -> None:
+        """Clean up by stopping all servers."""
+        await self.server_manager.stop_all_servers()
+
+    # ==========================================================================
+    # Internal request methods (to be overridden in tests or by subclasses)
+    # ==========================================================================
+
+    async def _request_diagnostics(self, file_path: str) -> list[dict[str, Any]]:
+        """Request diagnostics from the LSP server.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            Raw diagnostic data from server.
+        """
+        # This would normally communicate with the LSP server
+        # For now, return empty list (actual implementation in Phase 2+)
+        return []
+
+    async def _request_references(self, file_path: str, position: Position) -> list[dict[str, Any]]:
+        """Request references from the LSP server.
+
+        Args:
+            file_path: Path to the file.
+            position: Position of the symbol.
+
+        Returns:
+            Raw reference data from server.
+        """
+        return []
+
+    async def _request_rename(self, file_path: str, position: Position, new_name: str) -> dict[str, Any]:
+        """Request rename from the LSP server.
+
+        Args:
+            file_path: Path to the file.
+            position: Position of the symbol.
+            new_name: New name for the symbol.
+
+        Returns:
+            Raw workspace edit data from server.
+        """
+        return {"changes": {}}
+
+    async def _request_hover(self, file_path: str, position: Position) -> dict[str, Any] | None:
+        """Request hover info from the LSP server.
+
+        Args:
+            file_path: Path to the file.
+            position: Position to get hover info for.
+
+        Returns:
+            Raw hover data from server or None.
+        """
+        return None
+
+    # ==========================================================================
+    # Helper methods
+    # ==========================================================================
+
+    def _file_to_uri(self, file_path: str) -> str:
+        """Convert a file path to a file:// URI.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            File URI string.
+        """
+        if not file_path.startswith("/"):
+            file_path = "/" + file_path
+        return f"file://{file_path}"
+
+    def _uri_to_file(self, uri: str) -> str:
+        """Convert a file:// URI to a file path.
+
+        Args:
+            uri: File URI string.
+
+        Returns:
+            File path string.
+        """
+        if uri.startswith("file://"):
+            return uri[7:]
+        return uri
+
+    def _parse_diagnostic(self, raw: dict[str, Any]) -> Diagnostic:
+        """Parse a Diagnostic from raw LSP data.
+
+        Args:
+            raw: Raw diagnostic dictionary from LSP.
+
+        Returns:
+            Diagnostic instance.
+        """
+        range_data = raw["range"]
+        return Diagnostic(
+            range=self._parse_range(range_data),
+            severity=DiagnosticSeverity(raw["severity"]),
+            code=raw.get("code"),
+            source=raw.get("source", ""),
+            message=raw["message"],
+        )
+
+    def _parse_location(self, raw: dict[str, Any]) -> Location:
+        """Parse a Location from raw LSP data.
+
+        Args:
+            raw: Raw location dictionary from LSP.
+
+        Returns:
+            Location instance.
+        """
+        return Location(
+            uri=raw["uri"],
+            range=self._parse_range(raw["range"]),
+        )
+
+    def _parse_range(self, raw: dict[str, Any]) -> Range:
+        """Parse a Range from raw LSP data.
+
+        Args:
+            raw: Raw range dictionary from LSP.
+
+        Returns:
+            Range instance.
+        """
+        return Range(
+            start=Position(
+                line=raw["start"]["line"],
+                character=raw["start"]["character"],
+            ),
+            end=Position(
+                line=raw["end"]["line"],
+                character=raw["end"]["character"],
+            ),
+        )
+
+    def _parse_workspace_edit(self, raw: dict[str, Any]) -> WorkspaceEdit:
+        """Parse a WorkspaceEdit from raw LSP data.
+
+        Args:
+            raw: Raw workspace edit dictionary from LSP.
+
+        Returns:
+            WorkspaceEdit instance.
+        """
+        changes: dict[str, list[TextEdit]] = {}
+
+        raw_changes = raw.get("changes", {})
+        for uri, edits in raw_changes.items():
+            changes[uri] = [
+                TextEdit(
+                    range=self._parse_range(edit["range"]),
+                    new_text=edit["newText"],
+                )
+                for edit in edits
+            ]
+
+        return WorkspaceEdit(changes=changes)
+
+    def _parse_hover_info(self, raw: dict[str, Any]) -> HoverInfo:
+        """Parse HoverInfo from raw LSP data.
+
+        Args:
+            raw: Raw hover dictionary from LSP.
+
+        Returns:
+            HoverInfo instance.
+        """
+        contents = raw.get("contents", "")
+
+        # Handle MarkupContent format
+        if isinstance(contents, dict):
+            contents = contents.get("value", "")
+
+        range_data = raw.get("range")
+        hover_range = self._parse_range(range_data) if range_data else None
+
+        return HoverInfo(contents=contents, range=hover_range)

moai_adk/lsp/models.py

@@ -0,0 +1,261 @@
+# LSP Data Models
+"""LSP (Language Server Protocol) data models.
+
+These dataclasses represent the core LSP types used for communication
+between the client and language servers. All types follow the LSP 3.17
+specification.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import Union
+
+
+class DiagnosticSeverity(IntEnum):
+    """Severity level for diagnostics.
+
+    Values match LSP specification:
+    - ERROR = 1: Reports an error
+    - WARNING = 2: Reports a warning
+    - INFORMATION = 3: Reports an information
+    - HINT = 4: Reports a hint
+    """
+
+    ERROR = 1
+    WARNING = 2
+    INFORMATION = 3
+    HINT = 4
+
+
+@dataclass
+class Position:
+    """A position in a text document.
+
+    Position in a text document expressed as zero-based line and
+    zero-based character offset. A position is between two characters
+    like an 'insert' cursor in an editor.
+
+    Attributes:
+        line: Line position in a document (zero-based).
+        character: Character offset on a line in a document (zero-based).
+    """
+
+    line: int
+    character: int
+
+
+@dataclass
+class Range:
+    """A range in a text document.
+
+    A range in a text document expressed as start and end positions.
+    A range is comparable to a selection in an editor.
+
+    Attributes:
+        start: The range's start position (inclusive).
+        end: The range's end position (exclusive).
+    """
+
+    start: Position
+    end: Position
+
+    def contains(self, position: Position) -> bool:
+        """Check if a position is within this range.
+
+        Args:
+            position: The position to check.
+
+        Returns:
+            True if the position is within the range, False otherwise.
+        """
+        # Check if position is on the same line for single-line ranges
+        if self.start.line == self.end.line:
+            return position.line == self.start.line and self.start.character <= position.character <= self.end.character
+
+        # Multi-line range check
+        if position.line < self.start.line or position.line > self.end.line:
+            return False
+
+        if position.line == self.start.line:
+            return position.character >= self.start.character
+
+        if position.line == self.end.line:
+            return position.character <= self.end.character
+
+        return True
+
+    def is_single_line(self) -> bool:
+        """Check if the range spans only a single line.
+
+        Returns:
+            True if start and end are on the same line.
+        """
+        return self.start.line == self.end.line
+
+
+@dataclass
+class Location:
+    """A location inside a resource.
+
+    Represents a location inside a resource, such as a line inside a
+    text file.
+
+    Attributes:
+        uri: The resource URI (e.g., file:///path/to/file.py).
+        range: The range within the resource.
+    """
+
+    uri: str
+    range: Range
+
+
+@dataclass
+class Diagnostic:
+    """A diagnostic representing an issue in source code.
+
+    Represents a diagnostic, such as a compiler error or warning.
+    Diagnostic objects are only valid in the scope of a resource.
+
+    Attributes:
+        range: The range at which the message applies.
+        severity: The diagnostic's severity.
+        code: The diagnostic's code (can be string, int, or None).
+        source: The diagnostic's source (e.g., 'pyright', 'mypy').
+        message: The diagnostic's message.
+    """
+
+    range: Range
+    severity: DiagnosticSeverity
+    code: Union[str, int, None]
+    source: str
+    message: str
+
+    def is_error(self) -> bool:
+        """Check if this diagnostic is an error.
+
+        Returns:
+            True if severity is ERROR, False otherwise.
+        """
+        return self.severity == DiagnosticSeverity.ERROR
+
+
+@dataclass
+class TextDocumentIdentifier:
+    """Identifies a text document using a URI.
+
+    Text documents are identified using a URI. On the protocol level,
+    URIs are passed as strings.
+
+    Attributes:
+        uri: The text document's URI (e.g., file:///path/to/file.py).
+    """
+
+    uri: str
+
+    @classmethod
+    def from_path(cls, file_path: str) -> TextDocumentIdentifier:
+        """Create a TextDocumentIdentifier from a file path.
+
+        Args:
+            file_path: The file path (absolute or relative).
+
+        Returns:
+            A TextDocumentIdentifier with a file:// URI.
+        """
+        # Ensure the path starts with /
+        if not file_path.startswith("/"):
+            file_path = "/" + file_path
+        return cls(uri=f"file://{file_path}")
+
+
+@dataclass
+class TextDocumentPositionParams:
+    """Parameters for text document position requests.
+
+    A parameter literal used in requests to pass a text document
+    and a position inside that document.
+
+    Attributes:
+        text_document: The text document.
+        position: The position inside the text document.
+    """
+
+    text_document: TextDocumentIdentifier
+    position: Position
+
+
+@dataclass
+class TextEdit:
+    """A text edit applicable to a text document.
+
+    A textual edit applicable to a text document.
+
+    Attributes:
+        range: The range of the text document to be manipulated.
+        new_text: The string to be inserted. Empty for delete operations.
+    """
+
+    range: Range
+    new_text: str
+
+    def is_delete(self) -> bool:
+        """Check if this edit represents a deletion.
+
+        Returns:
+            True if new_text is empty (deletion), False otherwise.
+        """
+        return self.new_text == ""
+
+    def is_insert(self) -> bool:
+        """Check if this edit represents an insertion.
+
+        An insertion is when the range is zero-width (start == end)
+        and new_text is non-empty.
+
+        Returns:
+            True if this is an insertion, False otherwise.
+        """
+        return (
+            self.range.start.line == self.range.end.line
+            and self.range.start.character == self.range.end.character
+            and self.new_text != ""
+        )
+
+
+@dataclass
+class WorkspaceEdit:
+    """A workspace edit represents changes to many resources.
+
+    A workspace edit represents changes to many resources managed
+    in the workspace. The edit should be applied atomically.
+
+    Attributes:
+        changes: Holds changes to existing resources, keyed by URI.
+    """
+
+    changes: dict[str, list[TextEdit]] = field(default_factory=dict)
+
+    def file_count(self) -> int:
+        """Get the number of files affected by this edit.
+
+        Returns:
+            The number of unique file URIs in the changes.
+        """
+        return len(self.changes)
+
+
+@dataclass
+class HoverInfo:
+    """Hover information for a symbol.
+
+    The result of a hover request.
+
+    Attributes:
+        contents: The hover's content (can be markdown).
+        range: Optional range for the symbol being hovered.
+    """
+
+    contents: str
+    range: Range | None = None