golf-mcp 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

golf/core/platform.py

@@ -0,0 +1,180 @@
+"""Platform registration for Golf MCP projects."""
+
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import httpx
+from rich.console import Console
+
+from golf import __version__
+from golf.core.config import Settings
+from golf.core.parser import ComponentType, ParsedComponent
+
+console = Console()
+
+
+async def register_project_with_platform(
+    project_path: Path,
+    settings: Settings,
+    components: dict[ComponentType, list[ParsedComponent]],
+) -> bool:
+    """Register project with Golf platform during prod build.
+
+    Args:
+        project_path: Path to the project root
+        settings: Project settings
+        components: Parsed components dictionary
+
+    Returns:
+        True if registration succeeded or was skipped, False if failed
+    """
+    # Check if platform integration is enabled
+    api_key = os.getenv("GOLF_API_KEY")
+    if not api_key:
+        return True  # Skip silently if no API key
+
+    # Require explicit server ID
+    server_id = os.getenv("GOLF_SERVER_ID")
+    if not server_id:
+        console.print(
+            "[yellow]Warning: Platform registration skipped - GOLF_SERVER_ID environment variable required[/yellow]"
+        )
+        return True  # Skip registration but don't fail build
+
+    # Build metadata payload
+    metadata = {
+        "project_name": settings.name,
+        "description": settings.description,
+        "server_id": server_id,
+        "components": _build_component_list(components, project_path),
+        "build_timestamp": datetime.utcnow().isoformat(),
+        "golf_version": __version__,
+        "component_counts": _get_component_counts(components),
+        "server_config": {
+            "host": settings.host,
+            "port": settings.port,
+            "transport": settings.transport,
+            "auth_enabled": bool(settings.auth),
+            "telemetry_enabled": settings.opentelemetry_enabled,
+            "health_check_enabled": settings.health_check_enabled,
+        },
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.post(
+                "http://localhost:8000/api/resources",
+                json=metadata,
+                headers={
+                    "X-Golf-Key": api_key,
+                    "Content-Type": "application/json",
+                    "User-Agent": f"Golf-MCP/{__version__}",
+                },
+            )
+            response.raise_for_status()
+
+        console.print("[green]✓[/green] Registered with Golf platform")
+        return True
+
+    except httpx.TimeoutException:
+        console.print("[yellow]Warning: Platform registration timed out[/yellow]")
+        return False
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 401:
+            console.print(
+                "[yellow]Warning: Platform registration failed - invalid API key[/yellow]"
+            )
+        elif e.response.status_code == 403:
+            console.print(
+                "[yellow]Warning: Platform registration failed - access denied[/yellow]"
+            )
+        else:
+            console.print(
+                f"[yellow]Warning: Platform registration failed - HTTP {e.response.status_code}[/yellow]"
+            )
+        return False
+    except Exception as e:
+        console.print(f"[yellow]Warning: Platform registration failed: {e}[/yellow]")
+        return False  # Don't fail the build
+
+
+def _build_component_list(
+    components: dict[ComponentType, list[ParsedComponent]],
+    project_path: Path,
+) -> list[dict[str, Any]]:
+    """Convert parsed components to platform format.
+
+    Args:
+        components: Dictionary of parsed components by type
+        project_path: Path to the project root
+
+    Returns:
+        List of component metadata dictionaries
+    """
+    result = []
+
+    for comp_type, comp_list in components.items():
+        for comp in comp_list:
+            # Start with basic component data
+            component_data = {
+                "name": comp.name,
+                "type": comp_type.value,
+                "description": comp.docstring,
+                "entry_function": comp.entry_function,
+                "parent_module": comp.parent_module,
+            }
+
+            # Add file path relative to project root if available
+            if comp.file_path:
+                try:
+                    file_path = Path(comp.file_path)
+                    # Use the provided project_path for relative calculation
+                    rel_path = file_path.relative_to(project_path)
+                    component_data["file_path"] = str(rel_path)
+                except ValueError:
+                    # If relative_to fails, try to find a common path or use filename
+                    component_data["file_path"] = Path(comp.file_path).name
+
+            # Add schema information only if available and not None
+            if hasattr(comp, "input_schema") and comp.input_schema:
+                component_data["input_schema"] = comp.input_schema
+            if hasattr(comp, "output_schema") and comp.output_schema:
+                component_data["output_schema"] = comp.output_schema
+
+            # Add component-specific fields only if they have values
+            if comp_type == ComponentType.RESOURCE:
+                if hasattr(comp, "uri_template") and comp.uri_template:
+                    component_data["uri_template"] = comp.uri_template
+
+            elif comp_type == ComponentType.TOOL:
+                if hasattr(comp, "annotations") and comp.annotations:
+                    component_data["annotations"] = comp.annotations
+
+            # Add parameters only if they exist and are not empty
+            if hasattr(comp, "parameters") and comp.parameters:
+                component_data["parameters"] = comp.parameters
+
+            result.append(component_data)
+
+    return result
+
+
+def _get_component_counts(
+    components: dict[ComponentType, list[ParsedComponent]],
+) -> dict[str, int]:
+    """Get component counts by type.
+
+    Args:
+        components: Dictionary of parsed components by type
+
+    Returns:
+        Dictionary with counts for each component type
+    """
+    return {
+        "tools": len(components.get(ComponentType.TOOL, [])),
+        "resources": len(components.get(ComponentType.RESOURCE, [])),
+        "prompts": len(components.get(ComponentType.PROMPT, [])),
+        "total": sum(len(comp_list) for comp_list in components.values()),
+    }

golf/core/telemetry.py

@@ -109,9 +109,9 @@ def is_telemetry_enabled() -> bool:
         _telemetry_enabled = saved_preference
         return saved_preference
 
-    # Default to enabled (opt-out model)
-    _telemetry_enabled = True
-    return True
+    # Default to disabled (opt-in model)
+    _telemetry_enabled = False
+    return False
 
 
 def set_telemetry_enabled(enabled: bool, persist: bool = True) -> None:
@@ -209,13 +209,24 @@ def initialize_telemetry() -> None:
         posthog.disabled = False
         posthog.debug = False
 
+        # Disable IP collection and GeoIP enrichment at the SDK level
+        posthog.set_global_event_properties(
+            {
+                "$ip": "0",  # Override IP with dummy value to prevent collection
+                "$geoip_disable": True,  # Disable all GeoIP enrichment
+            }
+        )
+
     except Exception:
         # Telemetry should never break the application
         pass
 
 
 def track_event(event_name: str, properties: dict[str, Any] | None = None) -> None:
-    """Track an anonymous event with minimal data.
+    """Track an anonymous event with NO IP address or geolocation data.
+
+    IP collection and GeoIP enrichment are disabled at the SDK level to ensure
+    complete privacy protection. No IP addresses or location data ever reach PostHog.
 
     Args:
         event_name: Name of the event (e.g., "cli_init", "cli_build")
@@ -257,8 +268,16 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
                 }
             }
 
