forge-cpp-mcp 0.2.1__py3-none-any.whl

forgemcp/toolchain/tools/clangd.py

@@ -0,0 +1,280 @@
+"""Typed methods for clangd."""
+
+import asyncio
+import json
+import re
+from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Protocol, TypedDict
+
+from pydantic import JsonValue
+
+from forgemcp.process.errors import ProcessError
+from forgemcp.process.models import ProcessEncoding, ProcessTimeout
+from forgemcp.process.service import ProcessService, ProcessSession
+
+from ..errors import ToolCommandError, ToolParserError
+from ..spec import ToolInfo, ToolKind, ToolSpec
+
+
+type LspId = int | str
+
+
+@dataclass(frozen=True)
+class LspRequest:
+    id: LspId
+    method: str
+    params: JsonValue = None
+
+
+@dataclass(frozen=True)
+class LspNotification:
+    method: str
+    params: JsonValue = None
+
+
+@dataclass(frozen=True)
+class LspResponse:
+    id: LspId
+    result: JsonValue
+
+
+@dataclass(frozen=True)
+class LspErrorResponse:
+    id: LspId | None
+    code: int
+    message: str
+    data: JsonValue = None
+
+
+type LspMessage = LspRequest | LspNotification | LspResponse | LspErrorResponse
+
+
+def parse_message(value: object) -> LspMessage:
+    """Validate the JSON-RPC envelope without interpreting a language operation."""
+    if not isinstance(value, dict) or value.get("jsonrpc") != "2.0":
+        raise ToolParserError("clangd returned an invalid JSON-RPC envelope.")
+    identifier = value.get("id")
+    valid_id = type(identifier) in (int, str)
+    if "method" in value:
+        if (
+            not isinstance(value["method"], str)
+            or not value["method"]
+            or "result" in value
+            or "error" in value
+            or ("params" in value and not isinstance(value["params"], (dict, list)))
+        ):
+            raise ToolParserError("clangd returned an invalid request or notification.")
+        if "id" not in value:
+            return LspNotification(value["method"], value.get("params"))
+        if valid_id:
+            return LspRequest(identifier, value["method"], value.get("params"))
+    elif "result" in value and "error" not in value and valid_id:
+        return LspResponse(identifier, value["result"])
+    elif "error" in value and "result" not in value and "id" in value:
+        error = value["error"]
+        if (
+            (valid_id or identifier is None)
+            and isinstance(error, dict)
+            and type(error.get("code")) is int
+            and isinstance(error.get("message"), str)
+        ):
+            return LspErrorResponse(
+                identifier,
+                error["code"],
+                error["message"],
+                error.get("data"),
+            )
+    raise ToolParserError("clangd returned an invalid JSON-RPC response or identifier.")
+
+
+def reject_constant(value: str) -> None:
+    raise ValueError("Non-finite JSON number.")
+
+
+class Connection:
+    """A single-reader framed connection; process ownership stays in this module."""
+
+    def __init__(self, session: ProcessSession) -> None:
+        self._session = session
+        self.write_lock = asyncio.Lock()
+        self.claimed = False
+
+    @property
+    def process_id(self) -> int:
+        return self._session.process_id
+
+    async def close(self) -> None:
+        """Close the transport, leaving process cleanup inside the tool module."""
+        await self._session.close()
+
+    async def send(self, message: LspMessage) -> None:
+        value = {"jsonrpc": "2.0", **asdict(message)}
+        if isinstance(message, LspErrorResponse):
+            value = {
+                "jsonrpc": "2.0",
+                "id": message.id,
+                "error": {
+                    "code": message.code,
+                    "message": message.message,
+                    "data": message.data,
+                },
+            }
+        elif isinstance(message, (LspRequest, LspNotification)) and message.params is None:
+            value.pop("params")
+        parse_message(value)
+        try:
+            body = json.dumps(
+                value,
+                ensure_ascii=False,
+                allow_nan=False,
+                separators=(",", ":"),
+            ).encode("utf-8")
+            header = f"Content-Length: {len(body)}\r\n\r\n".encode("ascii")
+            async with self.write_lock:
+                await self._session.write_stdin((header + body).decode("latin_1"))
+        except (TypeError, ValueError, UnicodeError) as error:
+            raise ToolParserError("Cannot serialize an LSP message.") from error
+        except ProcessError as error:
+            raise ToolCommandError(
+                "Cannot send an LSP message to clangd.",
+                process_id=self.process_id,
+            ) from error
+
+    async def messages(self) -> AsyncGenerator[LspMessage]:
+        if self.claimed:
+            raise ToolCommandError("clangd messages already have a reader.")
+        self.claimed = True
+        buffer = bytearray()
+        length = None
+        try:
+            async for chunk in self._session.output():
+                if chunk.stream != "stdout":
+                    continue
+                buffer.extend(chunk.text.encode("latin_1"))
+                while True:
+                    if length is None:
+                        end = buffer.find(b"\r\n\r\n")
+                        if end < 0:
+                            break
+                        headers = bytes(buffer[:end]).decode("ascii")
+                        del buffer[:end + 4]
+                        lengths = []
+                        for header in headers.split("\r\n"):
+                            key, separator, value = header.partition(":")
+                            if not separator:
+                                raise ValueError("Malformed LSP header.")
+                            if key.strip().lower() == "content-length":
+                                lengths.append(value.strip())
+                        if len(lengths) != 1 or not re.fullmatch(r"[0-9]+", lengths[0]):
+                            raise ValueError("Invalid LSP content length.")
+                        length = int(lengths[0])
+                    if len(buffer) < length:
+                        break
+                    body = bytes(buffer[:length])
+                    del buffer[:length]
+                    length = None
+                    yield parse_message(
+                        json.loads(body.decode("utf-8"), parse_constant=reject_constant),
+                    )
+            if buffer or length is not None:
+                raise ToolParserError("clangd closed an incomplete LSP message.")
+            code = await self._session.wait()
+            if code != 0:
+                raise ToolCommandError(
+                    f"clangd exited with code {code}.",
+                    process_id=self.process_id,
+                )
+        except (ValueError, UnicodeError, RecursionError) as error:
+            raise ToolParserError("clangd returned malformed LSP data.") from error
+        except ProcessError as error:
+            raise ToolCommandError(
+                "clangd process communication failed.",
+                process_id=self.process_id,
+            ) from error
+
+
+class Connect(Protocol):
+    def __call__(
+        self,
+        project: Path,
+        compilation_database_directory: Path,
+    ) -> AbstractAsyncContextManager[Connection]: ...
+
+
+class Methods(TypedDict):
+    version: Callable[[], Awaitable[str]]
+    connect: Connect
+
+
+def create_spec(
+    path: Path,
+    processes: ProcessService,
+    environment: Mapping[str, str] | None = None,
+    inherit_environment: bool = True,
+) -> ToolSpec:
+    path = path.resolve()
+
+    async def version() -> str:
+        output = {"stdout": "", "stderr": ""}
+        try:
+            async with await processes.launch(
+                path,
+                ('--version',),
+                env=environment,
+                inherit_environment=inherit_environment,
+                timeout=ProcessTimeout(total=15),
+            ) as session:
+                await session.close_stdin()
+                async for chunk in session.output():
+                    # Only the short version banner is needed; drain the rest.
+                    remaining = 4096 - len(output[chunk.stream])
+                    output[chunk.stream] += chunk.text[:remaining]
+                code = await session.wait()
+                if code != 0:
+                    raise ToolCommandError(f"{INFO.name}.version failed (exit {code}).")
+        except ProcessError as error:
+            raise ToolCommandError(f"Cannot read {INFO.name} version.") from error
+        for text in output.values():
+            if match := re.search(
+                'clangd version ([0-9][^\\s]*)',
+                text,
+                re.IGNORECASE | re.MULTILINE,
+            ):
+                return match.group(1)
+        raise ToolParserError(f"Cannot parse {INFO.name} version.")
+
+    @asynccontextmanager
+    async def connect(
+        project: Path,
+        compilation_database_directory: Path,
+    ) -> AsyncGenerator[Connection]:
+        if not (compilation_database_directory / "compile_commands.json").is_file():
+            raise ToolCommandError("clangd requires an existing compilation database.")
+        try:
+            async with await processes.launch(
+                path,
+                (
+                    f"--compile-commands-dir={compilation_database_directory}",
+                    "--background-index",
+                ),
+                cwd=project,
+                env=environment,
+                inherit_environment=inherit_environment,
+                encoding=ProcessEncoding(driver="latin_1", errors="strict"),
+                timeout=ProcessTimeout(),
+            ) as session:
+                yield Connection(session)
+        except ProcessError as error:
+            raise ToolCommandError("Cannot run clangd.") from error
+
+    methods: Methods = {
+        "version": version,
+        "connect": connect,
+    }
+    return ToolSpec(INFO.name, INFO.kind, path, methods)
+
+
+INFO = ToolInfo(name='clangd', kind=ToolKind.LANGUAGE_SERVER, create_spec=create_spec)

