rocq-solid-mcp 1.0.0__py3-none-any.whl

rocq_solid_mcp/notifications.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import suppress
+from typing import Any
+
+
+class NotificationStore:
+    def __init__(self) -> None:
+        self._diagnostics: dict[tuple[str, int | None], list[dict[str, Any]]] = {}
+        self._diagnostic_events: dict[tuple[str, int | None], asyncio.Event] = {}
+        self._latest_versions_by_uri: dict[str, int | None] = {}
+        self._file_progress: dict[tuple[str, int | None], dict[str, Any]] = {}
+        self._latest_progress_versions_by_uri: dict[str, int | None] = {}
+        self._file_perf_data: dict[tuple[str, int | None], dict[str, Any]] = {}
+        self._perf_events: dict[tuple[str, int | None], asyncio.Event] = {}
+        self._latest_perf_versions_by_uri: dict[str, int | None] = {}
+        self._execution_info: dict[
+            tuple[str, int | None], tuple[int, dict[str, Any]]
+        ] = {}
+        self._execution_ranges: dict[tuple[str, int | None], list[dict[str, Any]]] = {}
+        self._execution_events: dict[tuple[str, int | None], asyncio.Event] = {}
+        self._execution_sequence = 0
+
+    def handle(self, method: str, params: Any | None) -> None:
+        if method == "textDocument/publishDiagnostics" and isinstance(params, dict):
+            self._handle_publish_diagnostics(params)
+        if method == "$/coq/fileProgress" and isinstance(params, dict):
+            self._handle_file_progress(params)
+        if method == "$/coq/filePerfData" and isinstance(params, dict):
+            self._handle_file_perf_data(params)
+        if method == "$/coq/executionInformation" and isinstance(params, dict):
+            self._handle_execution_info(params)
+
+    def clear(self, uri: str, version: int) -> None:
+        # A session serializes calls for one URI, so starting a new version makes
+        # all notification payloads and waiter events for older versions stale.
+        for mapping in (
+            self._diagnostics,
+            self._diagnostic_events,
+            self._file_progress,
+            self._file_perf_data,
+            self._perf_events,
+            self._execution_info,
+            self._execution_ranges,
+            self._execution_events,
+        ):
+            for key in [key for key in mapping if key[0] == uri]:
+                mapping.pop(key, None)
+        self._latest_versions_by_uri.pop(uri, None)
+        self._latest_progress_versions_by_uri.pop(uri, None)
+        self._latest_perf_versions_by_uri.pop(uri, None)
+
+    def _clear_stale_perf_data(self, uri: str, version: int | None) -> None:
+        for key in list(self._file_perf_data):
+            if key[0] == uri and key[1] != version:
+                self._file_perf_data.pop(key, None)
+                self._perf_events.pop(key, None)
+
+    def _clear_stale_execution_data(self, uri: str, version: int | None) -> None:
+        for key in list(self._execution_info):
+            if key[0] == uri and key[1] != version:
+                self._execution_info.pop(key, None)
+                self._execution_ranges.pop(key, None)
+                self._execution_events.pop(key, None)
+
+    def latest_file_progress(self, uri: str, version: int) -> dict[str, Any] | None:
+        key = (uri, version)
+        if key in self._file_progress:
+            return self._file_progress[key]
+
+        latest = self._latest_progress_versions_by_uri.get(uri)
+        if latest == version:
+            return self._file_progress.get((uri, latest))
+        return self._file_progress.get((uri, None))
+
+    def latest_file_perf_data(self, uri: str, version: int) -> dict[str, Any] | None:
+        key = (uri, version)
+        if key in self._file_perf_data:
+            return self._file_perf_data[key]
+
+        latest = self._latest_perf_versions_by_uri.get(uri)
+        if latest == version:
+            return self._file_perf_data.get((uri, latest))
+        return self._file_perf_data.get((uri, None))
+
+    async def wait_for_file_perf_data(
+        self, uri: str, version: int, settle_seconds: float = 0.25
+    ) -> dict[str, Any] | None:
+        key = (uri, version)
+        if self.latest_file_perf_data(uri, version) is None:
+            event = self._perf_events.setdefault(key, asyncio.Event())
+            with suppress(TimeoutError):
+                await asyncio.wait_for(event.wait(), timeout=settle_seconds)
+        return self.latest_file_perf_data(uri, version)
+
+    def latest_execution_sequence(self, uri: str, version: int) -> int:
+        info = self._execution_info.get((uri, version))
+        return info[0] if info is not None else 0
+
+    def latest_execution_info(self, uri: str, version: int) -> dict[str, Any] | None:
+        info = self._execution_info.get((uri, version))
+        return info[1] if info is not None else None
+
+    def execution_ranges(self, uri: str, version: int) -> list[dict[str, Any]]:
+        ranges = self._execution_ranges.get((uri, version))
+        if ranges is not None:
+            return list(ranges)
+        return list(self._execution_ranges.get((uri, None), []))
+
+    async def wait_for_execution_info(
+        self,
+        uri: str,
+        version: int,
+        *,
+        after_sequence: int,
+        timeout: float | None,
+    ) -> tuple[int, dict[str, Any]] | None:
+        key = (uri, version)
+        event = self._execution_events.setdefault(key, asyncio.Event())
+        while True:
+            event.clear()
+            info = self._execution_info.get(key)
+            if info is not None and info[0] > after_sequence:
+                return info
+            with suppress(TimeoutError):
+                await asyncio.wait_for(event.wait(), timeout=timeout)
+                continue
+            return None
+
+    def has_error_diagnostic(self, uri: str, version: int) -> bool:
+        # Exact-version lookup only: stale errors from a previous document
+        # version must not arm the after-error deadline.
+        diagnostics = self._diagnostics.get((uri, version), [])
+        return any(
+            isinstance(diagnostic, dict) and diagnostic.get("severity") == 1
+            for diagnostic in diagnostics
+        )
+
+    async def wait_for_error_diagnostic(self, uri: str, version: int) -> None:
+        key = (uri, version)
+        event = self._diagnostic_events.setdefault(key, asyncio.Event())
+        while True:
+            event.clear()
+            if self.has_error_diagnostic(uri, version):
+                return
+            await event.wait()
+
+    async def wait_for_diagnostics(
+        self, uri: str, version: int, settle_seconds: float = 0.25
+    ) -> list[dict[str, Any]]:
+        key = (uri, version)
+        if key not in self._diagnostics:
+            event = self._diagnostic_events.setdefault(key, asyncio.Event())
+            with suppress(TimeoutError):
+                await asyncio.wait_for(event.wait(), timeout=settle_seconds)
+
+        if key in self._diagnostics:
+            return self._diagnostics[key]
+
+        latest = self._latest_versions_by_uri.get(uri)
+        if latest == version:
+            return self._diagnostics.get((uri, latest), [])
+        return self._diagnostics.get((uri, None), [])
+
+    def _handle_publish_diagnostics(self, params: dict[str, Any]) -> None:
+        uri = params.get("uri")
+        version = params.get("version")
+        diagnostics = params.get("diagnostics", [])
+        if isinstance(uri, str) and isinstance(diagnostics, list):
+            key = (uri, version)
+            self._diagnostics[key] = diagnostics
+            self._latest_versions_by_uri[uri] = version
+            if event := self._diagnostic_events.get(key):
+                event.set()
+
+    def _handle_file_progress(self, params: dict[str, Any]) -> None:
+        text_document = params.get("textDocument")
+        if not isinstance(text_document, dict):
+            return
+
+        uri = text_document.get("uri")
+        version = text_document.get("version")
+        if not isinstance(uri, str):
+            return
+
+        self._file_progress[(uri, version)] = params
+        self._latest_progress_versions_by_uri[uri] = version
+
+    def _handle_file_perf_data(self, params: dict[str, Any]) -> None:
+        text_document = params.get("textDocument")
+        if not isinstance(text_document, dict):
+            return
+
+        uri = text_document.get("uri")
+        version = text_document.get("version")
+        timings = params.get("timings")
+        if not isinstance(uri, str) or not isinstance(timings, list):
+            return
+
+        key = (uri, version)
+        self._clear_stale_perf_data(uri, version)
+        self._file_perf_data[key] = params
+        self._latest_perf_versions_by_uri[uri] = version
+        if event := self._perf_events.get(key):
+            event.set()
+
+    def _handle_execution_info(self, params: dict[str, Any]) -> None:
+        text_document = params.get("textDocument")
+        if not isinstance(text_document, dict):
+            return
+
+        uri = text_document.get("uri")
+        version = text_document.get("version")
+        range_ = params.get("range")
+        if not isinstance(uri, str) or not isinstance(range_, dict):
+            return
+
+        self._execution_sequence += 1
+        key = (uri, version)
+        self._clear_stale_execution_data(uri, version)
+        self._execution_info[key] = (self._execution_sequence, params)
+        self._execution_ranges.setdefault(key, []).append(range_)
+        if event := self._execution_events.get(key):
+            event.set()

