rocq-solid-mcp 1.0.0__tar.gz

rocq_solid_mcp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benjamin Peters and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rocq_solid_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: rocq-solid-mcp
+Version: 1.0.0
+Summary: RocqSolid: an MCP server for Rocq proof development, backed by rocq-lsp
+Author: Benjamin Peters
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bn-peters/rocq-solid-mcp
+Project-URL: Repository, https://github.com/bn-peters/rocq-solid-mcp
+Project-URL: Issues, https://github.com/bn-peters/rocq-solid-mcp/issues
+Keywords: rocq,coq,mcp,proof assistant,lsp,agent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp<5,>=4.1
+Requires-Dist: pydantic<3,>=2.13
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.25; extra == "dev"
+Requires-Dist: pytest-xdist>=3.6; extra == "dev"
+Dynamic: license-file
+
+# RocqSolid
+
+[![PyPI](https://img.shields.io/pypi/v/rocq-solid-mcp)](https://pypi.org/project/rocq-solid-mcp/)
+[![CI](https://github.com/bn-peters/rocq-solid-mcp/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/bn-peters/rocq-solid-mcp/actions/workflows/ci.yml)
+
+An MCP server for Rocq proof development.
+
+The MCP is deliberately small:
+1. `check` generates diagnostics for a given file. It tries to return errors
+   from proofs throughout the file. Proof states are cached for efficiency.
+2. `run_at` runs a command at a given position in a file. This is useful for
+   queries like `Search` or `Check`, and for one-off debugging commands.
+
+## Requirements
+
+*RocqSolid appears to be more stable on OCaml 5 than on OCaml 4. Consider
+upgrading if you're experiencing crashes.*
+
+RocqSolid depends on a [patched version](https://github.com/bn-peters/coq-lsp)
+of [`coq-lsp`](https://github.com/rocq-community/coq-lsp). It improves the
+stability and error reporting of `coq-lsp`, and RocqSolid does not work
+without. It is compatible with Rocq 9.0, 9.1, and 9.2. It needs to be installed
+in all opam switches RocqSolid should work with:
+```bash
+opam repo add rocq-solid https://github.com/bn-peters/rocq-solid-mcp-opam.git
+opam install rocq-solid-mcp-lsp
+```
+You might be asked to uninstall `coq-lsp`. Don't worry, `rocq-solid-mcp-lsp` is compatible with standard `coq-lsp`.
+
+## Agent Setup
+
+We recommend using [`uv`](https://docs.astral.sh/uv/), a Python packaging tool.
+To teach your favorite agent about RocqSolid:
+```bash
+claude mcp add --scope user rocq-solid -- uvx rocq-solid-mcp
+codex mcp add rocq-solid -- uvx rocq-solid-mcp
+```
+
+## Project Setup
+
+The MCP looks for `_CoqProject` and `_RocqProject` files to set up file
+dependencies correctly. To generate them in a `dune`-based project, add
+`(generate_project_file)` to your `rocq.theory` stanzas:
+```
+; in theories/dune
+(rocq.theory
+  (name my-project)
+  (generate_project_file)
+  (theories Stdlib))
+```
+You need to link the right opam switch to your development so that RocqSolid
+knows which one to use:
+```
+opam switch link [switch] .
+```
+
+## Timeouts
+
+If you have files that compile very slowly, RocqSolid may time out. You can
+raise this limit with `ROCQ_LSP_TIMEOUT`.
+
+For Claude, re-register RocqSolid with a higher limit:
+```bash
+claude mcp remove --scope user rocq-solid
+claude mcp add --scope user rocq-solid -e ROCQ_LSP_TIMEOUT=290 -- uvx rocq-solid-mcp
+```
+
+For Codex, add the last two options to the existing entry in
+`~/.codex/config.toml`:
+```toml
+[mcp_servers.rocq-solid]
+command = "uvx"
+args = ["rocq-solid-mcp"]
+# add these two options:
+tool_timeout_sec = 300
+env = { ROCQ_LSP_TIMEOUT = "290" } # slightly lower than tool_timeout_sec
+```
+
+## Upgrading
+
+To upgrade RocqSolid:
+```
+uvx rocq-solid-mcp@latest --help
+```
+To upgrade `coq-lsp`, run in your switch:
+```
+opam update && opam upgrade rocq-solid-mcp-lsp
+```
+
+## Troubleshooting
+
+RocqSolid needs Python 3.11 or newer. If your default `python3` is older, `uvx`
+reports that no solution was found. Use `uvx --python 3.12 rocq-solid-mcp`
+instead.
+
+You can check a single file from the command line, which prints the diagnostics
+as JSON:
+```bash
+uvx rocq-solid-mcp check path/to/file.v
+```
+
+## Environment Variables
+
+All optional; defaults in parentheses.
+
+- `ROCQ_LSP_BINARY` (`coq-lsp`): the `coq-lsp` executable
+- `ROCQ_LSP_USE_OPAM` (`1`): run via `opam exec --`; `0` runs the binary
+  directly
+- `ROCQ_LSP_WORKSPACE` (unset): override the inferred workspace root
+- `ROCQ_LSP_TIMEOUT` (`55`, max `3600`): deadline per call; set slightly below
+  the MCP tool timeout
+- `ROCQ_LSP_HARD_TIMEOUT_GRACE` (`5`): extra wait after cancellation before the
+  session is killed
+- `ROCQ_LSP_COMMAND_TIMEOUT` (`5`): default per-sentence timeout; `0` disables
+- `ROCQ_LSP_TIMEOUT_AFTER_ERROR` (`10`): overall deadline for the rest of a
+  check after its first error; `0` disables
+- `ROCQ_LSP_MESSAGE_LIMIT` (`10`, max `50`): max errors returned per check
+- `ROCQ_LSP_MAX_ERRORS` (`1000000`): max errors `coq-lsp` collects
+- `ROCQ_LSP_IDLE_TTL_SECONDS` (`1800`): idle time before cached sessions are
+  stopped
+- `ROCQ_LSP_DUNE_BUILD` (`1`): build dune dependencies before checks; `0`
+  disables
+- `ROCQ_LSP_DUNE_TIMEOUT` (`55`, max `3600`): limit per dune detection or build
+  command
+
+
+## Support
+
+Join us on the Iris Mattermost!
+1. Go to the [GitLab log-in page](https://gitlab.mpi-sws.org/users/sign_in) and select the "GitHub" button, then log in with your GitHub account.
+2. Log in to Mattermost; this should use your GitLab login.
+3. Join the [RocqSolid](https://mattermost.mpi-sws.org/iris/channels/bens-rocq-mcp) channel.
+
+If you notice that your agent misbehaves with this MCP, please let us know! It
+would be particularly helpful if you could share your transcripts.
+
+## Development
+
+In a clone of this repository:
+```bash
+uv venv .venv && uv pip install -e ".[dev]"
+make test
+```
+`uv tool install -e .` installs a development version of `rocq-solid-mcp` to
+`~/.local/bin/`.
+
+To release a new version, bump `version` in `pyproject.toml` and push a tag
+`vX.Y.Z`. The `release` GitHub workflow builds the package and publishes it to
+PyPI.

rocq_solid_mcp-1.0.0/README.md

@@ -0,0 +1,149 @@
+# RocqSolid
+
+[![PyPI](https://img.shields.io/pypi/v/rocq-solid-mcp)](https://pypi.org/project/rocq-solid-mcp/)
+[![CI](https://github.com/bn-peters/rocq-solid-mcp/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/bn-peters/rocq-solid-mcp/actions/workflows/ci.yml)
+
+An MCP server for Rocq proof development.
+
+The MCP is deliberately small:
+1. `check` generates diagnostics for a given file. It tries to return errors
+   from proofs throughout the file. Proof states are cached for efficiency.
+2. `run_at` runs a command at a given position in a file. This is useful for
+   queries like `Search` or `Check`, and for one-off debugging commands.
+
+## Requirements
+
+*RocqSolid appears to be more stable on OCaml 5 than on OCaml 4. Consider
+upgrading if you're experiencing crashes.*
+
+RocqSolid depends on a [patched version](https://github.com/bn-peters/coq-lsp)
+of [`coq-lsp`](https://github.com/rocq-community/coq-lsp). It improves the
+stability and error reporting of `coq-lsp`, and RocqSolid does not work
+without. It is compatible with Rocq 9.0, 9.1, and 9.2. It needs to be installed
+in all opam switches RocqSolid should work with:
+```bash
+opam repo add rocq-solid https://github.com/bn-peters/rocq-solid-mcp-opam.git
+opam install rocq-solid-mcp-lsp
+```
+You might be asked to uninstall `coq-lsp`. Don't worry, `rocq-solid-mcp-lsp` is compatible with standard `coq-lsp`.
+
+## Agent Setup
+
+We recommend using [`uv`](https://docs.astral.sh/uv/), a Python packaging tool.
+To teach your favorite agent about RocqSolid:
+```bash
+claude mcp add --scope user rocq-solid -- uvx rocq-solid-mcp
+codex mcp add rocq-solid -- uvx rocq-solid-mcp
+```
+
+## Project Setup
+
+The MCP looks for `_CoqProject` and `_RocqProject` files to set up file
+dependencies correctly. To generate them in a `dune`-based project, add
+`(generate_project_file)` to your `rocq.theory` stanzas:
+```
+; in theories/dune
+(rocq.theory
+  (name my-project)
+  (generate_project_file)
+  (theories Stdlib))
+```
+You need to link the right opam switch to your development so that RocqSolid
+knows which one to use:
+```
+opam switch link [switch] .
+```
+
+## Timeouts
+
+If you have files that compile very slowly, RocqSolid may time out. You can
+raise this limit with `ROCQ_LSP_TIMEOUT`.
+
+For Claude, re-register RocqSolid with a higher limit:
+```bash
+claude mcp remove --scope user rocq-solid
+claude mcp add --scope user rocq-solid -e ROCQ_LSP_TIMEOUT=290 -- uvx rocq-solid-mcp
+```
+
+For Codex, add the last two options to the existing entry in
+`~/.codex/config.toml`:
+```toml
+[mcp_servers.rocq-solid]
+command = "uvx"
+args = ["rocq-solid-mcp"]
+# add these two options:
+tool_timeout_sec = 300
+env = { ROCQ_LSP_TIMEOUT = "290" } # slightly lower than tool_timeout_sec
+```
+
+## Upgrading
+
+To upgrade RocqSolid:
+```
+uvx rocq-solid-mcp@latest --help
+```
+To upgrade `coq-lsp`, run in your switch:
+```
+opam update && opam upgrade rocq-solid-mcp-lsp
+```
+
+## Troubleshooting
+
+RocqSolid needs Python 3.11 or newer. If your default `python3` is older, `uvx`
+reports that no solution was found. Use `uvx --python 3.12 rocq-solid-mcp`
+instead.
+
+You can check a single file from the command line, which prints the diagnostics
+as JSON:
+```bash
+uvx rocq-solid-mcp check path/to/file.v
+```
+
+## Environment Variables
+
+All optional; defaults in parentheses.
+
+- `ROCQ_LSP_BINARY` (`coq-lsp`): the `coq-lsp` executable
+- `ROCQ_LSP_USE_OPAM` (`1`): run via `opam exec --`; `0` runs the binary
+  directly
+- `ROCQ_LSP_WORKSPACE` (unset): override the inferred workspace root
+- `ROCQ_LSP_TIMEOUT` (`55`, max `3600`): deadline per call; set slightly below
+  the MCP tool timeout
+- `ROCQ_LSP_HARD_TIMEOUT_GRACE` (`5`): extra wait after cancellation before the
+  session is killed
+- `ROCQ_LSP_COMMAND_TIMEOUT` (`5`): default per-sentence timeout; `0` disables
+- `ROCQ_LSP_TIMEOUT_AFTER_ERROR` (`10`): overall deadline for the rest of a
+  check after its first error; `0` disables
+- `ROCQ_LSP_MESSAGE_LIMIT` (`10`, max `50`): max errors returned per check
+- `ROCQ_LSP_MAX_ERRORS` (`1000000`): max errors `coq-lsp` collects
+- `ROCQ_LSP_IDLE_TTL_SECONDS` (`1800`): idle time before cached sessions are
+  stopped
+- `ROCQ_LSP_DUNE_BUILD` (`1`): build dune dependencies before checks; `0`
+  disables
+- `ROCQ_LSP_DUNE_TIMEOUT` (`55`, max `3600`): limit per dune detection or build
+  command
+
+
+## Support
+
+Join us on the Iris Mattermost!
+1. Go to the [GitLab log-in page](https://gitlab.mpi-sws.org/users/sign_in) and select the "GitHub" button, then log in with your GitHub account.
+2. Log in to Mattermost; this should use your GitLab login.
+3. Join the [RocqSolid](https://mattermost.mpi-sws.org/iris/channels/bens-rocq-mcp) channel.
+
+If you notice that your agent misbehaves with this MCP, please let us know! It
+would be particularly helpful if you could share your transcripts.
+
+## Development
+
+In a clone of this repository:
+```bash
+uv venv .venv && uv pip install -e ".[dev]"
+make test
+```
+`uv tool install -e .` installs a development version of `rocq-solid-mcp` to
+`~/.local/bin/`.
+
+To release a new version, bump `version` in `pyproject.toml` and push a tag
+`vX.Y.Z`. The `release` GitHub workflow builds the package and publishes it to
+PyPI.

rocq_solid_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,59 @@
+[project]
+name = "rocq-solid-mcp"
+version = "1.0.0"
+description = "RocqSolid: an MCP server for Rocq proof development, backed by rocq-lsp"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Benjamin Peters" }]
+requires-python = ">=3.11"
+keywords = ["rocq", "coq", "mcp", "proof assistant", "lsp", "agent"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "fastmcp>=4.1,<5",
+    "pydantic>=2.13,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.25",
+    "pytest-xdist>=3.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/bn-peters/rocq-solid-mcp"
+Repository = "https://github.com/bn-peters/rocq-solid-mcp"
+Issues = "https://github.com/bn-peters/rocq-solid-mcp/issues"
+
+[project.scripts]
+rocq-solid-mcp = "rocq_solid_mcp.cli:main"
+# Legacy name from before the rename; kept so existing configurations work.
+bens-rocq-mcp = "rocq_solid_mcp.cli:main"
+
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests/unit", "tests/integration", "tests/e2e"]

rocq_solid_mcp-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rocq_solid_mcp-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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,
+    }