forgemcp/toolchain/tools/clangxx.py

@@ -0,0 +1,61 @@
+"""Typed methods for clang++."""
+
+import re
+from collections.abc import Awaitable, Callable, Mapping
+from pathlib import Path
+from typing import TypedDict
+
+from forgemcp.process.errors import ProcessError
+from forgemcp.process.models import ProcessTimeout
+from forgemcp.process.service import ProcessService
+
+from ..errors import ToolCommandError, ToolParserError
+from ..spec import ToolInfo, ToolKind, ToolSpec
+
+
+class Methods(TypedDict):
+    version: Callable[[], Awaitable[str]]
+
+
+def create_spec(
+    path: Path,
+    processes: ProcessService,
+    environment: Mapping[str, str] | None = None,
+    inherit_environment: bool = True,
+) -> ToolSpec:
+    path = path.resolve()
+
+    async def version() -> str:
+        output = {"stdout": "", "stderr": ""}
+        try:
+            async with await processes.launch(
+                path,
+                ('--version',),
+                env=environment,
+                inherit_environment=inherit_environment,
+                timeout=ProcessTimeout(total=15),
+            ) as session:
+                await session.close_stdin()
+                async for chunk in session.output():
+                    # Only the short version banner is needed; drain the rest.
+                    remaining = 4096 - len(output[chunk.stream])
+                    output[chunk.stream] += chunk.text[:remaining]
+                code = await session.wait()
+                if code != 0:
+                    raise ToolCommandError(f"{INFO.name}.version failed (exit {code}).")
+        except ProcessError as error:
+            raise ToolCommandError(f"Cannot read {INFO.name} version.") from error
+        for text in output.values():
+            if match := re.search(
+                'clang version ([0-9][^\\s]*)',
+                text,
+                re.IGNORECASE | re.MULTILINE,
+            ):
+                return match.group(1)
+        raise ToolParserError(f"Cannot parse {INFO.name} version.")
+
+    methods: Methods = {"version": version}
+    return ToolSpec(INFO.name, INFO.kind, path, methods)
+
+
+INFO = ToolInfo(name='clang++', kind=ToolKind.COMPILER, create_spec=create_spec)