-            # Identify the user with properties
-            posthog.identify(distinct_id=anonymous_id, properties=person_properties)
+            # Identify the user with properties (IP tracking disabled)
+            posthog.identify(
+                distinct_id=anonymous_id,
+                properties={
+                    **person_properties,
+                    # Explicitly disable IP tracking in identify call
+                    "$ip": "0",
+                    "$geoip_disable": True,
+                },
+            )
 
             _user_identified = True
 
@@ -267,8 +286,9 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
             "golf_version": __version__,
             "python_version": f"{platform.python_version_tuple()[0]}.{platform.python_version_tuple()[1]}",
             "os": platform.system(),
-            # Explicitly disable IP tracking
-            "$ip": None,
+            # Explicitly disable IP tracking and GeoIP enrichment
+            "$ip": "0",  # Override IP to prevent collection
+            "$geoip_disable": True,  # Disable GeoIP enrichment
         }
 
         # Filter properties to only include safe ones

golf/examples/api_key/.env.example

@@ -1,5 +1 @@
-GOLF_CLIENT_ID="default-client-id"
-GOLF_CLIENT_SECRET="default-secret"
-JWT_SECRET="example-jwt-secret-for-development-only"
-OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318/v1/traces"
-OTEL_SERVICE_NAME="golf-mcp"
+#GOLF_API_KEY=<your-api-key>

golf/examples/api_key/README.md

@@ -7,26 +7,26 @@ This example demonstrates how to build a GitHub API MCP server using Golf's API
 This MCP server provides tools for:
 
 - **Repository Management** 
-  - `list-repos` - List repositories for users, organizations, or the authenticated user
+  - `list_repos` - List repositories for users, organizations, or the authenticated user
   
 - **Issue Management** 
-  - `create-issues` - Create new issues with labels
-  - `list-issues` - List and filter issues by state and labels
+  - `create_issues` - Create new issues with labels
+  - `list_issues` - List and filter issues by state and labels
   
 - **Code Search**
-  - `code-search` - Search for code across GitHub with language and repository filters
+  - `code_search` - Search for code across GitHub with language and repository filters
   
 - **User Information**
-  - `get-users` - Get user profiles or verify authentication
+  - `get_users` - Get user profiles or verify authentication
 
 ## Tool Naming Convention
 
 Golf automatically derives tool names from the file structure:
