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

rocq_solid_mcp/__init__.py

@@ -0,0 +1,6 @@
+"""RocqSolid: an MCP server for Rocq proof development via rocq-lsp."""
+
+from .manager import RocqLspManager
+from .models import CheckResult
+
+__all__ = ["CheckResult", "RocqLspManager"]

rocq_solid_mcp/cli.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from collections.abc import Sequence
+from typing import TextIO
+
+from .manager import RocqLspManager
+from .models import RenderOptions
+
+
+def main(argv: Sequence[str] | None = None) -> int | None:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args:
+        run_mcp_server()
+        return None
+
+    parsed = _parser().parse_args(args)
+    if parsed.command == "check":
+        return asyncio.run(_check(parsed.file, sys.stdout))
+    return 2
+
+
+def run_mcp_server() -> None:
+    from .server import main as server_main
+
+    server_main()
+
+
+async def _check(file: str, output: TextIO) -> int:
+    manager = RocqLspManager()
+    try:
+        result = await manager.check_file(
+            file,
+            command_timeout_seconds=0,
+            timeout_after_error_seconds=0,
+            overall_timeout_seconds=0,
+            long_running_seconds=0,
+        )
+        rendered = result.render(RenderOptions(message_limit=None))
+        print(json.dumps(rendered, indent=2), file=output)
+        return 0
+    finally:
+        await manager.close()
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="rocq-solid-mcp")
+    subcommands = parser.add_subparsers(dest="command", required=True)
+
+    check = subcommands.add_parser(
+        "check",
+        help="check a Rocq file and print formatted JSON",
+    )
+    check.add_argument("file", help="path to a .v file")
+
+    return parser
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rocq_solid_mcp/config.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import math
+import os
+import warnings
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_COMMAND_TIMEOUT_SECONDS = 5.0
+DEFAULT_TIMEOUT_AFTER_ERROR_SECONDS = 10.0
+DEFAULT_MESSAGE_LIMIT = 10
+MAX_MESSAGE_LIMIT = 50
+DEFAULT_OVERALL_TIMEOUT_SECONDS = 55
+MAX_OVERALL_TIMEOUT_SECONDS = 3600.0
+
+
+@dataclass(frozen=True)
+class TimeoutPolicy:
+    request_seconds: float = DEFAULT_OVERALL_TIMEOUT_SECONDS
+    cancel_grace_seconds: float = 5.0
+    command_seconds: float | None = DEFAULT_COMMAND_TIMEOUT_SECONDS
+    # Overall deadline for the rest of a check once the first error
+    # diagnostic has been observed: the whole call is cancelled at most this
+    # many seconds after the first error. None or a non-positive value
+    # disables it.
+    request_seconds_after_error: float | None = DEFAULT_TIMEOUT_AFTER_ERROR_SECONDS
+
+
+@dataclass(frozen=True)
+class RocqLspConfig:
+    binary: str
+    timeout_policy: TimeoutPolicy
+    max_errors: int
+    workspace: Path | None
+    message_limit: int = DEFAULT_MESSAGE_LIMIT
+    use_opam: bool = True
+    idle_ttl_seconds: float = 1800.0
+    dune_build: bool = True
+    dune_timeout_seconds: float = DEFAULT_OVERALL_TIMEOUT_SECONDS
+
+
+def _float_env(name: str, default: str) -> float:
+    value = float(os.environ.get(name, default))
+    if not math.isfinite(value):
+        # nan/inf would poison timeout arithmetic and asyncio timers.
+        return float(default)
+    return value
+
+
+def _optional_positive_float_env(name: str, default: str = "0") -> float | None:
+    """Read an optional float where non-positive values disable the setting.
+
+    A set-but-empty variable falls back to the default, matching the unset
+    case, instead of failing to parse. Non-finite values (nan/inf) disable
+    the setting: they would poison timeout arithmetic and asyncio timers,
+    and "no limit" is exactly what disabling means.
+    """
+    raw = os.environ.get(name, default)
+    if not raw.strip():
+        raw = default
+    value = float(raw)
+    if not math.isfinite(value) or value <= 0:
+        return None
+    return value
+
+
+def bounded_overall_timeout_seconds(value: float | None) -> float:
+    if value is None:
+        return DEFAULT_OVERALL_TIMEOUT_SECONDS
+    return min(float(value), MAX_OVERALL_TIMEOUT_SECONDS)
+
+
+def bounded_message_limit(limit: int | None) -> int:
+    if limit is None:
+        return DEFAULT_MESSAGE_LIMIT
+    return min(max(int(limit), 0), MAX_MESSAGE_LIMIT)
+
+
+def _int_env(name: str, default: str) -> int:
+    return int(os.environ.get(name, default))
+
+
+def _bool_env(name: str, default: str) -> bool:
+    value = os.environ.get(name, default).strip().lower()
+    if value in {"1", "true", "yes", "on"}:
+        return True
+    if value in {"0", "false", "no", "off"}:
+        return False
+    raise ValueError(f"{name} must be a boolean value")
+
+
+def load_config() -> RocqLspConfig:
+    if "ROCQ_LSP_COMMAND_TIMEOUT_AFTER_ERROR" in os.environ:
+        warnings.warn(
+            "ROCQ_LSP_COMMAND_TIMEOUT_AFTER_ERROR is no longer read; use "
+            "ROCQ_LSP_TIMEOUT_AFTER_ERROR, which bounds the rest of a check "
+            "after its first error (non-positive values disable it).",
+            stacklevel=2,
+        )
+    workspace = os.environ.get("ROCQ_LSP_WORKSPACE")
+    return RocqLspConfig(
+        binary=os.environ.get("ROCQ_LSP_BINARY", "coq-lsp"),
+        timeout_policy=TimeoutPolicy(
+            request_seconds=bounded_overall_timeout_seconds(
+                _float_env("ROCQ_LSP_TIMEOUT", str(DEFAULT_OVERALL_TIMEOUT_SECONDS))
+            ),
+            cancel_grace_seconds=_float_env("ROCQ_LSP_HARD_TIMEOUT_GRACE", "5"),
+            command_seconds=_optional_positive_float_env(
+                "ROCQ_LSP_COMMAND_TIMEOUT", str(DEFAULT_COMMAND_TIMEOUT_SECONDS)
+            ),
+            request_seconds_after_error=_optional_positive_float_env(
+                "ROCQ_LSP_TIMEOUT_AFTER_ERROR",
+                str(DEFAULT_TIMEOUT_AFTER_ERROR_SECONDS),
+            ),
+        ),
+        max_errors=_int_env("ROCQ_LSP_MAX_ERRORS", "1000000"),
+        workspace=Path(workspace).expanduser().resolve() if workspace else None,
+        message_limit=bounded_message_limit(
+            _int_env("ROCQ_LSP_MESSAGE_LIMIT", str(DEFAULT_MESSAGE_LIMIT))
+        ),
+        use_opam=_bool_env("ROCQ_LSP_USE_OPAM", "1"),
+        idle_ttl_seconds=_float_env("ROCQ_LSP_IDLE_TTL_SECONDS", "1800"),
+        dune_build=_bool_env("ROCQ_LSP_DUNE_BUILD", "1"),
+        dune_timeout_seconds=bounded_overall_timeout_seconds(
+            _float_env("ROCQ_LSP_DUNE_TIMEOUT", str(DEFAULT_OVERALL_TIMEOUT_SECONDS))
+        ),
+    )
+
+
+def rocq_lsp_command(binary: str, *, use_opam: bool) -> tuple[str, ...]:
+    if use_opam:
+        return ("opam", "exec", "--", binary)
+    return (binary,)
+
+
+def rocq_lsp_settings(max_errors: int) -> dict[str, object]:
+    return {
+        "client_version": "any",
+        "eager_diagnostics": True,
+        "max_errors": max_errors,
+        "check_only_on_request": False,
+        "send_perf_data": True,
+        "send_execinfo": True,
+        "send_diags": True,
+        "send_diags_extra_data": True,
+    }