pythonparts-mcp 0.2.0__py3-none-any.whl

server/tools/typecheck.py

@@ -0,0 +1,140 @@
+"""
+Tool: typecheck_file
+
+Runs pyright against a file using the ALLPLAN runtime context and returns
+structured diagnostics.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from ..pyright_config import get_pyright_config_dir, get_python_interpreter
+from . import READ_ONLY_TOOL_ANNOTATIONS
+
+# Pyright severity labels → canonical names
+_SEVERITY_MAP = {
+    "error": "error",
+    "warning": "warning",
+    "information": "info",
+}
+
+
+def _run_pyright(file_path: str, config_dir: Path) -> dict:
+    """Invoke pyright and return its parsed JSON output."""
+    result = subprocess.run(
+        [
+            sys.executable, "-m", "pyright",
+            "--outputjson",
+            "--project", str(config_dir),
+            "--pythonpath", get_python_interpreter(),
+            file_path,
+        ],
+        capture_output=True,
+        text=True,
+        stdin=subprocess.DEVNULL,  # prevent inheriting the MCP server's stdin
+        timeout=120,
+    )
+
+    # pyright exits with 1 when diagnostics are found — that is not an error
+    # for us. Only fail if we cannot parse the output at all.
+    # pyright may print warnings before the JSON object; find the first '{'
+    stdout = result.stdout
+    json_start = stdout.find("{")
+    if json_start == -1:
+        raise RuntimeError(
+            f"pyright produced no JSON output (exit {result.returncode}):\n"
+            f"stdout: {stdout}\nstderr: {result.stderr}"
+        )
+    try:
+        return json.loads(stdout[json_start:])
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(
+            f"pyright produced unparseable output (exit {result.returncode}):\n"
+            f"stdout: {stdout}\nstderr: {result.stderr}"
+        ) from exc
+
+
+def _is_false_positive(diagnostic: dict) -> bool:
+    """
+    Return True for known false positives that should be suppressed.
+
+    BuildingElement attributes are populated dynamically from the .pyp file at
+    runtime, so pyright cannot verify them statically. These errors are expected
+    and not actionable.
+    """
+    return (
+        diagnostic.get("rule") == "reportAttributeAccessIssue"
+        and "BuildingElement" in diagnostic.get("message", "")
+    )
+
+
+def _map_diagnostics(raw: dict) -> list[dict]:
+    """Flatten pyright's per-file diagnostic list into a single list, excluding false positives."""
+    diagnostics: list[dict] = []
+    for file_result in raw.get("generalDiagnostics", []):
+        severity = _SEVERITY_MAP.get(file_result.get(
+            "severity", ""), file_result.get("severity", ""))
+        range_ = file_result.get("range", {})
+        start = range_.get("start", {})
+        entry = {
+            "severity": severity,
+            "message": file_result.get("message", ""),
+            "file": file_result.get("file", ""),
+            "line": start.get("line", 0) + 1,  # pyright is 0-based
+            "column": start.get("character", 0) + 1,
+            "rule": file_result.get("rule", ""),
+        }
+        if not _is_false_positive(entry):
+            diagnostics.append(entry)
+    return diagnostics
+
+
+def register_typecheck_tools(mcp: FastMCP) -> None:
+    """Register all type-checking tools on the given FastMCP instance."""
+
+    @mcp.tool(annotations=READ_ONLY_TOOL_ANNOTATIONS)
+    def typecheck_file(file_path: str) -> dict:
+        """
+        Run a full type-check against the given file using the ALLPLAN Python
+        runtime and its bundled .pyi stubs.
+
+        Args:
+            file_path: Absolute path to the Python file to check.
+
+        Returns:
+            ok:                  False only if the tool itself failed (e.g. pyright not found).
+            data.error_count:    Number of errors reported.
+            data.warning_count:  Number of warnings reported.
+            data.diagnostics:    List of diagnostic items, each with severity, message,
+                                 file, line, column, and rule fields.
+        """
+        path = Path(file_path)
+        if not path.is_file():
+            return {
+                "ok": False,
+                "error": f"File not found: {file_path}",
+            }
+
+        config_dir = get_pyright_config_dir()
+
+        try:
+            raw = _run_pyright(file_path, config_dir)
+        except RuntimeError as exc:
+            return {"ok": False, "error": str(exc)}
+
+        diagnostics = _map_diagnostics(raw)
+
+        return {
+            "ok": True,
+            "data": {
+                "error_count": sum(1 for d in diagnostics if d["severity"] == "error"),
+                "warning_count": sum(1 for d in diagnostics if d["severity"] == "warning"),
+                "diagnostics": diagnostics,
+            },
+        }

server/worker.py