rocq_solid_mcp/pipeline.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .models import Diagnostic, is_empty_value, source_text_for_range
+from .pretty import normalize_proof_state
+
+
+def build_diagnostics(
+    raw: list[dict[str, Any]],
+    document: dict[str, Any] | None,
+    *,
+    content: str | None = None,
+    supplemental_proof_states: dict[str, Any] | None = None,
+) -> list[Diagnostic]:
+    diagnostic_range_keys = {
+        _range_key(_diagnostic_sentence_range(diagnostic)) for diagnostic in raw
+    }
+    proof_states = _proof_states_by_range(document, diagnostic_range_keys)
+    _merge_supplemental_proof_states(proof_states, supplemental_proof_states)
+    diagnostics: list[Diagnostic] = []
+    for diagnostic in raw:
+        sentence_range = _diagnostic_sentence_range(diagnostic)
+        diagnostics.append(
+            Diagnostic.from_lsp(
+                diagnostic,
+                proof_state=proof_states.get(_range_key(sentence_range)),
+                sentence=(
+                    source_text_for_range(content, sentence_range)
+                    if content is not None
+                    else None
+                ),
+            )
+        )
+    return diagnostics
+
+
+def _proof_states_by_range(
+    document: dict[str, Any] | None,
+    wanted_range_keys: set[str],
+) -> dict[str, Any]:
+    if not document:
+        return {}
+    states: dict[str, Any] = {}
+    for span in document.get("spans", []):
+        if not isinstance(span, dict):
+            continue
+        goals = span.get("goals")
+        range_ = span.get("range")
+        if goals is not None and isinstance(range_, dict):
+            key = _range_key(range_)
+            if key not in wanted_range_keys:
+                continue
+            normalized = normalize_proof_state(goals)
+            if not is_empty_value(normalized):
+                states[key] = normalized
+    return states
+
+
+def _merge_supplemental_proof_states(
+    states: dict[str, Any],
+    supplemental: dict[str, Any] | None,
+) -> None:
+    if not supplemental:
+        return
+    for key, proof_state in supplemental.items():
+        normalized = normalize_proof_state(proof_state)
+        if not isinstance(normalized, dict) or is_empty_value(normalized):
+            continue
+        current = states.get(key)
+        if isinstance(current, dict):
+            for field, value in normalized.items():
+                if field not in current and not is_empty_value(value):
+                    current[field] = value
+            continue
+        states[key] = normalized
+
+
+def _diagnostic_sentence_range(diagnostic: Any) -> dict[str, Any]:
+    if not isinstance(diagnostic, dict):
+        return {}
+    data = diagnostic.get("data")
+    if isinstance(data, dict) and isinstance(data.get("sentenceRange"), dict):
+        return data["sentenceRange"]
+    range_ = diagnostic.get("range")
+    return range_ if isinstance(range_, dict) else {}
+
+
+def _range_key(range_: dict[str, Any]) -> str:
+    return json.dumps(range_, sort_keys=True, separators=(",", ":"))

