Add ping tool, runtime check CLI, and bump to v0.2.0

- Add lightweight ping tool for MCP parity (#18)
- Add check-runtime subcommand and runtime_check module for
  verifying TiGL/TiXI/OpenCASCADE/Gmsh availability (#17)
- Ship environment.yml for one-command conda setup
- Add tigl-mcp-check script alias
- Bump version from 0.1.2 to 0.2.0

Made-with: Cursor

Author: Kugel-Blitz-13

environment.yml

@@ -0,0 +1,19 @@
+name: tigl-mcp
+channels:
+  - dlr-sc
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.12
+  - tigl3
+  - tixi3
+  - python-tigl3
+  - python-tixi3
+  - pythonocc-core
+  - gmsh
+  - python-gmsh
+  - meshio
+  - numpy
+  - pip
+  - pip:
+      - -e .

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tigl-mcp"
-version = "0.1.2"
+version = "0.2.0"
 description = "An MCP around the TiGL library"
 authors = [
   { name = "The Design Research Collective", email = "ask-drc@cmu.edu" }
@@ -43,6 +43,7 @@ dev = [
 
 [project.scripts]
 tigl-mcp = "tigl_mcp.main:main"
+tigl-mcp-check = "tigl_mcp.runtime_check:print_runtime_report"
 
 [tool.ruff]
 line-length = 88

src/tigl_mcp/main.py

@@ -45,6 +45,13 @@ def build_parser() -> argparse.ArgumentParser:
 
 def main(argv: Sequence[str] | None = None) -> int:
     """Register tools and start the FastMCP server."""
+    raw = list(argv) if argv is not None else __import__("sys").argv[1:]
+    if raw and raw[0] == "check-runtime":
+        from tigl_mcp.runtime_check import print_runtime_report
+
+        print_runtime_report()
+        return 0
+
     parser = build_parser()
     args = parser.parse_args(argv)
 

src/tigl_mcp/runtime_check.py

@@ -0,0 +1,135 @@
+"""Runtime validation for TiGL/TiXI native dependencies."""
+
+from __future__ import annotations
+
+import shutil
+import sys
+
+
+CONDA_INSTALL_CMD = (
+    "conda install -c dlr-sc -c conda-forge tigl3 tixi3 python-tigl3 python-tixi3"
+)
+
+DOCKER_BUILD_CMD = "docker build -t tigl-mcp:dev ."
+
+INSTALL_GUIDE = f"""\
+TiGL/TiXI native bindings are not available in this Python environment.
+
+To install, choose one of the following options:
+
+  1. Conda (recommended):
+     {CONDA_INSTALL_CMD}
+
+  2. Conda environment file (ships with this repo):
+     conda env create -f environment.yml
+     conda activate tigl-mcp
+
+  3. Docker (includes TiGL + Gmsh + SU2):
+     {DOCKER_BUILD_CMD}
+
+  4. Pre-built binaries from DLR:
+     https://github.com/DLR-SC/tigl/releases
+
+The server will still start in stub mode (synthetic geometry) without
+these bindings, but real STEP/STL export requires the native runtime.
+"""
+
+
+def check_tigl_runtime() -> dict[str, object]:
+    """Probe the environment for TiGL and TiXI availability.
+
+    Returns a dict suitable for printing or returning as a tool response.
+    """
+    results: dict[str, object] = {
+        "python": sys.version,
+        "platform": sys.platform,
+    }
+
+    # TiXI
+    try:
+        from tixi3 import tixi3wrapper  # type: ignore[import-untyped]
+
+        tixi_h = tixi3wrapper.Tixi3()
+        results["tixi3"] = {"available": True, "version": getattr(tixi_h, "version", "unknown")}
+    except Exception as exc:
+        results["tixi3"] = {"available": False, "error": str(exc)}
+
+    # TiGL
+    try:
+        from tigl3 import tigl3wrapper  # type: ignore[import-untyped]
+
+        results["tigl3"] = {"available": True, "module": tigl3wrapper.__name__}
+    except Exception as exc:
+        results["tigl3"] = {"available": False, "error": str(exc)}
+
+    # OpenCASCADE (used for watertight STEP export)
+    try:
+        from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeSolid  # type: ignore[import-untyped]  # noqa: F401
+
+        results["opencascade"] = {"available": True}
+    except Exception as exc:
+        results["opencascade"] = {"available": False, "error": str(exc)}
+
+    # Gmsh (used for meshing in the pipeline)
+    gmsh_bin = shutil.which("gmsh")
+    try:
+        import gmsh as _gmsh  # type: ignore[import-untyped]  # noqa: F401
+
+        results["gmsh"] = {
+            "available": True,
+            "python_api": True,
+            "cli": gmsh_bin or "not on PATH",
+        }
+    except Exception:
+        results["gmsh"] = {
+            "available": gmsh_bin is not None,
+            "python_api": False,
+            "cli": gmsh_bin or "not on PATH",
+        }
+
+    all_ok = all(
+        isinstance(v, dict) and v.get("available", False)
+        for v in results.values()
+        if isinstance(v, dict)
+    )
+    results["all_ok"] = all_ok
+
+    return results
+
+
+def print_runtime_report() -> None:
+    """Print a human-readable runtime diagnostics report."""
+    report = check_tigl_runtime()
+
+    print("=" * 60)
+    print("  TiGL MCP Runtime Check")
+    print("=" * 60)
+    print(f"  Python:      {report['python']}")
+    print(f"  Platform:    {report['platform']}")
+    print()
+
+    for name in ("tixi3", "tigl3", "opencascade", "gmsh"):
+        info = report.get(name, {})
+        if not isinstance(info, dict):
+            continue
+        ok = info.get("available", False)
+        status = "OK" if ok else "MISSING"
+        marker = "+" if ok else "x"
+        line = f"  [{marker}] {name:15s} {status}"
+        if not ok and "error" in info:
+            line += f"  ({info['error'][:80]})"
+        if ok and "version" in info:
+            line += f"  (v{info['version']})"
+        if "cli" in info:
+            line += f"  [cli: {info['cli']}]"
+        print(line)
+
+    print()
+    if report.get("all_ok"):
+        print("  All dependencies found. Full TiGL geometry export is available.")
+    else:
+        print("  Some dependencies are missing. The server will run in stub mode.")
+        print()
+        print(INSTALL_GUIDE)
+
+    print("=" * 60)

src/tigl_mcp/tools/__init__.py

@@ -22,6 +22,7 @@
     get_high_level_parameters_tool,
     set_high_level_parameters_tool,
 )
+from tigl_mcp.tools.ping import ping_tool
 from tigl_mcp.tools.sampling import (
     intersect_components_tool,
     intersect_with_plane_tool,
@@ -32,6 +33,7 @@
 def build_tools(session_manager: SessionManager) -> list[ToolDefinition]:
     """Instantiate all tool definitions with the provided session manager."""
     return [
+        ping_tool(session_manager),
         open_cpacs_tool(session_manager),
         close_cpacs_tool(session_manager),
         get_configuration_summary_tool(session_manager),

src/tigl_mcp/tools/ping.py

@@ -0,0 +1,45 @@
+"""Lightweight health-check tool for the TiGL MCP server."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from tigl_mcp.tooling import ToolDefinition, ToolParameters
+
+
+class PingParams(ToolParameters):
+    """Request payload for the ping tool."""
+
+    message: str | None = None
+
+
+def ping_tool(_session_manager: Any = None) -> ToolDefinition:
+    """Build a ping tool definition (session_manager is accepted but unused)."""
+
+    def handler(params: dict[str, Any]) -> dict[str, Any]:
+        now = datetime.now(UTC).isoformat()
+        reply = params.get("message") or "pong"
+        return {
+            "ok": True,
+            "message": reply,
+            "server": "tigl-mcp",
+            "timestamp": now,
+        }
+
+    return ToolDefinition(
+        name="ping",
+        description="Lightweight health check that confirms the server is reachable without requiring a CPACS session or TiGL runtime.",
+        parameters_model=PingParams,
+        handler=handler,
+        output_schema={
+            "type": "object",
+            "properties": {
+                "ok": {"type": "boolean"},
+                "message": {"type": "string"},
+                "server": {"type": "string"},
+                "timestamp": {"type": "string", "format": "date-time"},
+            },
+            "required": ["ok", "message", "server", "timestamp"],
+        },
+    )