-- `tools/issues/create.py` → `create-issues`
-- `tools/issues/list.py` → `list-issues`
-- `tools/repos/list.py` → `list-repos`
-- `tools/search/code.py` → `code-search`
-- `tools/users/get.py` → `get-users`
+- `tools/issues/create.py` → `create_issues`
+- `tools/issues/list.py` → `list_issues`
+- `tools/repos/list.py` → `list_repos`
+- `tools/search/code.py` → `code_search`
+- `tools/users/get.py` → `get_users`
 
 ## Configuration
 

golf/examples/api_key/golf.json

@@ -4,9 +4,5 @@
   "host": "127.0.0.1",
   "port": 3000,
   "transport": "sse",
-  "health_check_enabled": false,
-  "health_check_path": "/health",
-  "health_check_response": "OK",
-  "opentelemetry_enabled": true,
-  "opentelemetry_default_exporter": "otlp_http"
+  "opentelemetry_enabled": false
 } 

golf/examples/basic/.env.example

@@ -1,5 +1,4 @@
-GOLF_CLIENT_ID="default-client-id"
-GOLF_CLIENT_SECRET="default-secret"
+GITHUB_CLIENT_ID="default-client-id"
+GITHUB_CLIENT_SECRET="default-secret"
 JWT_SECRET="example-jwt-secret-for-development-only"
-OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318/v1/traces"
-OTEL_SERVICE_NAME="golf-mcp"
+#GOLF_API_KEY=<your-api-key>

golf/examples/basic/golf.json

@@ -4,9 +4,5 @@
   "host": "127.0.0.1",
   "port": 3000,
   "transport": "sse",
-  "health_check_enabled": false,
-  "health_check_path": "/health",
-  "health_check_response": "OK",
-  "opentelemetry_enabled": true,
-  "opentelemetry_default_exporter": "otlp_http"
+  "opentelemetry_enabled": false
 } 

golf/metrics/__init__.py

@@ -0,0 +1,10 @@
+"""Golf metrics module for Prometheus-compatible metrics collection."""
+
+from golf.metrics.collector import MetricsCollector, get_metrics_collector
+from golf.metrics.registry import init_metrics
+
+__all__ = [
+    "MetricsCollector",
+    "get_metrics_collector",
+    "init_metrics",
+]

golf/metrics/collector.py

