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

forgemcp/toolchain/tools/msbuild.py

@@ -0,0 +1,61 @@
+"""Typed methods for msbuild."""
+
+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', '-nologo'),
+                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(
+                '^([0-9]+\\.[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='msbuild', kind=ToolKind.BUILD_RUNNER, create_spec=create_spec)

forgemcp/toolchain/tools/msvc.py

@@ -0,0 +1,27 @@
+"""Typed methods for cl."""
+
+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='cl', kind=ToolKind.COMPILER, create_spec=create_spec)

forgemcp/toolchain/tools/ninja.py

@@ -0,0 +1,61 @@
+"""Typed methods for ninja."""
+
+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(
+                '^([0-9]+\\.[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='ninja', kind=ToolKind.BUILD_RUNNER, create_spec=create_spec)

forgemcp/workspace/__init__.py

@@ -0,0 +1,5 @@
+"""Workspace filesystem feature."""
+
+from .service import WorkspaceService
+
+__all__ = ["WorkspaceService"]

forgemcp/workspace/diff.py

@@ -0,0 +1,181 @@
+"""Typed, immutable line diffs for workspace mutation results."""
+
+import difflib
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from .path import WorkspacePath
+from .service import (
+    FileEditResult,
+    FileWriteResult,
+    ResultProvider,
+    WorkspaceService,
+    read_text,
+)
+
+
+class DiffLine(BaseModel):
+    kind: Literal["context", "added", "removed"]
+    before_line: int | None = Field(ge=1)
+    after_line: int | None = Field(ge=1)
+    text: str
+    spans: list[tuple[int, int]] = Field(default_factory=list)
+
+
+class DiffRange(BaseModel):
+    kind: Literal["replace", "insert", "delete"]
+    before_start: int = Field(ge=1)
+    before_count: int = Field(ge=0)
+    after_start: int = Field(ge=1)
+    after_count: int = Field(ge=0)
+
+
+class DiffHunk(BaseModel):
+    before_start: int = Field(ge=1)
+    before_count: int = Field(ge=0)
+    after_start: int = Field(ge=1)
+    after_count: int = Field(ge=0)
+    lines: list[DiffLine]
+
+
+class FileDiff(BaseModel):
+    path: WorkspacePath
+    changes: list[DiffRange]
+    hunks: list[DiffHunk]
+
+
+def create_diff(path: WorkspacePath, before_text: str, after_text: str) -> FileDiff:
+    """Preserve exact line text, including line endings and a missing final newline."""
+    before = before_text.splitlines(keepends=True)
+    after = after_text.splitlines(keepends=True)
+    matcher = difflib.SequenceMatcher(
+        None,
+        before,
+        after,
+        autojunk=False,
+    )
+    changes = [
+        DiffRange(
+            kind=kind,
+            before_start=i + 1,
+            before_count=j - i,
+            after_start=k + 1,
+            after_count=l - k,
+        )
+        for kind, i, j, k, l in matcher.get_opcodes()
+        if kind != "equal"
+    ]
+    hunks = []
+    for group in matcher.get_grouped_opcodes(3):
+        lines = []
+        for kind, i, j, k, l in group:
+            if kind == "equal":
+                lines.extend(
+                    DiffLine(
+                        kind="context",
+                        before_line=number + 1,
+                        after_line=k + number - i + 1,
+                        text=before[number],
+                    )
+                    for number in range(i, j)
+                )
+            else:
+                before_spans = {}
+                after_spans = {}
+                if kind == "replace":
+                    for old, new in zip(range(i, j), range(k, l)):
+                        character_diff = difflib.SequenceMatcher(
+                            None,
+                            before[old],
+                            after[new],
+                            autojunk=False,
+                        )
+                        before_spans[old] = []
+                        after_spans[new] = []
+                        for operation, a, b, c, d in character_diff.get_opcodes():
+                            if operation != "equal":
+                                before_spans[old].append((a, b))
+                                after_spans[new].append((c, d))
+                lines.extend(
+                    DiffLine(
+                        kind="removed",
+                        before_line=number + 1,
+                        after_line=None,
+                        text=before[number],
+                        spans=before_spans.get(number, [(0, len(before[number]))]),
+                    )
+                    for number in range(i, j)
+                )
+                lines.extend(
+                    DiffLine(
+                        kind="added",
+                        before_line=None,
+                        after_line=number + 1,
+                        text=after[number],
+                        spans=after_spans.get(number, [(0, len(after[number]))]),
+                    )
+                    for number in range(k, l)
+                )
+        hunks.append(
+            DiffHunk(
+                before_start=group[0][1] + 1,
+                before_count=group[-1][2] - group[0][1],
+                after_start=group[0][3] + 1,
+                after_count=group[-1][4] - group[0][3],
+                lines=lines,
+            )
+        )
+    return FileDiff(path=path, changes=changes, hunks=hunks)
+
+
+class DiffProvider(ResultProvider[str]):
+    """Capture the old text before a write/edit and publish its immutable diff."""
+
+    def __init__(self, workspace: WorkspaceService) -> None:
+        self.workspace = workspace
+
+    async def before_workspace_write_file(
+        self,
+        call_id: str,
+        path: WorkspacePath,
+        text: str,
+    ) -> str:
+        candidate = self.workspace.resolve_workspace_path(path)
+        return read_text(candidate, path) if candidate.exists() else ""
+
+    async def after_workspace_write_file(
+        self,
+        call_id: str,
+        context: str,
+        result: FileWriteResult,
+    ) -> str:
+        return self.save_diff(call_id, result.path, context)
+
+    async def before_workspace_edit_file(
+        self,
+        call_id: str,
+        path: WorkspacePath,
+        old_text: str,
+        new_text: str,
+        replace_all: bool,
+    ) -> str:
+        return read_text(self.workspace.resolve_workspace_path(path), path)
+
+    async def after_workspace_edit_file(
+        self,
+        call_id: str,
+        context: str,
+        result: FileEditResult,
+    ) -> str:
+        return self.save_diff(call_id, result.path, context)
+
+    def save_diff(self, call_id: str, path: WorkspacePath, before: str) -> str:
+        after = read_text(self.workspace.resolve_workspace_path(path), path)
+        diff = create_diff(path, before, after)
+        return self.workspace.save_result_resource(
+            call_id,
+            "diff",
+            "application/json",
+            diff.model_dump_json(),
+        )

forgemcp/workspace/errors.py

@@ -0,0 +1,5 @@
+"""Workspace feature errors."""
+
+
+class WorkspaceError(Exception):
+    """Base class for expected workspace failures."""

forgemcp/workspace/metadata.py

@@ -0,0 +1,87 @@
+"""Platform-specific file ownership; unavailable accounts are represented by None."""
+
+import os
+from pathlib import Path
+
+
+def file_owner(path: Path) -> str | None:
+    if os.name != "nt":
+        try:
+            return path.owner()
+        except (KeyError, OSError, NotImplementedError):
+            return None
+
+    import ctypes
+    from ctypes import wintypes
+
+    advapi = ctypes.WinDLL("advapi32", use_last_error=True)
+    kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+    owner, descriptor = ctypes.c_void_p(), ctypes.c_void_p()
+    get_security = advapi.GetNamedSecurityInfoW
+    get_security.argtypes = [
+        wintypes.LPWSTR,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        ctypes.POINTER(ctypes.c_void_p),
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_void_p),
+    ]
+    get_security.restype = wintypes.DWORD
+    lookup = advapi.LookupAccountSidW
+    lookup.argtypes = [
+        wintypes.LPCWSTR,
+        ctypes.c_void_p,
+        wintypes.LPWSTR,
+        ctypes.POINTER(wintypes.DWORD),
+        wintypes.LPWSTR,
+        ctypes.POINTER(wintypes.DWORD),
+        ctypes.POINTER(wintypes.DWORD),
+    ]
+    lookup.restype = wintypes.BOOL
+    kernel.LocalFree.argtypes = [ctypes.c_void_p]
+    kernel.LocalFree.restype = ctypes.c_void_p
+    if get_security(
+        str(path),
+        1,
+        1,
+        ctypes.byref(owner),
+        None,
+        None,
+        None,
+        ctypes.byref(descriptor),
+    ):
+        return None
+    try:
+        name_size, domain_size, kind = (
+            wintypes.DWORD(),
+            wintypes.DWORD(),
+            wintypes.DWORD(),
+        )
+        lookup(
+            None,
+            owner,
+            None,
+            ctypes.byref(name_size),
+            None,
+            ctypes.byref(domain_size),
+            ctypes.byref(kind),
+        )
+        if not name_size.value:
+            return None
+        name = ctypes.create_unicode_buffer(name_size.value)
+        domain = ctypes.create_unicode_buffer(max(1, domain_size.value))
+        if not lookup(
+            None,
+            owner,
+            name,
+            ctypes.byref(name_size),
+            domain,
+            ctypes.byref(domain_size),
+            ctypes.byref(kind),
+        ):
+            return None
+        return f"{domain.value}\\{name.value}" if domain.value else name.value
+    finally:
+        kernel.LocalFree(descriptor)

