gobby 0.2.5__py3-none-any.whl

gobby/llm/service.py

@@ -0,0 +1,236 @@
+"""
+LLM Service for multi-provider support.
+
+Provides a unified interface for accessing multiple LLM providers (Claude, Codex,
+Gemini, LiteLLM) based on the multi-provider config structure with feature-specific
+provider routing.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.config.app import (
+        DaemonConfig,
+    )
+    from gobby.llm.base import LLMProvider
+
+logger = logging.getLogger(__name__)
+
+
+# Type alias for feature configs that have provider/model/prompt fields
+FeatureConfig = "SessionSummaryConfig | TitleSynthesisConfig | RecommendToolsConfig"
+
+
+class LLMService:
+    """
+    Service for managing multiple LLM providers.
+
+    Provides unified access to configured LLM providers and routes requests
+    to the appropriate provider based on feature configuration.
+
+    Example usage:
+        # Initialize with config
+        service = LLMService(config)
+
+        # Get provider by name
+        claude = service.get_provider("claude")
+
+        # Get provider for a feature (uses feature's provider/model config)
+        provider, model, prompt = service.get_provider_for_feature(config.session_summary)
+
+        # Use provider
+        result = await provider.generate_summary(context, prompt_template=prompt)
+    """
+
+    def __init__(self, config: "DaemonConfig"):
+        """
+        Initialize LLM service with configuration.
+
+        Args:
+            config: Client configuration containing llm_providers settings.
+
+        Raises:
+            ValueError: If llm_providers is not configured.
+        """
+        self._config = config
+        self._providers: dict[str, LLMProvider] = {}
+        self._initialized_providers: set[str] = set()
+
+        if not config.llm_providers:
+            raise ValueError("llm_providers config is required for LLMService")
+
+        # Log enabled providers
+        enabled = config.llm_providers.get_enabled_providers()
+        logger.debug(f"LLMService initialized with providers: {enabled}")
+
+    def _get_provider_instance(self, name: str) -> "LLMProvider":
+        """
+        Get or create a provider instance by name (lazy initialization).
+
+        Args:
+            name: Provider name (claude, codex, gemini, litellm)
+
+        Returns:
+            LLMProvider instance
+
+        Raises:
+            ValueError: If provider is not configured or not supported
+        """
+        if name in self._providers:
+            return self._providers[name]
+
+        # Check if provider is configured
+        if not self._config.llm_providers:
+            raise ValueError("llm_providers not configured")
+
+        provider_config = getattr(self._config.llm_providers, name, None)
+        if not provider_config:
+            enabled = self._config.llm_providers.get_enabled_providers()
+            raise ValueError(f"Provider '{name}' is not configured. Available providers: {enabled}")
+
+        # Create provider instance based on name
+        provider: LLMProvider
+
+        if name == "claude":
+            from gobby.llm.claude import ClaudeLLMProvider
+
+            provider = ClaudeLLMProvider(self._config)
+            logger.debug("Initialized Claude provider")
+
+        elif name == "codex":
+            from gobby.llm.codex import CodexProvider
+
+            provider = CodexProvider(self._config)
+            logger.debug(f"Initialized Codex provider (auth_mode: {provider_config.auth_mode})")
+
+        elif name == "gemini":
+            from gobby.llm.gemini import GeminiProvider
+
+            provider = GeminiProvider(self._config)
+            logger.debug(f"Initialized Gemini provider (auth_mode: {provider_config.auth_mode})")
+
+        elif name == "litellm":
+            from gobby.llm.litellm import LiteLLMProvider
+
+            provider = LiteLLMProvider(self._config)
+            logger.debug("Initialized LiteLLM provider")
+
+        else:
+            raise ValueError(
+                f"Unknown provider '{name}'. Supported providers: claude, codex, gemini, litellm"
+            )
+
+        self._providers[name] = provider
+        self._initialized_providers.add(name)
+        return provider
+
+    def get_provider(self, name: str) -> "LLMProvider":
+        """
+        Get a provider by name.
+
+        Args:
+            name: Provider name (claude, codex, gemini, litellm)
+
+        Returns:
+            LLMProvider instance
+
+        Raises:
+            ValueError: If provider is not configured or not supported
+
+        Example:
+            claude = service.get_provider("claude")
+            result = await claude.generate_summary(context)
+        """
+        return self._get_provider_instance(name)
+
+    def get_provider_for_feature(
+        self, feature_config: Any
+    ) -> tuple["LLMProvider", str, str | None]:
+        """
+        Get provider, model, and prompt for a feature configuration.
+
+        Feature configs (SessionSummaryConfig, TitleSynthesisConfig, etc.) specify
+        which provider and model to use for that feature. This method returns
+        the appropriate provider instance along with the configured model and prompt.
+
+        Args:
+            feature_config: Feature configuration object with provider, model, and
+                           optionally prompt fields.
+
+        Returns:
+            Tuple of (provider, model, prompt) where:
+            - provider: LLMProvider instance
+            - model: Model name string
+            - prompt: Optional prompt template string (or None if not configured)
+
+        Raises:
+            ValueError: If feature config is missing required fields
+            ValueError: If specified provider is not configured
+
+        Example:
+            provider, model, prompt = service.get_provider_for_feature(config.session_summary)
+            result = await provider.generate_summary(context, prompt_template=prompt)
+        """
+        # Extract provider name from feature config
+        provider_name = getattr(feature_config, "provider", None)
+        if not provider_name:
+            raise ValueError(
+                f"Feature config {type(feature_config).__name__} missing 'provider' field"
+            )
+
+        # Extract model
+        model = getattr(feature_config, "model", None)
+        if not model:
+            raise ValueError(
+                f"Feature config {type(feature_config).__name__} missing 'model' field"
+            )
+
+        # Extract prompt (optional)
+        prompt = getattr(feature_config, "prompt", None)
+
+        # Get provider instance
+        provider = self._get_provider_instance(provider_name)
+
+        return provider, model, prompt
+
+    def get_default_provider(self) -> "LLMProvider":
+        """
+        Get the default provider (first enabled provider, preferring Claude).
+
+        Returns:
+            LLMProvider instance
+
+        Raises:
+            ValueError: If no providers are configured
+        """
+        if not self._config.llm_providers:
+            raise ValueError("llm_providers not configured")
+
+        enabled = self._config.llm_providers.get_enabled_providers()
+        if not enabled:
+            raise ValueError("No providers configured in llm_providers")
+
+        # Prefer Claude if available
+        if "claude" in enabled:
+            return self._get_provider_instance("claude")
+
+        # Otherwise use first available
+        return self._get_provider_instance(enabled[0])
+
+    @property
+    def enabled_providers(self) -> list[str]:
+        """Get list of enabled provider names."""
+        if not self._config.llm_providers:
+            return []
+        return self._config.llm_providers.get_enabled_providers()
+
+    @property
+    def initialized_providers(self) -> list[str]:
+        """Get list of providers that have been initialized (lazily loaded)."""
+        return list(self._initialized_providers)
+
+    def __repr__(self) -> str:
+        enabled = self.enabled_providers
+        initialized = self.initialized_providers
+        return f"LLMService(enabled={enabled}, initialized={initialized})"

gobby/mcp_proxy/__init__.py

@@ -0,0 +1,29 @@
+"""
+MCP (Model Context Protocol) package for gobby daemon.
+
+This package provides:
+- MCPClientManager: Multi-server connection management
+- MCPServerConfig: Server configuration dataclass
+- MCP actions: add/remove/list servers
+- create_mcp_server: FastMCP server factory
+"""
+
+from .manager import (
+    ConnectionState,
+    HealthState,
+    MCPClientManager,
+    MCPConnectionHealth,
+    MCPError,
+    MCPServerConfig,
+)
+from .server import create_mcp_server
+
+__all__ = [
+    "ConnectionState",
+    "HealthState",
+    "MCPClientManager",
+    "MCPConnectionHealth",
+    "MCPError",
+    "MCPServerConfig",
+    "create_mcp_server",
+]

gobby/mcp_proxy/actions.py

@@ -0,0 +1,175 @@
+"""
+MCP actions for local-first daemon.
+
+Provides simplified MCP server management without platform sync.
+"""
+
+import logging
+from typing import Any
+
+from gobby.mcp_proxy.manager import MCPClientManager, MCPServerConfig
+from gobby.tools.summarizer import generate_server_description
+
+logger = logging.getLogger(__name__)
+
+
+async def add_mcp_server(
+    mcp_manager: MCPClientManager,
+    name: str,
+    transport: str,
+    project_id: str,
+    url: str | None = None,
+    headers: dict[str, str] | None = None,
+    command: str | None = None,
+    args: list[str] | None = None,
+    env: dict[str, str] | None = None,
+    enabled: bool = True,
+    description: str | None = None,
+) -> dict[str, Any]:
+    """
+    Dynamically add a new MCP server connection.
+
+    Args:
+        mcp_manager: MCP client manager instance
+        name: Unique server name
+        transport: Transport type (http, stdio, websocket)
+        project_id: Required project ID - all servers must belong to a project
+        url: Server URL (for http/websocket)
+        headers: Custom HTTP headers
+        command: Command to run (for stdio)
+        args: Command arguments (for stdio)
+        env: Environment variables (for stdio)
+        enabled: Whether server is enabled
+        description: Optional server description
+
+    Returns:
+        Result dict with success status and server info
+    """
+    try:
+        # Normalize server name to lowercase
+        name = name.lower()
+
+        # Create configuration
+        config = MCPServerConfig(
+            name=name,
+            transport=transport,
+            url=url,
+            headers=headers,
+            command=command,
+            args=args,
+            env=env,
+            enabled=enabled,
+            description=description,
+            project_id=project_id,
+        )
+
+        # Add server via manager (connects and caches tools)
+        result = await mcp_manager.add_server(config)
+
+        if not result.get("success"):
+            return result
+
+        # Get full tool schemas from add_server result
+        full_tool_schemas = result.get("full_tool_schemas", [])
+
+        # Generate server description using AI if not provided
+        if not description and full_tool_schemas:
+            try:
+                server_description = await generate_server_description(
+                    server_name=name, tool_summaries=full_tool_schemas
+                )
+                config.description = server_description
+            except Exception as e:
+                logger.warning(f"Failed to generate server description: {e}")
+
+        logger.debug(f"Added MCP server: {name} ({transport})")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to add MCP server '{name}': {e}")
+        return {
+            "success": False,
+            "name": name,
+            "error": str(e),
+            "message": f"Failed to add server: {e}",
+        }
+
+
+async def remove_mcp_server(
+    mcp_manager: MCPClientManager,
+    name: str,
+    project_id: str,
+) -> dict[str, Any]:
+    """
+    Remove an MCP server.
+
+    Args:
+        mcp_manager: MCP client manager instance
+        name: Server name to remove
+        project_id: Required project ID
+
+    Returns:
+        Result dict with success status
+    """
+    try:
+        result = await mcp_manager.remove_server(name, project_id=project_id)
+        if result.get("success"):
+            logger.debug(f"Removed MCP server: {name} (project {project_id})")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to remove MCP server '{name}': {e}")
+        return {
+            "success": False,
+            "name": name,
+            "error": str(e),
+            "message": f"Failed to remove server: {e}",
+        }
+
+
+async def list_mcp_servers(
+    mcp_manager: MCPClientManager,
+) -> dict[str, Any]:
+    """
+    List all configured MCP servers.
+
+    Args:
+        mcp_manager: MCP client manager instance
+
+    Returns:
+        Dict with servers list and status. Each server includes:
+        - project_id: None for global servers, UUID string for project-scoped
+    """
+    try:
+        servers = []
+        for config in mcp_manager.server_configs:
+            health = mcp_manager.health.get(config.name)
+            servers.append(
+                {
+                    "name": config.name,
+                    "project_id": config.project_id,
+                    "transport": config.transport,
+                    "enabled": config.enabled,
+                    "url": config.url,
+                    "command": config.command,
+                    "description": config.description,
+                    "connected": config.name in mcp_manager.connections,
+                    "state": health.state.value if health else "unknown",
+                    "tools": config.tools or [],
+                }
+            )
+
+        return {
+            "success": True,
+            "servers": servers,
+            "total_count": len(servers),
+            "connected_count": len(mcp_manager.connections),
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to list MCP servers: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "servers": [],
+        }

gobby/mcp_proxy/daemon_control.py

@@ -0,0 +1,198 @@
+"""Daemon process control."""
+
+import asyncio
+import logging
+import os
+import signal
+import sys
+from typing import Any
+
+import httpx
+import psutil
+
+logger = logging.getLogger("gobby.daemon.control")
+
+
+async def check_daemon_http_health(port: int, timeout: float = 2.0) -> bool:
+    """Check if daemon is healthy via HTTP."""
+    try:
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(f"http://localhost:{port}/admin/status", timeout=timeout)
+            return resp.status_code == 200
+    except Exception:
+        return False
+
+
+def get_daemon_pid() -> int | None:
+    """Get PID of running daemon process."""
+    current_pid = os.getpid()
+    for proc in psutil.process_iter(["pid", "name", "cmdline"]):
+        try:
+            if proc.info["pid"] == current_pid:
+                continue
+
+            cmdline = proc.info["cmdline"]
+            if not cmdline:
+                continue
+
+            cmdline_str = " ".join(cmdline)
+            # Match either gobby.runner or gobby.cli daemon start
+            if "gobby.runner" in cmdline_str or (
+                "gobby.cli" in cmdline_str and "daemon" in cmdline_str
+            ):
+                from typing import cast
+
+                return cast(int, proc.info["pid"])
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            pass
+    return None
+
+
+def is_daemon_running() -> bool:
+    """Check if daemon is running."""
+    return get_daemon_pid() is not None
+
+
+async def start_daemon_process(port: int, websocket_port: int) -> dict[str, Any]:
+    """Start daemon in a new process."""
+    if is_daemon_running():
+        pid = get_daemon_pid()
+        return {
+            "success": False,
+            "already_running": True,
+            "pid": pid,
+            "message": f"Daemon is already running with PID {pid}",
+        }
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "gobby.cli.app",
+        "daemon",
+        "start",
+        "--port",
+        str(port),
+        "--websocket-port",
+        str(websocket_port),
+    ]
+
+    try:
+        # Use asyncio.create_subprocess_exec to avoid blocking the event loop
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        # Do NOT await communicate() - this blocks until exit.
+        # Instead, wait a brief moment to check for immediate crash.
+        await asyncio.sleep(0.5)
+
+        if proc.returncode is not None:
+            # Process exited immediately - capture output
+            stdout, stderr = await proc.communicate()
+            return {
+                "success": False,
+                "message": "Start failed - process exited immediately",
+                "error": stderr.decode().strip() if stderr else "Unknown error",
+            }
+
+        # Process is running - check health
+        if await check_daemon_http_health(port, timeout=5.0):
+            return {
+                "success": True,
+                "pid": proc.pid,
+                "output": "Daemon started successfully",
+            }
+
+        # If health check fails but process is still running, check pid directly
+        # This might happen if listening takes longer than health check
+        pid = get_daemon_pid()
+        if pid:
+            return {
+                "success": True,
+                "pid": pid,
+                "output": "Daemon started (health check pending)",
+            }
+
+        return {
+            "success": False,
+            "message": "Start failed - process running but unhealthy",
+            "error": "Health check timed out",
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e), "message": f"Failed to start: {e}"}
+
+
+async def stop_daemon_process(pid: int | None = None) -> dict[str, Any]:
+    """Stop running daemon."""
+    if pid is None:
+        pid = get_daemon_pid()
+
+    if not pid:
+        return {"success": False, "not_running": True, "message": "Daemon not running"}
+
+    timeout = 5.0
+    deadline = asyncio.get_running_loop().time() + timeout
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+
+        # Poll for termination
+        while True:
+            try:
+                os.kill(pid, 0)
+                if asyncio.get_running_loop().time() > deadline:
+                    return {
+                        "success": False,
+                        "error": "Process did not exit after SIGTERM",
+                        "message": "Stop timed out",
+                    }
+                await asyncio.sleep(0.1)
+            except ProcessLookupError:
+                # Process is gone
+                return {"success": True, "output": "Daemon stopped"}
+
+    except ProcessLookupError:
+        return {"success": False, "error": "Process not found", "not_running": True}
+    except PermissionError:
+        return {"success": False, "error": "Permission denied"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def restart_daemon_process(
+    current_pid: int | None, port: int, websocket_port: int
+) -> dict[str, Any]:
+    """Restart daemon."""
+    stop_result = await stop_daemon_process(current_pid)
+    if not stop_result.get("success") and not stop_result.get("not_running"):
+        return stop_result
+
+    # Wait for ports to be free with actual port checking
+    import socket
+
+    def is_port_free(p: int) -> bool:
+        """Check if a port is available by attempting to bind to it."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind(("127.0.0.1", p))
+                return True
+        except OSError:
+            return False
+
+    for _ in range(10):
+        if await asyncio.to_thread(is_port_free, port) and await asyncio.to_thread(
+            is_port_free, websocket_port
+        ):
+            break
+        await asyncio.sleep(0.5)
+    else:
+        return {
+            "success": False,
+            "error": f"Ports {port} and/or {websocket_port} not free after 10 retries",
+        }
+
+    return await start_daemon_process(port, websocket_port)