@@ -0,0 +1,184 @@
+"""
+Persistent worker subprocesses running under the ALLPLAN-embedded interpreter.
+
+ALLPLAN's Python modules are native extensions that can only be imported by the
+interpreter shipped in ``Prg\\Python``, and loading their DLLs costs seconds. A
+worker is therefore spawned once, on first use, and kept alive for the lifetime
+of the MCP server so that cost is paid only once.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import logging
+import queue
+import subprocess
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+from .config import AllplanConfig, get_config
+from .paths import interpreter_path
+
+_SHUTDOWN_TIMEOUT_SECONDS = 5
+_logger = logging.getLogger(__name__)
+
+
+class WorkerGoneError(RuntimeError):
+    """The worker process died or fell out of sync with the request/response protocol."""
+
+
+class PersistentWorker:
+    """A worker script running under the ALLPLAN interpreter, reused across calls.
+
+    The protocol is one JSON line in, one JSON line out. The first line sent is an
+    init handshake that the worker acknowledges before it accepts any request.
+    """
+
+    def __init__(
+        self,
+        script: Path,
+        build_init_params: Callable[[AllplanConfig], dict],
+        *,
+        init_timeout: float,
+        request_timeout: float,
+    ) -> None:
+        self._script = script
+        self._build_init_params = build_init_params
+        self._init_timeout = init_timeout
+        self._request_timeout = request_timeout
+        self._proc: subprocess.Popen[str] | None = None
+        self._lines: queue.Queue[str | None] = queue.Queue()
+        self._lock = threading.Lock()
+        self._init_data: dict = {}
+        atexit.register(self.shutdown)
+
+    @property
+    def init_data(self) -> dict:
+        """Payload the worker reported in its handshake ack, empty until first use."""
+        return self._init_data
+
+    @property
+    def is_running(self) -> bool:
+        """Whether the subprocess is alive, per ``Popen.poll()``."""
+        return self._proc is not None and self._proc.poll() is None
+
+    def request(self, payload: dict) -> dict:
+
+        """Send one request and return the worker's response, or a structured error.
+
+        Every failure mode leaves the worker dead but the caller alive: the next
+        request spawns a fresh process.
+        """
+        with self._lock:
+            try:
+                proc = self._ensure_running()
+                self._write(proc, payload)
+                return self._read(self._request_timeout)
+            except TimeoutError:
+                self._kill()
+                return {
+                    "ok": False,
+                    "error": f"The worker did not respond within {self._request_timeout:.0f}s "
+                             "and was restarted. A snippet that blocks forever cannot be recovered "
+                             "from — make sure it terminates.",
+                }
+            except (WorkerGoneError, BrokenPipeError, OSError) as exc:
+                self._kill()
+                return {"ok": False, "error": str(exc)}
+
+    def shutdown(self) -> None:
+        """Ask the worker to exit by closing its stdin, then kill it if it lingers."""
+        proc = self._proc
+        if proc is None or proc.poll() is not None:
+            self._proc = None
+            return
+        try:
+            if proc.stdin is not None:
+                proc.stdin.close()
+            proc.wait(timeout=_SHUTDOWN_TIMEOUT_SECONDS)
+        except (OSError, subprocess.TimeoutExpired):
+            proc.kill()
+        finally:
+            self._proc = None
+
+    def _ensure_running(self) -> subprocess.Popen[str]:
+        if self._proc is not None and self._proc.poll() is None:
+            return self._proc
+        self._proc = self._spawn(get_config())
+        return self._proc
+
+    def _spawn(self, cfg: AllplanConfig) -> subprocess.Popen[str]:
+        self._lines = queue.Queue()
+        proc = subprocess.Popen(
+            [str(interpreter_path(cfg.prg)), str(self._script)],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            bufsize=1,
+        )
+        self._proc = proc
+
+        threading.Thread(target=self._pump, args=(proc, self._lines), daemon=True).start()
+
+        self._write(proc, self._build_init_params(cfg))
+        ack = self._read(self._init_timeout)
+        if not ack.get("ok"):
+            proc.kill()
+            raise WorkerGoneError(f"Worker init failed: {ack.get('error', ack)}")
+
+        self._init_data = ack.get("data", {})
+        return proc
+
+    @staticmethod
+    def _pump(proc: subprocess.Popen[str], lines: queue.Queue[str | None]) -> None:
+        """Drain the worker's stdout into a queue so reads can be given a deadline."""
+        assert proc.stdout is not None
+        for line in proc.stdout:
+            lines.put(line)
+        lines.put(None)
+
+    @staticmethod
+    def _write(proc: subprocess.Popen[str], payload: dict) -> None:
+        if proc.stdin is None:
+            raise WorkerGoneError("Worker stdin is not available.")
+        proc.stdin.write(json.dumps(payload) + "\n")
+        proc.stdin.flush()
+
+    def _read(self, timeout: float) -> dict:
+        deadline = time.monotonic() + timeout
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError
+            try:
+                line = self._lines.get(timeout=remaining)
+            except queue.Empty:
+                raise TimeoutError from None
+
+            if line is None:
+                raise WorkerGoneError("The worker exited unexpectedly.")
+
+            # The ALLPLAN DLLs occasionally print standalone log lines to stdout, so
+            # skip anything before the JSON, and skip lines that contain no JSON at all.
+            json_start = line.find("{")
+            if json_start == -1:
+                continue
+            try:
+                return json.loads(line[json_start:])
+            except json.JSONDecodeError as exc:
+                raise WorkerGoneError(f"Malformed worker response: {exc}. Raw: {line[:300]}") from exc
+
+    def _kill(self) -> None:
+        proc = self._proc
+        self._proc = None
+        if proc is not None:
+            try:
+                proc.kill()
+            except OSError:
+                pass