rocq_solid_mcp/pretty.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .models import is_empty_value, pruned_dict
+
+
+def pp_to_text(value: Any) -> str:
+    """Render rocq-lsp's serialized Pp tree into readable plain text."""
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if not isinstance(value, list) or not value:
+        return str(value)
+
+    tag = value[0]
+    if tag == "Pp_empty":
+        return ""
+    if tag == "Pp_string":
+        return str(value[1]) if len(value) > 1 else ""
+    if tag == "Pp_sized_string":
+        return str(value[2]) if len(value) > 2 else ""
+    if tag == "Pp_glue":
+        return "".join(pp_to_text(item) for item in _list_at(value, 1))
+    if tag in {"Pp_box", "Pp_tag"}:
+        return pp_to_text(value[2]) if len(value) > 2 else ""
+    if tag == "Pp_print_break":
+        indent = value[2] if len(value) > 2 and isinstance(value[2], int) else 0
+        return "\n" + (" " * max(indent, 0))
+    if tag == "Pp_force_newline":
+        return "\n"
+    if tag == "Pp_comment":
+        return "\n".join(str(item) for item in _list_at(value, 1))
+    return str(value)
+
+
+def normalize_proof_state(value: Any) -> Any:
+    """Turn rocq-lsp goal answers into agent-facing JSON."""
+    if _is_pp(value):
+        return pp_to_text(value)
+    if isinstance(value, list):
+        return [
+            normalized
+            for item in value
+            if not is_empty_value(normalized := normalize_proof_state(item))
+        ]
+    if not isinstance(value, dict):
+        return value
+
+    if _looks_like_goal(value):
+        return _normalize_goal(value)
+    if _looks_like_goal_config(value):
+        return _normalize_goal_config(value)
+    if _looks_like_message(value):
+        return _normalize_message(value)
+
+    result: dict[str, Any] = {}
+    for key, item in value.items():
+        if key in {"textDocument", "position", "range", "error", "program"}:
+            continue
+        normalized = normalize_proof_state(item)
+        if key == "goals" and isinstance(normalized, dict):
+            result.update(normalized)
+            continue
+        if not is_empty_value(normalized):
+            result[key] = normalized
+    return result
+
+
+def _normalize_goal(value: dict[str, Any]) -> dict[str, Any]:
+    info = value.get("info") if isinstance(value.get("info"), dict) else {}
+    return pruned_dict(
+        {
+            "name": normalize_proof_state(info.get("name")),
+            "hypotheses": _normalize_hypotheses(value.get("hyps", [])),
+            "conclusion": normalize_proof_state(value.get("ty")),
+        }
+    )
+
+
+def _normalize_goal_config(value: dict[str, Any]) -> dict[str, Any]:
+    goals = normalize_proof_state(value.get("goals", []))
+    given_up = normalize_proof_state(value.get("given_up", []))
+    result = {
+        "goals": goals,
+        "bullet": normalize_proof_state(value.get("bullet")),
+        "shelved_goals": normalize_proof_state(value.get("shelf", [])),
+    }
+    if given_up != goals:
+        result["given_up_goals"] = given_up
+    return pruned_dict(result)
+
+
+def _normalize_message(value: dict[str, Any]) -> dict[str, Any]:
+    result = dict(value)
+    if "text" in result:
+        result["text"] = normalize_proof_state(result["text"])
+    return pruned_dict(result)
+
+
+def _normalize_hypotheses(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+
+    hypotheses: list[str] = []
+    for item in value:
+        hypothesis = _normalize_hypothesis(item)
+        if hypothesis:
+            hypotheses.append(hypothesis)
+    return hypotheses
+
+
+def _normalize_hypothesis(value: Any) -> str | None:
+    if not isinstance(value, dict):
+        normalized = normalize_proof_state(value)
+        return str(normalized) if normalized is not None else None
+
+    names = _hypothesis_names(value.get("names", []))
+    ty = normalize_proof_state(value.get("ty"))
+    definition = normalize_proof_state(value.get("def"))
+    if not names:
+        return str(ty) if ty is not None else None
+
+    prefix = " ".join(names)
+    if definition is not None and ty is not None:
+        return f"{prefix} := {definition} : {ty}"
+    if ty is not None:
+        return f"{prefix} : {ty}"
+    if definition is not None:
+        return f"{prefix} := {definition}"
+    return prefix
+
+
+def _hypothesis_names(value: Any) -> list[str]:
+    normalized = normalize_proof_state(value)
+    if isinstance(normalized, list):
+        return [str(item) for item in normalized if item is not None]
+    if normalized is None:
+        return []
+    return [str(normalized)]
+
+
+def _is_pp(value: Any) -> bool:
+    return (
+        isinstance(value, list)
+        and len(value) > 0
+        and isinstance(value[0], str)
+        and value[0].startswith("Pp_")
+    )
+
+
+def _looks_like_goal(value: dict[str, Any]) -> bool:
+    return "hyps" in value and "ty" in value
+
+
+def _looks_like_goal_config(value: dict[str, Any]) -> bool:
+    return "goals" in value and "stack" in value and "shelf" in value
+
+
+def _looks_like_message(value: dict[str, Any]) -> bool:
+    return "text" in value and "level" in value
+
+
+def _list_at(value: list[Any], index: int) -> list[Any]:
+    item = value[index] if len(value) > index else []
+    return item if isinstance(item, list) else []