forgemcp/workspace/path.py

@@ -0,0 +1,71 @@
+"""Qualified managed paths and explicit external locations shared by modules."""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath, PureWindowsPath
+from typing import Literal, cast
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+
+class WorkspacePath(str):
+    """A project/storage path, or root/ followed by an absolute native path."""
+
+    def __new__(cls, value: str) -> WorkspacePath:
+        instance = super().__new__(cls, value)
+        instance.validate_path()
+        return instance
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls,
+        source_type: object,
+        handler: GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls,
+            core_schema.str_schema(),
+            serialization=core_schema.to_string_ser_schema(),
+        )
+
+    def validate_path(self) -> WorkspacePath:
+        area, separator, relative = self.partition("/")
+        if area not in ("project", "storage", "root") or not separator:
+            raise ValueError("Workspace path must start with project/, storage/, or root/.")
+        if "\\" in relative or "\0" in relative:
+            raise ValueError("Workspace paths use '/' and cannot contain NUL.")
+        windows = PureWindowsPath(relative)
+        if area == "root":
+            native = windows if windows.drive else PurePosixPath(relative)
+            if (
+                not native.is_absolute()
+                or native.as_posix() != relative
+                or any(part in (".", "..") for part in relative.split("/"))
+                or relative.startswith(("//?/", "//./"))
+            ):
+                raise ValueError("root/ must be followed by a canonical absolute path.")
+            return self
+        if windows.drive or windows.root or any(
+            part in ("", ".", "..") for part in relative.split("/") if relative
+        ):
+            raise ValueError("Workspace path must contain a canonical relative path.")
+        return self
+
+    @property
+    def area(self) -> Literal["project", "storage", "root"]:
+        return cast(Literal["project", "storage", "root"], self.partition("/")[0])
+
+    @property
+    def relative(self) -> str:
+        # The root/ suffix stays absolute and is rejected by managed-root APIs.
+        return self.partition("/")[2] or "."
+
+    @property
+    def absolute(self) -> Path:
+        if self.area != "root":
+            raise ValueError("Only root/ paths contain a native absolute path.")
+        path = Path(self.relative)
+        if not path.is_absolute():
+            raise ValueError("The external path is not absolute on this host.")
+        return path

forgemcp/workspace/providers.py

@@ -0,0 +1,25 @@
+"""Invocation contexts and links to immutable Workspace provider resources."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ResultResource(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    uri: str
+    mime_type: Literal["application/json", "text/markdown"]
+
+
+class ResultResources(BaseModel):
+    resources: dict[str, ResultResource] = Field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ProviderCall:
+    id: str
+    tool_name: str
+    contexts: Mapping[str, object]