@@ -0,0 +1,239 @@
+"""Metrics collector for Golf MCP servers."""
+
+from typing import Optional
+
+# Global metrics collector instance
+_metrics_collector: Optional["MetricsCollector"] = None
+
+
+class MetricsCollector:
+    """Collects metrics for Golf MCP servers using Prometheus client."""
+
+    def __init__(self, enabled: bool = False) -> None:
+        """Initialize the metrics collector.
+
+        Args:
+            enabled: Whether metrics collection is enabled
+        """
+        self.enabled = enabled
+        self._metrics = {}
+
+        if self.enabled:
+            self._init_prometheus_metrics()
+
+    def _init_prometheus_metrics(self) -> None:
+        """Initialize Prometheus metrics if enabled."""
+        try:
+            from prometheus_client import Counter, Histogram, Gauge
+
+            # Tool execution metrics
+            self._metrics["tool_executions"] = Counter(
+                "golf_tool_executions_total",
+                "Total number of tool executions",
+                ["tool_name", "status"],
+            )
+
+            self._metrics["tool_duration"] = Histogram(
+                "golf_tool_duration_seconds",
+                "Tool execution duration in seconds",
+                ["tool_name"],
+            )
+
+            # HTTP request metrics
+            self._metrics["http_requests"] = Counter(
+                "golf_http_requests_total",
+                "Total number of HTTP requests",
+                ["method", "status_code", "path"],
+            )
+
+            self._metrics["http_duration"] = Histogram(
+                "golf_http_request_duration_seconds",
+                "HTTP request duration in seconds",
+                ["method", "path"],
+            )
+
+            # Resource access metrics
+            self._metrics["resource_reads"] = Counter(
+                "golf_resource_reads_total",
+                "Total number of resource reads",
+                ["resource_uri"],
+            )
+
+            # Prompt generation metrics
+            self._metrics["prompt_generations"] = Counter(
+                "golf_prompt_generations_total",
+                "Total number of prompt generations",
+                ["prompt_name"],
+            )
+
+            # Error metrics
+            self._metrics["errors"] = Counter(
+                "golf_errors_total",
+                "Total number of errors",
+                ["component_type", "error_type"],
+            )
+
+            # Session metrics
+            self._metrics["sessions_total"] = Counter(
+                "golf_sessions_total", "Total number of sessions created"
+            )
+
+            self._metrics["session_duration"] = Histogram(
+                "golf_session_duration_seconds", "Session duration in seconds"
+            )
+
+            # System metrics
+            self._metrics["uptime"] = Gauge(
+                "golf_uptime_seconds", "Server uptime in seconds"
+            )
+
+        except ImportError:
+            # Prometheus client not available, disable metrics
+            self.enabled = False
+
+    def increment_tool_execution(self, tool_name: str, status: str) -> None:
+        """Record a tool execution.
+
+        Args:
+            tool_name: Name of the tool that was executed
+            status: Execution status ('success' or 'error')
+        """
+        if not self.enabled or "tool_executions" not in self._metrics:
+            return
+
+        self._metrics["tool_executions"].labels(
+            tool_name=tool_name, status=status
+        ).inc()
+
+    def record_tool_duration(self, tool_name: str, duration: float) -> None:
+        """Record tool execution duration.
+
+        Args:
+            tool_name: Name of the tool
+            duration: Execution duration in seconds
+        """
+        if not self.enabled or "tool_duration" not in self._metrics:
+            return
+
+        self._metrics["tool_duration"].labels(tool_name=tool_name).observe(duration)
+
+    def increment_http_request(self, method: str, status_code: int, path: str) -> None:
+        """Record an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            status_code: HTTP status code
+            path: Request path
+        """
+        if not self.enabled or "http_requests" not in self._metrics:
+            return
+
+        self._metrics["http_requests"].labels(
+            method=method, status_code=str(status_code), path=path
+        ).inc()
+
+    def record_http_duration(self, method: str, path: str, duration: float) -> None:
+        """Record HTTP request duration.
+
+        Args:
+            method: HTTP method
+            path: Request path
+            duration: Request duration in seconds
+        """
+        if not self.enabled or "http_duration" not in self._metrics:
+            return
+
+        self._metrics["http_duration"].labels(method=method, path=path).observe(
+            duration
+        )
+
+    def increment_resource_read(self, resource_uri: str) -> None:
+        """Record a resource read.
+
+        Args:
+            resource_uri: URI of the resource that was read
+        """
+        if not self.enabled or "resource_reads" not in self._metrics:
+            return
+
+        self._metrics["resource_reads"].labels(resource_uri=resource_uri).inc()
+
+    def increment_prompt_generation(self, prompt_name: str) -> None:
+        """Record a prompt generation.
+
+        Args:
+            prompt_name: Name of the prompt that was generated
+        """
+        if not self.enabled or "prompt_generations" not in self._metrics:
+            return
+
+        self._metrics["prompt_generations"].labels(prompt_name=prompt_name).inc()
+
+    def increment_error(self, component_type: str, error_type: str) -> None:
+        """Record an error.
+
+        Args:
+            component_type: Type of component ('tool', 'resource', 'prompt', 'http')
+            error_type: Type of error ('timeout', 'auth_error', 'validation_error', etc.)
+        """
+        if not self.enabled or "errors" not in self._metrics:
+            return
+
+        self._metrics["errors"].labels(
+            component_type=component_type, error_type=error_type
+        ).inc()
+
+    def increment_session(self) -> None:
+        """Record a new session."""
+        if not self.enabled or "sessions_total" not in self._metrics:
+            return
+
+        self._metrics["sessions_total"].inc()
+
+    def record_session_duration(self, duration: float) -> None:
+        """Record session duration.
+
+        Args:
+            duration: Session duration in seconds
+        """
+        if not self.enabled or "session_duration" not in self._metrics:
+            return
+
+        self._metrics["session_duration"].observe(duration)
+
+    def set_uptime(self, seconds: float) -> None:
+        """Set the server uptime.
+
+        Args:
+            seconds: Server uptime in seconds
+        """
+        if not self.enabled or "uptime" not in self._metrics:
+            return
+
+        self._metrics["uptime"].set(seconds)
+
+
+def init_metrics_collector(enabled: bool = False) -> MetricsCollector:
+    """Initialize the global metrics collector.
+
+    Args:
+        enabled: Whether to enable metrics collection
+
+    Returns:
+        The initialized metrics collector
+    """
+    global _metrics_collector
+    _metrics_collector = MetricsCollector(enabled=enabled)
+    return _metrics_collector
+
+
+def get_metrics_collector() -> MetricsCollector:
+    """Get the global metrics collector instance.
+
+    Returns:
+        The metrics collector, or a disabled one if not initialized
+    """
+    global _metrics_collector
+    if _metrics_collector is None:
+        _metrics_collector = MetricsCollector(enabled=False)
+    return _metrics_collector

golf/metrics/registry.py

@@ -0,0 +1,12 @@
+"""Metrics registry for Golf MCP servers."""
+
+from golf.metrics.collector import init_metrics_collector
+
+
+def init_metrics(enabled: bool = False) -> None:
+    """Initialize the metrics system.
+
+    Args:
+        enabled: Whether to enable metrics collection
+    """
+    init_metrics_collector(enabled=enabled)