agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool/diagnostics/lsp_proxy.py

@@ -0,0 +1,41 @@
+"""LSP Proxy - Helper for deploying and managing LSP proxy instances.
+
+The actual proxy script is in lsp_proxy_script.py and is executed as a subprocess.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+# Path to the proxy script
+_PROXY_SCRIPT_PATH = Path(__file__).parent / "lsp_proxy_script.py"
+
+
+class LSPProxy:
+    """Helper class for deploying and managing LSP proxy instances."""
+
+    @staticmethod
+    def get_script_path() -> Path:
+        """Get the path to the proxy script."""
+        return _PROXY_SCRIPT_PATH
+
+    @staticmethod
+    def get_start_command(lsp_command: str, port_file: str) -> list[str]:
+        """Get command to start proxy as a background process.
+
+        Args:
+            lsp_command: The LSP server command (e.g., "pyright-langserver --stdio")
+            port_file: Path for the port file (proxy writes its port here)
+
+        Returns:
+            Command and args for process_manager.start_process()
+        """
+        return [
+            "python",
+            str(_PROXY_SCRIPT_PATH),
+            "--command",
+            lsp_command,
+            "--port-file",
+            port_file,
+        ]

agentpool/diagnostics/lsp_proxy_script.py

@@ -0,0 +1,229 @@
+"""LSP Proxy - Wraps stdio LSP server, exposes via TCP.
+
+This script is executed as a subprocess to proxy between TCP clients
+and a stdio-based LSP server.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import contextlib
+import json
+from pathlib import Path
+import sys
+from typing import Any
+
+
+class LSPProxy:
+    """Proxies between TCP clients and a stdio-based LSP server."""
+
+    def __init__(self, command: list[str], port_file: str):
+        self.command = command
+        self.port_file = port_file
+        self._port_file_path = Path(port_file)
+        self.process: asyncio.subprocess.Process | None = None
+        self.lock = asyncio.Lock()
+        self._request_id = 0
+        self.port: int | None = None
+
+    async def start(self) -> None:
+        """Start the LSP server subprocess."""
+        # Remove existing port file if present
+        if self._port_file_path.exists():
+            self._port_file_path.unlink()
+
+        # Use asyncio subprocess for native async I/O
+        self.process = await asyncio.create_subprocess_exec(
+            *self.command,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+    async def _read_lsp_message(self) -> dict[str, Any] | None:
+        """Read a single JSON-RPC message from LSP server stdout."""
+        if not self.process or not self.process.stdout:
+            return None
+
+        headers = {}
+        while True:
+            line = await self.process.stdout.readline()
+            if not line:
+                return None  # EOF
+            line_str = line.decode().strip()
+            if not line_str:
+                break  # Empty line = end of headers
+            if ": " in line_str:
+                key, value = line_str.split(": ", 1)
+                headers[key] = value
+
+        if "Content-Length" not in headers:
+            return None
+
+        length = int(headers["Content-Length"])
+        body = await self.process.stdout.readexactly(length)
+        result: dict[str, Any] = json.loads(body)
+        return result
+
+    async def _send_to_lsp(self, message: dict[str, Any]) -> None:
+        """Send JSON-RPC message to LSP server."""
+        if not self.process or not self.process.stdin:
+            raise RuntimeError("LSP server not running")
+
+        payload = json.dumps(message)
+        header = f"Content-Length: {len(payload)}\r\n\r\n"
+        self.process.stdin.write((header + payload).encode())
+        await self.process.stdin.drain()
+
+    async def send_request(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Send request to LSP and wait for response."""
+        if not self.process:
+            return {"error": "LSP server not running"}
+
+        async with self.lock:
+            self._request_id += 1
+            msg_id = self._request_id
+            request = {"jsonrpc": "2.0", "id": msg_id, "method": method, "params": params}
+            await self._send_to_lsp(request)
+
+            try:
+                response = await asyncio.wait_for(self._read_lsp_message(), timeout=30.0)
+            except TimeoutError:
+                # Check stderr for error info
+                if self.process.stderr:
+                    try:
+                        err = await asyncio.wait_for(self.process.stderr.read(4096), timeout=0.1)
+                        if err:
+                            return {"error": f"Timeout, stderr: {err.decode()}"}
+                    except TimeoutError:
+                        pass
+                return {"error": "Timeout waiting for LSP response"}
+
+            if response is None:
+                # Check stderr for error info
+                if self.process.stderr:
+                    try:
+                        err = await asyncio.wait_for(self.process.stderr.read(4096), timeout=0.1)
+                        if err:
+                            return {"error": f"LSP error: {err.decode()}"}
+                    except TimeoutError:
+                        pass
+                return {"error": "No response from LSP server"}
+
+            return response
+
+    async def send_notification(self, method: str, params: dict[str, Any]) -> None:
+        """Send notification to LSP (no response expected)."""
+        notification = {"jsonrpc": "2.0", "method": method, "params": params}
+        async with self.lock:
+            await self._send_to_lsp(notification)
+
+    async def handle_client(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """Handle incoming client connection."""
+        try:
+            while True:
+                # Read Content-Length header
+                headers = b""
+                while b"\r\n\r\n" not in headers:
+                    chunk = await reader.read(1)
+                    if not chunk:
+                        return  # Client disconnected
+                    headers += chunk
+
+                # Parse Content-Length
+                header_str = headers.decode()
+                length = None
+                for line in header_str.split("\r\n"):
+                    if line.startswith("Content-Length:"):
+                        length = int(line.split(":")[1].strip())
+                        break
+
+                if length is None:
+                    return
+
+                # Read body
+                body = await reader.read(length)
+                request = json.loads(body)
+
+                # Forward to LSP
+                if "id" in request:
+                    # It's a request, wait for response
+                    response = await self.send_request(request["method"], request.get("params", {}))
+                else:
+                    # It's a notification
+                    await self.send_notification(request["method"], request.get("params", {}))
+                    continue  # No response to send
+
+                # Send response back to client
+                payload = json.dumps(response)
+                header = f"Content-Length: {len(payload)}\r\n\r\n"
+                writer.write(header.encode() + payload.encode())
+                await writer.drain()
+
+        except (ConnectionError, json.JSONDecodeError, UnicodeDecodeError) as e:
+            print(f"Client error: {e}", file=sys.stderr, flush=True)
+        finally:
+            writer.close()
+            await writer.wait_closed()
+
+    async def run(self) -> None:
+        """Start proxy server."""
+        await self.start()
+
+        # Ensure parent directory exists
+        self._port_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Start TCP server on localhost with dynamic port
+        server = await asyncio.start_server(self.handle_client, host="127.0.0.1", port=0)
+
+        # Get the assigned port
+        addr = server.sockets[0].getsockname()
+        self.port = addr[1]
+
+        # Write port to file so clients know where to connect
+        self._port_file_path.write_text(str(self.port))
+
+        # Signal ready by creating a marker file
+        ready_path = Path(str(self.port_file) + ".ready")
+        ready_path.touch()
+
+        print(f"LSP Proxy listening on 127.0.0.1:{self.port}", file=sys.stderr, flush=True)
+
+        async with server:
+            await server.serve_forever()
+
+    async def shutdown(self) -> None:
+        """Shutdown the proxy and LSP server."""
+        if self.process:
+            self.process.terminate()
+            try:
+                await asyncio.wait_for(self.process.wait(), timeout=5)
+            except TimeoutError:
+                self.process.kill()
+
+        # Cleanup files
+        ready_path = Path(str(self.port_file) + ".ready")
+        if self._port_file_path.exists():
+            self._port_file_path.unlink()
+        if ready_path.exists():
+            ready_path.unlink()
+
+
+def main() -> None:
+    """Entry point for the LSP proxy script."""
+    parser = argparse.ArgumentParser(description="LSP Proxy Server")
+    parser.add_argument("--command", required=True, help="LSP server command")
+    parser.add_argument("--port-file", required=True, help="File to write port number to")
+    args = parser.parse_args()
+
+    proxy = LSPProxy(args.command.split(), args.port_file)
+
+    with contextlib.suppress(KeyboardInterrupt):
+        asyncio.run(proxy.run())
+
+
+if __name__ == "__main__":
+    main()

agentpool/diagnostics/models.py

@@ -0,0 +1,398 @@
+"""Data models for diagnostics and LSP operations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypedDict
+
+
+@dataclass
+class Diagnostic:
+    """A single diagnostic message from an LSP server or CLI tool."""
+
+    file: str
+    """File path the diagnostic applies to."""
+
+    line: int
+    """1-based line number."""
+
+    column: int
+    """1-based column number."""
+
+    severity: Literal["error", "warning", "info", "hint"]
+    """Severity level."""
+
+    message: str
+    """Human-readable diagnostic message."""
+
+    source: str
+    """Tool/server that produced this diagnostic (e.g., 'pyright', 'mypy')."""
+
+    code: str | None = None
+    """Optional error code (e.g., 'reportGeneralTypeIssues')."""
+
+    end_line: int | None = None
+    """End line for range diagnostics."""
+
+    end_column: int | None = None
+    """End column for range diagnostics."""
+
+
+@dataclass
+class DiagnosticsResult:
+    """Result of running diagnostics on files."""
+
+    diagnostics: list[Diagnostic] = field(default_factory=list)
+    """List of diagnostics found."""
+
+    success: bool = True
+    """Whether the diagnostic run completed without errors."""
+
+    duration: float = 0.0
+    """Time taken in seconds."""
+
+    error: str | None = None
+    """Error message if success is False."""
+
+    server_id: str | None = None
+    """ID of the server that produced these results."""
+
+    @property
+    def error_count(self) -> int:
+        """Count of error-level diagnostics."""
+        return sum(1 for d in self.diagnostics if d.severity == "error")
+
+    @property
+    def warning_count(self) -> int:
+        """Count of warning-level diagnostics."""
+        return sum(1 for d in self.diagnostics if d.severity == "warning")
+
+
+@dataclass
+class LSPServerState:
+    """State of a running LSP server."""
+
+    server_id: str
+    """Identifier for this server (e.g., 'pyright', 'pylsp')."""
+
+    process_id: str
+    """Process ID from ProcessManager."""
+
+    port: int
+    """TCP port for communication."""
+
+    language: str
+    """Primary language this server handles."""
+
+    root_uri: str | None = None
+    """Workspace root URI."""
+
+    initialized: bool = False
+    """Whether LSP initialize handshake completed."""
+
+    capabilities: dict[str, Any] = field(default_factory=dict)
+    """Server capabilities from initialize response."""
+
+
+@dataclass
+class Position:
+    """A position in a text document (0-based line and character)."""
+
+    line: int
+    """0-based line number."""
+
+    character: int
+    """0-based character offset."""
+
+
+@dataclass
+class Range:
+    """A range in a text document."""
+
+    start: Position
+    """Start position (inclusive)."""
+
+    end: Position
+    """End position (exclusive)."""
+
+
+@dataclass
+class Location:
+    """A location in a resource (file + range)."""
+
+    uri: str
+    """File URI."""
+
+    range: Range
+    """Range within the file."""
+
+
+@dataclass
+class SymbolInfo:
+    """Information about a symbol (function, class, variable, etc.)."""
+
+    name: str
+    """Symbol name."""
+
+    kind: str
+    """Symbol kind (function, class, variable, etc.)."""
+
+    location: Location
+    """Where the symbol is defined."""
+
+    container_name: str | None = None
+    """Name of the containing symbol (e.g., class name for a method)."""
+
+    detail: str | None = None
+    """Additional detail (e.g., type signature)."""
+
+    children: list[SymbolInfo] = field(default_factory=list)
+    """Child symbols (for document symbols with hierarchy)."""
+
+
+@dataclass
+class HoverInfo:
+    """Hover information for a position."""
+
+    contents: str
+    """Hover content (may be markdown)."""
+
+    range: Range | None = None
+    """Range the hover applies to."""
+
+
+@dataclass
+class CompletionItem:
+    """A completion suggestion."""
+
+    label: str
+    """The label shown in completion list."""
+
+    kind: str | None = None
+    """Kind of completion (function, variable, class, etc.)."""
+
+    detail: str | None = None
+    """Detail shown next to label."""
+
+    documentation: str | None = None
+    """Documentation string."""
+
+    insert_text: str | None = None
+    """Text to insert (if different from label)."""
+
+    sort_text: str | None = None
+    """Sort order text."""
+
+
+@dataclass
+class CodeAction:
+    """A code action (quick fix, refactoring, etc.)."""
+
+    title: str
+    """Title of the action."""
+
+    kind: str | None = None
+    """Kind of action (quickfix, refactor, etc.)."""
+
+    diagnostics: list[Diagnostic] = field(default_factory=list)
+    """Diagnostics this action resolves."""
+
+    is_preferred: bool = False
+    """Whether this is the preferred action."""
+
+    edit: dict[str, Any] | None = None
+    """Workspace edit to apply."""
+
+    command: dict[str, Any] | None = None
+    """Command to execute."""
+
+
+@dataclass
+class CallHierarchyItem:
+    """An item in a call hierarchy."""
+
+    name: str
+    """Name of the callable."""
+
+    kind: str
+    """Symbol kind."""
+
+    uri: str
+    """File URI."""
+
+    range: Range
+    """Range of the callable."""
+
+    selection_range: Range
+    """Range to select (usually the name)."""
+
+    detail: str | None = None
+    """Additional detail."""
+
+    data: Any = None
+    """Server-specific data for resolving."""
+
+
+@dataclass
+class CallHierarchyCall:
+    """A call in a call hierarchy."""
+
+    item: CallHierarchyItem
+    """The calling/called item."""
+
+    from_ranges: list[Range] = field(default_factory=list)
+    """Ranges where the call occurs."""
+
+
+@dataclass
+class TypeHierarchyItem:
+    """An item in a type hierarchy."""
+
+    name: str
+    """Name of the type."""
+
+    kind: str
+    """Symbol kind."""
+
+    uri: str
+    """File URI."""
+
+    range: Range
+    """Range of the type."""
+
+    selection_range: Range
+    """Range to select (usually the name)."""
+
+    detail: str | None = None
+    """Additional detail."""
+
+    data: Any = None
+    """Server-specific data for resolving."""
+
+
+@dataclass
+class SignatureInfo:
+    """Signature help information."""
+
+    label: str
+    """The signature label."""
+
+    documentation: str | None = None
+    """Documentation string."""
+
+    parameters: list[dict[str, Any]] = field(default_factory=list)
+    """Parameter information."""
+
+    active_parameter: int | None = None
+    """Index of the active parameter."""
+
+
+@dataclass
+class RenameResult:
+    """Result of a rename operation."""
+
+    changes: dict[str, list[dict[str, Any]]]
+    """Map of file URI to list of text edits."""
+
+    success: bool = True
+    """Whether rename preparation succeeded."""
+
+    error: str | None = None
+    """Error message if failed."""
+
+
+# LSP Hover content types (from LSP spec)
+
+
+class MarkedStringDict(TypedDict):
+    """MarkedString with language identifier (deprecated in LSP 3.0+)."""
+
+    language: str
+    value: str
+
+
+class MarkupContent(TypedDict):
+    """MarkupContent from LSP spec."""
+
+    kind: str  # "plaintext" or "markdown"
+    value: str
+
+
+# Union type for hover contents
+type MarkedString = str | MarkedStringDict
+type HoverContents = str | MarkupContent | MarkedStringDict | list[MarkedString]
+
+
+# Symbol kind mapping from LSP numeric values
+SYMBOL_KIND_MAP: dict[int, str] = {
+    1: "file",
+    2: "module",
+    3: "namespace",
+    4: "package",
+    5: "class",
+    6: "method",
+    7: "property",
+    8: "field",
+    9: "constructor",
+    10: "enum",
+    11: "interface",
+    12: "function",
+    13: "variable",
+    14: "constant",
+    15: "string",
+    16: "number",
+    17: "boolean",
+    18: "array",
+    19: "object",
+    20: "key",
+    21: "null",
+    22: "enum_member",
+    23: "struct",
+    24: "event",
+    25: "operator",
+    26: "type_parameter",
+}
+
+
+# Completion item kind mapping
+COMPLETION_KIND_MAP: dict[int, str] = {
+    1: "text",
+    2: "method",
+    3: "function",
+    4: "constructor",
+    5: "field",
+    6: "variable",
+    7: "class",
+    8: "interface",
+    9: "module",
+    10: "property",
+    11: "unit",
+    12: "value",
+    13: "enum",
+    14: "keyword",
+    15: "snippet",
+    16: "color",
+    17: "file",
+    18: "reference",
+    19: "folder",
+    20: "enum_member",
+    21: "constant",
+    22: "struct",
+    23: "event",
+    24: "operator",
+    25: "type_parameter",
+}
+
+
+# Code action kind mapping
+CODE_ACTION_KIND_MAP: dict[str, str] = {
+    "": "quickfix",
+    "quickfix": "quickfix",
+    "refactor": "refactor",
+    "refactor.extract": "refactor.extract",
+    "refactor.inline": "refactor.inline",
+    "refactor.rewrite": "refactor.rewrite",
+    "source": "source",
+    "source.organizeImports": "source.organize_imports",
+    "source.fixAll": "source.fix_all",
+}

agentpool/functional/run.py

@@ -42,11 +42,14 @@ async def run_agent(
 ) -> Any:
     """Run prompt through agent and return result."""
     async with Agent[Any, str](**kwargs) as agent:
+        # Convert to structured output agent if output_type specified
+        final = agent.to_structured(output_type) if output_type is not None else agent
+
         if image_url:
             image = ImageUrl(url=image_url)
-            result = await agent.run(prompt, image, output_type=output_type)
+            result = await final.run(prompt, image)
         else:
-            result = await agent.run(prompt, output_type=output_type)
+            result = await final.run(prompt)
         return result.content
 
 
@@ -76,5 +79,8 @@ def run_agent_sync(
     **kwargs: Unpack[AgentKwargs],
 ) -> Any:
     """Sync wrapper for run_agent."""
-    coro = run_agent(prompt, image_url, output_type=output_type, **kwargs)  # type: ignore
-    return run_sync(coro)
+
+    async def _run() -> Any:
+        return await run_agent(prompt, image_url, output_type=output_type, **kwargs)  # type: ignore
+
+    return run_sync(_run())