forgemcp/toolchain/tools/cmake.py

@@ -0,0 +1,280 @@
+"""Typed methods for cmake."""
+
+import re
+from collections.abc import Awaitable, Callable, Mapping, Sequence
+from pathlib import Path
+from typing import Protocol, TypedDict
+
+from pydantic import BaseModel, Field
+
+from forgemcp.process.errors import ProcessError
+from forgemcp.process.models import ProcessTimeout
+from forgemcp.process.service import ProcessService
+
+from ..errors import ToolCommandError, ToolParserError
+from ..spec import ToolInfo, ToolKind, ToolSpec
+
+
+type Progress = Callable[[str], Awaitable[None]]
+
+
+class PresetsResult(BaseModel):
+    configure: list[str] = Field(default_factory=list)
+    build: list[str] = Field(default_factory=list)
+    test: list[str] = Field(default_factory=list)
+
+
+class ConfigureResult(BaseModel):
+    return_code: int = 0
+    process_id: int | None = None
+    configured: bool = False
+    generated: bool = False
+
+
+class BuildResult(BaseModel):
+    return_code: int = 0
+    process_id: int | None = None
+    completed_steps: int | None = None
+    total_steps: int | None = None
+
+
+class Presets(Protocol):
+    async def __call__(self, source: Path) -> PresetsResult: ...
+
+
+class Configure(Protocol):
+    async def __call__(
+        self,
+        source: Path,
+        build_directory: Path | None,
+        *,
+        preset: str | None = None,
+        generator: str | None = None,
+        definitions: Mapping[str, str] | None = None,
+        timeout: ProcessTimeout = ProcessTimeout(total=600),
+        on_progress: Progress | None = None,
+    ) -> ConfigureResult: ...
+
+
+class Build(Protocol):
+    async def __call__(
+        self,
+        source: Path,
+        build_directory: Path | None,
+        *,
+        preset: str | None = None,
+        configuration: str | None = None,
+        targets: Sequence[str] | None = None,
+        parallel: int | None = None,
+        timeout: ProcessTimeout = ProcessTimeout(total=600),
+        on_progress: Progress | None = None,
+    ) -> BuildResult: ...
+
+
+class Methods(TypedDict):
+    version: Callable[[], Awaitable[str]]
+    presets: Presets
+    configure: Configure
+    build: Build
+
+
+def parse_cache(text: str) -> dict[str, str]:
+    entries = {}
+    for line in text.splitlines():
+        if line.startswith(("//", "#")):
+            continue
+        key_type, separator, value = line.partition("=")
+        key, colon, _ = key_type.partition(":")
+        if separator and colon:
+            entries[key] = value
+    return entries
+
+
+def create_spec(
+    path: Path,
+    processes: ProcessService,
+    environment: Mapping[str, str] | None = None,
+    inherit_environment: bool = True,
+) -> ToolSpec:
+    path = path.resolve()
+
+    async def version() -> str:
+        output = {"stdout": "", "stderr": ""}
+        try:
+            async with await processes.launch(
+                path,
+                ('--version',),
+                env=environment,
+                inherit_environment=inherit_environment,
+                timeout=ProcessTimeout(total=15),
+            ) as session:
+                await session.close_stdin()
+                async for chunk in session.output():
+                    # Only the short version banner is needed; drain the rest.
+                    remaining = 4096 - len(output[chunk.stream])
+                    output[chunk.stream] += chunk.text[:remaining]
+                code = await session.wait()
+                if code != 0:
+                    raise ToolCommandError(f"{INFO.name}.version failed (exit {code}).")
+        except ProcessError as error:
+            raise ToolCommandError(f"Cannot read {INFO.name} version.") from error
+        for text in output.values():
+            if match := re.search(
+                'cmake version ([0-9][0-9A-Za-z.+~-]*)',
+                text,
+                re.IGNORECASE | re.MULTILINE,
+            ):
+                return match.group(1)
+        raise ToolParserError(f"Cannot parse {INFO.name} version.")
+
+    async def execute(
+        source: Path,
+        arguments: Sequence[str],
+        timeout: ProcessTimeout,
+        on_line: Progress,
+    ) -> tuple[int, int]:
+        buffers = {"stdout": "", "stderr": ""}
+        session = None
+        try:
+            async with await processes.launch(
+                path,
+                arguments,
+                cwd=source,
+                env=environment,
+                inherit_environment=inherit_environment,
+                timeout=timeout,
+            ) as session:
+                await session.close_stdin()
+                async for chunk in session.output():
+                    buffers[chunk.stream] += chunk.text.replace("\r", "\n")
+                    while "\n" in buffers[chunk.stream]:
+                        line, _, buffers[chunk.stream] = buffers[chunk.stream].partition("\n")
+                        if line.strip():
+                            await on_line(line)
+                for line in buffers.values():
+                    if line.strip():
+                        await on_line(line)
+                return await session.wait(), session.process_id
+        except ProcessError as error:
+            raise ToolCommandError(
+                str(error),
+                process_id=session.process_id if session is not None else None,
+            ) from error
+
+    async def presets(source: Path) -> PresetsResult:
+        result = PresetsResult()
+        kind = None
+
+        async def parse(line: str) -> None:
+            nonlocal kind
+            heading = re.fullmatch(r"Available (\w+) presets:", line.strip())
+            if heading:
+                kind = heading.group(1)
+            elif kind in ("configure", "build", "test"):
+                match = re.fullmatch(r'\s+"(.*?)"(?:\s+-.*)?', line)
+                if match is not None:
+                    getattr(result, kind).append(match.group(1))
+
+        code, process_id = await execute(
+            source,
+            ("--list-presets=all",),
+            ProcessTimeout(total=30),
+            parse,
+        )
+        if code != 0:
+            raise ToolCommandError(f"CMake could not list presets (exit {code}, process {process_id}).")
+        return result
+
+    async def configure(
+        source: Path,
+        build_directory: Path | None,
+        *,
+        preset: str | None = None,
+        generator: str | None = None,
+        definitions: Mapping[str, str] | None = None,
+        timeout: ProcessTimeout = ProcessTimeout(total=600),
+        on_progress: Progress | None = None,
+    ) -> ConfigureResult:
+        arguments = ["--preset", preset] if preset is not None else ["-S", str(source)]
+        if preset is None and build_directory is None:
+            raise ToolCommandError("A plain configure requires a build directory.")
+        if build_directory is not None:
+            arguments.extend(("-B", str(build_directory)))
+        if generator is not None:
+            arguments.extend(("-G", generator))
+        for key, value in (definitions or {}).items():
+            arguments.append(f"-D{key}={value}")
+        result = ConfigureResult()
+
+        async def parse(line: str) -> None:
+            if line.startswith("-- Configuring done"):
+                result.configured = True
+            if line.startswith("-- Generating done"):
+                result.generated = True
+            if on_progress is not None and line.startswith(("-- ", "CMake Error", "CMake Warning")):
+                await on_progress(line.removeprefix("-- "))
+
+        result.return_code, result.process_id = await execute(
+            source,
+            arguments,
+            timeout,
+            parse,
+        )
+        return result
+
+    async def build(
+        source: Path,
+        build_directory: Path | None,
+        *,
+        preset: str | None = None,
+        configuration: str | None = None,
+        targets: Sequence[str] | None = None,
+        parallel: int | None = None,
+        timeout: ProcessTimeout = ProcessTimeout(total=600),
+        on_progress: Progress | None = None,
+    ) -> BuildResult:
+        arguments = ["--build"]
+        if preset is None:
+            if build_directory is None:
+                raise ToolCommandError("A plain build requires a build directory.")
+            arguments.append(str(build_directory))
+        else:
+            arguments.extend(("--preset", preset))
+        if configuration is not None:
+            arguments.extend(("--config", configuration))
+        if targets is not None:
+            arguments.extend(("--target", *targets))
+        if parallel is not None:
+            arguments.extend(("--parallel", str(parallel)))
+        result = BuildResult()
+
+        async def parse(line: str) -> None:
+            step = re.match(r"\[(\d+)/(\d+)\]\s+", line)
+            if step:
+                result.completed_steps = int(step.group(1))
+                result.total_steps = int(step.group(2))
+            if on_progress is not None and (
+                step
+                or re.match(r"\[\s*\d+%\]", line)
+                or line.startswith(("FAILED:", "ninja:", "MSBuild version"))
+            ):
+                await on_progress(line)
+
+        result.return_code, result.process_id = await execute(
+            source,
+            arguments,
+            timeout,
+            parse,
+        )
+        return result
+
+    methods: Methods = {
+        "version": version,
+        "presets": presets,
+        "configure": configure,
+        "build": build,
+    }
+    return ToolSpec(INFO.name, INFO.kind, path, methods)
+
+
+INFO = ToolInfo(name='cmake', kind=ToolKind.BUILD_SYSTEM, create_spec=create_spec)

forgemcp/toolchain/tools/cppvsdbg.py

@@ -0,0 +1,27 @@
+"""Typed methods for cppvsdbg."""
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TypedDict
+
+from forgemcp.process.service import ProcessService
+
+from ..spec import ToolInfo, ToolKind, ToolSpec
+
+
+class Methods(TypedDict):
+    pass
+
+
+def create_spec(
+    path: Path,
+    processes: ProcessService,
+    environment: Mapping[str, str] | None = None,
+    inherit_environment: bool = True,
+) -> ToolSpec:
+    path = path.resolve()
+    methods: Methods = {}
+    return ToolSpec(INFO.name, INFO.kind, path, methods)
+
+
+INFO = ToolInfo(name='cppvsdbg', kind=ToolKind.DEBUGGER, create_spec=create_spec)