fcp-python 0.1.0__py3-none-any.whl

fcp_python/lsp/client.py

@@ -0,0 +1,196 @@
+"""LSP client implementation."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Any
+
+from .transport import LspWriter, read_loop
+from .types import InitializeResult, JsonRpcNotification, ServerCapabilities
+
+logger = logging.getLogger(__name__)
+
+
+class LspError(Exception):
+    """Error from LSP server."""
+
+    def __init__(self, code: int, message: str) -> None:
+        self.code = code
+        super().__init__(f"LSP error {code}: {message}")
+
+
+class LspClient:
+    """JSON-RPC client for communicating with an LSP server subprocess."""
+
+    def __init__(
+        self,
+        process: asyncio.subprocess.Process,
+        writer: LspWriter,
+        pending: dict[str, asyncio.Future],
+        pending_lock: asyncio.Lock,
+        notification_queue: asyncio.Queue[JsonRpcNotification],
+        read_task: asyncio.Task,
+        server_capabilities: ServerCapabilities | None = None,
+    ) -> None:
+        self._process = process
+        self._writer = writer
+        self._pending = pending
+        self._pending_lock = pending_lock
+        self._notification_queue = notification_queue
+        self._read_task = read_task
+        self._next_id = 1
+        self.server_capabilities = server_capabilities
+
+    @classmethod
+    async def spawn(cls, command: str, args: list[str], root_uri: str) -> LspClient:
+        """Spawn an LSP server process and perform the initialize handshake."""
+        process = await asyncio.create_subprocess_exec(
+            command,
+            *args,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+
+        assert process.stdin is not None
+        assert process.stdout is not None
+
+        writer = LspWriter(process.stdin)
+        pending: dict[str, asyncio.Future] = {}
+        pending_lock = asyncio.Lock()
+        notification_queue: asyncio.Queue[JsonRpcNotification] = asyncio.Queue(maxsize=64)
+
+        reader = process.stdout
+        read_task = asyncio.create_task(
+            read_loop(reader, pending, notification_queue, pending_lock)
+        )
+
+        client = cls(
+            process=process,
+            writer=writer,
+            pending=pending,
+            pending_lock=pending_lock,
+            notification_queue=notification_queue,
+            read_task=read_task,
+        )
+
+        # Initialize handshake
+        caps = await client._initialize(root_uri)
+        client.server_capabilities = caps
+
+        # Send initialized notification
+        await client.notify("initialized", {})
+
+        return client
+
+    async def _initialize(self, root_uri: str) -> ServerCapabilities:
+        params = {
+            "processId": os.getpid(),
+            "rootUri": root_uri,
+            "capabilities": {
+                "textDocument": {
+                    "codeAction": {
+                        "codeActionLiteralSupport": {
+                            "codeActionKind": {
+                                "valueSet": [
+                                    "quickfix",
+                                    "refactor",
+                                    "refactor.extract",
+                                    "refactor.inline",
+                                    "refactor.rewrite",
+                                    "source",
+                                    "source.organizeImports",
+                                ]
+                            }
+                        }
+                    },
+                    "rename": {"prepareSupport": False},
+                },
+                "workspace": {
+                    "applyEdit": True,
+                    "workspaceEdit": {
+                        "documentChanges": True,
+                        "resourceOperations": ["create", "rename", "delete"],
+                    },
+                },
+            },
+        }
+
+        result = await self.request("initialize", params)
+        init_result = InitializeResult.from_dict(result)
+        return init_result.capabilities
+
+    async def request(self, method: str, params: Any) -> Any:
+        """Send a JSON-RPC request and await the response."""
+        req_id = self._next_id
+        self._next_id += 1
+
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future = loop.create_future()
+
+        async with self._pending_lock:
+            self._pending[str(req_id)] = fut
+
+        await self._writer.send_request(req_id, method, params)
+
+        resp = await fut
+
+        if resp.error is not None:
+            raise LspError(resp.error.code, resp.error.message)
+
+        return resp.result
+
+    async def notify(self, method: str, params: Any) -> None:
+        """Send a JSON-RPC notification (no response expected)."""
+        await self._writer.send_notification(method, params)
+
+    async def did_open(self, uri: str, text: str) -> None:
+        """Send textDocument/didOpen notification."""
+        params = {
+            "textDocument": {
+                "uri": uri,
+                "languageId": "python",
+                "version": 1,
+                "text": text,
+            }
+        }
+        await self.notify("textDocument/didOpen", params)
+
+    async def did_change(self, uri: str, version: int, text: str) -> None:
+        """Send textDocument/didChange notification (full sync)."""
+        params = {
+            "textDocument": {"uri": uri, "version": version},
+            "contentChanges": [{"text": text}],
+        }
+        await self.notify("textDocument/didChange", params)
+
+    async def did_close(self, uri: str) -> None:
+        """Send textDocument/didClose notification."""
+        params = {"textDocument": {"uri": uri}}
+        await self.notify("textDocument/didClose", params)
+
+    async def shutdown(self) -> None:
+        """Send shutdown request and exit notification, then wait for process."""
+        try:
+            await self.request("shutdown", None)
+        except Exception:
+            pass
+        try:
+            await self.notify("exit", None)
+        except Exception:
+            pass
+        try:
+            await self._process.wait()
+        except Exception:
+            pass
+        self._read_task.cancel()
+        try:
+            await self._read_task
+        except asyncio.CancelledError:
+            pass
+
+    @property
+    def notification_queue(self) -> asyncio.Queue[JsonRpcNotification]:
+        return self._notification_queue

fcp_python/lsp/lifecycle.py

@@ -0,0 +1,89 @@
+"""LSP server lifecycle manager with crash recovery."""
+
+from __future__ import annotations
+
+import logging
+import time
+from enum import Enum, auto
+
+from .client import LspClient
+
+logger = logging.getLogger(__name__)
+
+
+class ServerStatus(Enum):
+    NotStarted = auto()
+    Starting = auto()
+    Ready = auto()
+    Indexing = auto()
+    Crashed = auto()
+    Stopped = auto()
+
+
+class LifecycleManager:
+    """Manages LSP server lifecycle including crash recovery and document replay."""
+
+    def __init__(
+        self,
+        command: str,
+        args: list[str],
+        root_uri: str,
+        max_restarts: int = 3,
+    ) -> None:
+        self._command = command
+        self._args = args
+        self._root_uri = root_uri
+        self._client: LspClient | None = None
+        self._status = ServerStatus.NotStarted
+        self._restart_count = 0
+        self._max_restarts = max_restarts
+        self._last_restart: float | None = None
+        self._tracked_documents: dict[str, str] = {}
+
+    @property
+    def status(self) -> ServerStatus:
+        return self._status
+
+    async def ensure_client(self) -> LspClient:
+        """Ensure the LSP client is running. Starts or restarts if needed."""
+        if self._client is not None and self._status == ServerStatus.Ready:
+            return self._client
+
+        if self._status == ServerStatus.Crashed and self._restart_count >= self._max_restarts:
+            raise RuntimeError("max restarts exceeded")
+
+        self._status = ServerStatus.Starting
+
+        try:
+            client = await LspClient.spawn(self._command, self._args, self._root_uri)
+            self._client = client
+            self._status = ServerStatus.Ready
+            self._last_restart = time.monotonic()
+
+            # Replay tracked documents
+            for uri, text in list(self._tracked_documents.items()):
+                try:
+                    await client.did_open(uri, text)
+                except Exception:
+                    logger.warning("failed to replay document: %s", uri)
+
+            return client
+        except Exception as e:
+            self._status = ServerStatus.Crashed
+            self._restart_count += 1
+            raise RuntimeError(f"failed to start LSP server: {e}") from e
+
+    def track_document(self, uri: str, text: str) -> None:
+        """Track a document for replay on restart."""
+        self._tracked_documents[uri] = text
+
+    def untrack_document(self, uri: str) -> None:
+        """Untrack a document."""
+        self._tracked_documents.pop(uri, None)
+
+    async def shutdown(self) -> None:
+        """Shutdown the LSP server gracefully."""
+        if self._client is not None:
+            await self._client.shutdown()
+        self._client = None
+        self._status = ServerStatus.Stopped

fcp_python/lsp/transport.py

@@ -0,0 +1,105 @@
+"""Content-Length framed LSP transport."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from .types import JsonRpcNotification, JsonRpcResponse
+
+logger = logging.getLogger(__name__)
+
+
+def encode_message(body: bytes) -> bytes:
+    """Prepend Content-Length header to a message body."""
+    header = f"Content-Length: {len(body)}\r\n\r\n".encode("ascii")
+    return header + body
+
+
+async def decode_message(reader: asyncio.StreamReader) -> dict:
+    """Read a Content-Length framed message and parse as JSON."""
+    content_length: int | None = None
+
+    # Read headers line by line
+    while True:
+        line = await reader.readline()
+        if not line:
+            raise ConnectionError("unexpected EOF reading headers")
+
+        line_str = line.decode("ascii", errors="replace").strip()
+        if not line_str:
+            # Empty line = end of headers
+            break
+
+        if line_str.lower().startswith("content-length:"):
+            value = line_str.split(":", 1)[1].strip()
+            try:
+                content_length = int(value)
+            except ValueError:
+                raise ValueError(f"invalid Content-Length: {value}")
+
+    if content_length is None:
+        raise ValueError("missing Content-Length header")
+
+    body = await reader.readexactly(content_length)
+    return json.loads(body)
+
+
+class LspWriter:
+    """Writer wrapper for sending LSP messages with Content-Length framing."""
+
+    def __init__(self, writer: asyncio.StreamWriter) -> None:
+        self._writer = writer
+        self._lock = asyncio.Lock()
+
+    async def send_request(self, id: Any, method: str, params: Any) -> None:
+        msg = {"jsonrpc": "2.0", "id": id, "method": method, "params": params}
+        body = json.dumps(msg).encode("utf-8")
+        frame = encode_message(body)
+        async with self._lock:
+            self._writer.write(frame)
+            await self._writer.drain()
+
+    async def send_notification(self, method: str, params: Any) -> None:
+        msg = {"jsonrpc": "2.0", "method": method, "params": params}
+        body = json.dumps(msg).encode("utf-8")
+        frame = encode_message(body)
+        async with self._lock:
+            self._writer.write(frame)
+            await self._writer.drain()
+
+
+async def read_loop(
+    reader: asyncio.StreamReader,
+    pending: dict[str, asyncio.Future],
+    notification_queue: asyncio.Queue[JsonRpcNotification],
+    pending_lock: asyncio.Lock,
+) -> None:
+    """Dispatch incoming messages to pending futures or notification queue."""
+    while True:
+        try:
+            msg = await decode_message(reader)
+        except (ConnectionError, asyncio.IncompleteReadError):
+            return  # EOF or read error
+        except Exception:
+            logger.debug("read_loop: error decoding message", exc_info=True)
+            return
+
+        # Response: has "id" and no "method"
+        if "id" in msg and "method" not in msg:
+            resp = JsonRpcResponse.from_dict(msg)
+            id_str = str(resp.id)
+            async with pending_lock:
+                fut = pending.pop(id_str, None)
+            if fut is not None and not fut.done():
+                fut.set_result(resp)
+        elif "method" in msg and "id" not in msg:
+            # Notification
+            notif = JsonRpcNotification.from_dict(msg)
+            try:
+                notification_queue.put_nowait(notif)
+            except asyncio.QueueFull:
+                logger.warning("notification queue full, dropping: %s", notif.method)
+        # Server requests (both id and method) are ignored for now